<style>
  :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; }
</style>
<script src="../../../resources/js-test-pre.js"></script>
<script>
globalThis.testRunner?.dumpAsText();
globalThis.testRunner?.waitUntilDone();

const log = globalThis.$vm?.print ?? 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 = [
`data:video/mp4;base64,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`,
`data:video/mp4;base64,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`,
`data:video/mp4;base64,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`,
`data:video/mp4;base64,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`,
];

/**
 * @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;
}

onload = async () => {
  try {
let adapter0 = await navigator.gpu.requestAdapter();
let adapter1 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth32float-stencil8',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxTextureDimension1D: 8192,
    maxBindGroupsPlusVertexBuffers: 24,
    minUniformBufferOffsetAlignment: 256,
    maxUniformBufferBindingSize: 60535231,
    maxStorageBufferBindingSize: 149422978,
  },
});
let bindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 65,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer0 = device0.createBuffer({size: 19613, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder0 = device0.createCommandEncoder({});
let querySet0 = device0.createQuerySet({label: '\u49d3\u{1f6b0}\u{1f882}\u0a5a\ue669', type: 'occlusion', count: 36});
let texture0 = device0.createTexture({
  size: [420, 1, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let commandEncoder1 = device0.createCommandEncoder({label: '\u6833\u0a06\u{1fa1b}\u9263\u02ff\u{1fc22}\u0202\u{1fe03}\u{1f8cd}\u5e54\u95bd'});
let texture1 = device0.createTexture({
  label: '\uca1e\u{1f9b6}\ub4ef\u0598\u33ba\u0834\u2bfe\u38eb\u0a9e\u{1fedb}\u{1fe1b}',
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture2 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 159},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
adapter1.label = '\u08d8\u{1fe8d}\u98e6\uaf91\uc67b\u09e8\u0737\udc51';
} catch {}
let bindGroupLayout1 = device0.createBindGroupLayout({
  label: '\u49e8\u6a7b\u036e\ue61f\uda56\u50aa\ua850\u6284',
  entries: [
    {
      binding: 102,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 453,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let buffer1 = device0.createBuffer({
  size: 20107,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture3 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler0 = device0.createSampler({
  label: '\u0bcf\u01be\u5a8d\u{1f637}\ub1fa\u11b4\u0e95\udd93\u{1f95d}\ubc5f',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMaxClamp: 89.84,
});
try {
commandEncoder1.copyBufferToBuffer(buffer1, 2368, buffer0, 28, 3068);
} catch {}
let imageData0 = new ImageData(40, 4);
let bindGroupLayout2 = device0.createBindGroupLayout({
  label: '\ua9a2\u7421',
  entries: [
    {
      binding: 265,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder2 = device0.createCommandEncoder();
let texture4 = device0.createTexture({
  size: [210, 1, 1],
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView0 = texture1.createView({dimension: '2d-array'});
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(100).fill(75), /* required buffer size: 100 */
{offset: 100, rowsPerImage: 65}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'film', transfer: 'bt1361ExtendedColourGamut'} });
let buffer2 = device0.createBuffer({
  label: '\u533e\u8a72\u066f',
  size: 13424,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let textureView1 = texture3.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true});
try {
renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 5_384, 1_001);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer1, 5712, new Float32Array(8135), 989, 144);
} catch {}
let promise0 = device0.queue.onSubmittedWorkDone();
let texture5 = device0.createTexture({
  size: [420, 1, 1],
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder0 = commandEncoder2.beginComputePass({label: '\u0c70\u13e6\ue469\u3bcc'});
let renderBundle0 = renderBundleEncoder0.finish({});
let sampler1 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 98.64,
  lodMaxClamp: 99.54,
  compare: 'greater',
  maxAnisotropy: 1,
});
let textureView2 = texture4.createView({format: 'r16float'});
let textureView3 = texture1.createView({
  label: '\u34d0\uff05\u0003\u4ef7\u2b6a\u002e\ufc20\u5f1a\u7c04\u6ac5\u09c0',
  dimension: '2d-array',
  arrayLayerCount: 1,
});
let computePassEncoder1 = commandEncoder0.beginComputePass({label: '\u0940\u{1fdbf}\u{1fcb3}\u0213\u4662\u{1fa0b}\ub1ed\ub2ac'});
try {
commandEncoder1.copyBufferToBuffer(buffer1, 4596, buffer0, 5804, 1716);
} catch {}
let commandEncoder3 = device0.createCommandEncoder({});
let textureView4 = texture5.createView({dimension: '2d-array'});
let computePassEncoder2 = commandEncoder3.beginComputePass({});
let sampler2 = device0.createSampler({
  label: '\u{1fcdd}\u368a\ud0f5\u5d80\uc63c\u{1fdc1}\ue9bd\u060b\u{1fa46}\u9c09',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 55.87,
  lodMaxClamp: 68.25,
});
try {
commandEncoder1.copyBufferToBuffer(buffer2, 2564, buffer1, 3720, 416);
} catch {}
try {
  await promise0;
} catch {}
let imageData1 = new ImageData(12, 40);
let bindGroup0 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 453, resource: textureView1},
    {binding: 102, resource: textureView2},
    {binding: 9, resource: textureView4},
  ],
});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView5 = texture5.createView({dimension: '2d-array', arrayLayerCount: 1});
let textureView6 = texture2.createView({mipLevelCount: 1});
try {
computePassEncoder1.setBindGroup(2, bindGroup0, new Uint32Array(3530), 540, 0);
} catch {}
let bindGroup1 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 102, resource: textureView2},
    {binding: 9, resource: textureView4},
    {binding: 453, resource: textureView1},
  ],
});
let texture6 = device0.createTexture({
  label: '\u{1fb24}\u8832\u5bc4\u2d4d\u2aed\u0675\ucae1\u0fce\u0331\u{1fedb}\ub361',
  size: [32, 32, 16],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(4933), 1_625, 0);
} catch {}
try {
querySet0.destroy();
} catch {}
let buffer3 = device0.createBuffer({size: 22727, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let textureView7 = texture6.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6});
let computePassEncoder3 = commandEncoder1.beginComputePass({});
let sampler3 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 94.57,
  lodMaxClamp: 97.51,
});
try {
computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(399), 0, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
await gc();
try {
adapter1.label = '\ud590\u35fd';
} catch {}
let buffer4 = device0.createBuffer({size: 18469, usage: GPUBufferUsage.COPY_SRC});
let texture7 = device0.createTexture({
  size: [72, 24, 1],
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView8 = texture6.createView({dimension: 'cube-array', baseMipLevel: 0, arrayLayerCount: 6});
let sampler4 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 92.51,
});
try {
computePassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(433), 9, 0);
} catch {}
let textureView9 = texture7.createView({mipLevelCount: 1});
let sampler5 = device0.createSampler({
  label: '\u1fa0\udcf1\u{1fcdf}\u09d1\u0bb9\u3b7c\u08bf',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 12.15,
  lodMaxClamp: 84.85,
  compare: 'equal',
  maxAnisotropy: 8,
});
try {
computePassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(1951), 114, 0);
} catch {}
try {
computePassEncoder2.end();
} catch {}
try {
commandEncoder3.copyBufferToBuffer(buffer1, 2988, buffer0, 1460, 636);
} catch {}
let sampler6 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 72.66,
  lodMaxClamp: 88.85,
});
try {
buffer0.unmap();
} catch {}
try {
commandEncoder3.clearBuffer(buffer2);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 228, new Int16Array(49639), 1342, 16);
} catch {}
let commandEncoder4 = device0.createCommandEncoder({});
let texture8 = device0.createTexture({size: [288, 96, 1], mipLevelCount: 1, format: 'r8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
computePassEncoder0.setBindGroup(3, bindGroup0);
} catch {}
try {
commandEncoder4.copyTextureToTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 10, y: 3, z: 15},
  aspect: 'all',
},
{
  texture: texture1,
  mipLevel: 0,
  origin: {x: 6, y: 2, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder5 = device0.createCommandEncoder({label: '\u0c5e\u0f29\u083d\u0ba8\u1b38\udaa8\u15ae\u0781\u{1f6e1}\u9f69'});
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
commandEncoder3.copyTextureToBuffer({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {
  /* bytesInLastRow: 420 widthInBlocks: 420 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 344 */
  offset: 344,
  buffer: buffer2,
}, {width: 420, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder6 = device0.createCommandEncoder({});
let texture9 = device0.createTexture({
  size: [288, 96, 1],
  sampleCount: 1,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView10 = texture5.createView({});
let computePassEncoder4 = commandEncoder6.beginComputePass({});
let sampler7 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 14.87,
  lodMaxClamp: 73.66,
  compare: 'less',
});
try {
commandEncoder3.copyBufferToBuffer(buffer1, 716, buffer2, 4076, 108);
} catch {}
let commandEncoder7 = device0.createCommandEncoder({});
let texture10 = device0.createTexture({
  label: '\u7240\u{1f9a9}\u{1fee4}\u17f0\ua736',
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder5 = commandEncoder4.beginComputePass({});
let sampler8 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 6.596,
  maxAnisotropy: 14,
});
try {
buffer2.unmap();
} catch {}
let commandEncoder8 = device0.createCommandEncoder({});
let texture11 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
commandEncoder5.copyBufferToBuffer(buffer1, 5464, buffer2, 460, 936);
} catch {}
try {
  await adapter1.requestAdapterInfo();
} catch {}
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView11 = texture5.createView({
  label: '\u{1ff61}\u{1fb86}\u{1fba1}\u7adc\uc3a4\u0b8f\u082f\u0b86\u{1ff10}\ufc0b',
  dimension: '2d-array',
  aspect: 'depth-only',
  mipLevelCount: 1,
});
let computePassEncoder6 = commandEncoder5.beginComputePass();
let commandEncoder9 = device0.createCommandEncoder({label: '\ud9eb\u526e'});
let computePassEncoder7 = commandEncoder7.beginComputePass({});
try {
commandEncoder8.copyBufferToBuffer(buffer1, 3752, buffer0, 76, 2724);
} catch {}
try {
commandEncoder8.copyTextureToBuffer({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 114 widthInBlocks: 57 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1490 */
  offset: 1490,
  buffer: buffer1,
}, {width: 57, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer5 = device0.createBuffer({
  size: 6588,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder10 = device0.createCommandEncoder({});
let sampler9 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMaxClamp: 46.04,
  compare: 'not-equal',
});
let texture12 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 25},
  mipLevelCount: 3,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
computePassEncoder4.setBindGroup(0, bindGroup1);
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer5, offset: 256, size: 56}}],
});
let buffer6 = device0.createBuffer({
  size: 5102,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder11 = device0.createCommandEncoder({label: '\u0289\ua5df\uf6f6\ub554'});
let texture13 = device0.createTexture({
  size: {width: 39, height: 66, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder8 = commandEncoder10.beginComputePass({});
try {
buffer3.unmap();
} catch {}
let sampler10 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 26.36,
  lodMaxClamp: 28.56,
  maxAnisotropy: 16,
});
let canvas0 = document.createElement('canvas');
let bindGroup3 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 9, resource: textureView11},
    {binding: 453, resource: textureView1},
    {binding: 102, resource: textureView2},
  ],
});
let commandEncoder12 = device0.createCommandEncoder({});
let sampler11 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 52.49,
  lodMaxClamp: 92.03,
  compare: 'less-equal',
});
try {
computePassEncoder1.setBindGroup(1, bindGroup2);
} catch {}
try {
commandEncoder11.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1174 */
  offset: 1174,
  bytesPerRow: 512,
  buffer: buffer4,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 35, y: 1, z: 0},
  aspect: 'all',
}, {width: 16, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer7 = device0.createBuffer({
  label: '\u0d80\u{1fe71}\ua13a\ud768\uf157\u0fd3',
  size: 11596,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder9 = commandEncoder9.beginComputePass({});
try {
computePassEncoder6.setBindGroup(1, bindGroup2);
} catch {}
try {
computePassEncoder3.setBindGroup(1, bindGroup2, new Uint32Array(5671), 595, 0);
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
try {
  await promise1;
} catch {}
let buffer8 = device0.createBuffer({
  size: 11615,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture14 = device0.createTexture({
  label: '\u{1fd50}\u8d1b\u12ba\u9b28\u1664\u06d3\u053d',
  size: [288, 96, 1],
  format: 'astc-12x12-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
  await buffer0.mapAsync(GPUMapMode.READ, 2384, 536);
} catch {}
let video0 = await videoWithData(3);
let buffer9 = device0.createBuffer({
  size: 452,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: true,
});
let commandEncoder13 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(2, bindGroup3);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(399).fill(134), /* required buffer size: 399 */
{offset: 399}, {width: 113, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext0 = canvas0.getContext('webgpu');
let commandEncoder14 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(2, bindGroup1, new Uint32Array(2115), 952, 0);
} catch {}
try {
commandEncoder11.copyTextureToTexture({
  texture: texture2,
  mipLevel: 2,
  origin: {x: 24, y: 0, z: 8},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 8, y: 12, z: 0},
  aspect: 'all',
},
{width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let sampler12 = device0.createSampler({
  label: '\u2485\ub867\u5ac5\u{1fd78}',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 9.632,
});
try {
computePassEncoder9.setBindGroup(2, bindGroup0);
} catch {}
try {
computePassEncoder1.setBindGroup(3, bindGroup0, new Uint32Array(2993), 238, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 4612, new Float32Array(2482), 791, 200);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder12.copyBufferToTexture({
  /* bytesInLastRow: 304 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2896 */
  offset: 2592,
  buffer: buffer1,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {width: 228, height: 12, depthOrArrayLayers: 1});
} catch {}
let buffer10 = device0.createBuffer({
  label: '\ua4f7\u065d\u070c\u8dfc\u{1ff56}\u{1fbf4}\u6480\u{1ff0d}\u{1fcf4}',
  size: 6276,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView12 = texture3.createView({dimension: '2d', format: 'r8sint', baseMipLevel: 0, mipLevelCount: 1});
let textureView13 = texture8.createView({dimension: '2d-array', aspect: 'all'});
let renderPassEncoder0 = commandEncoder8.beginRenderPass({colorAttachments: [{view: textureView13, loadOp: 'clear', storeOp: 'discard'}]});
try {
renderPassEncoder0.setBindGroup(3, bindGroup1, new Uint32Array(2889), 259, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 61, y: 26 },
  flipY: true,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandBuffer0 = commandEncoder11.finish({label: '\uf60c\uc2ab\u5c3d\u5c9a\u313f\u6bf6\u0021\u7ac9\ue993\u{1f8fe}'});
let texture15 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 22},
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder10 = commandEncoder13.beginComputePass({});
let sampler13 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 18.56,
  lodMaxClamp: 34.63,
  maxAnisotropy: 16,
});
try {
computePassEncoder10.setBindGroup(1, bindGroup0, new Uint32Array(97), 36, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint32', 7_496, 64);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder3.copyBufferToBuffer(buffer4, 72, buffer10, 1468, 1044);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup4 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView8}]});
let textureView14 = texture2.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1});
let computePassEncoder11 = commandEncoder12.beginComputePass({});
try {
computePassEncoder1.setBindGroup(2, bindGroup2, new Uint32Array(248), 32, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer5, 'uint32', 1_660, 1_707);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let buffer11 = device0.createBuffer({size: 21840, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder15 = device0.createCommandEncoder({});
let textureView15 = texture14.createView({});
try {
computePassEncoder6.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer11, 'uint32', 5_188, 1_794);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 1648, new DataView(new ArrayBuffer(48665)), 3631, 4536);
} catch {}
try {
device0.queue.label = '\u871f\u{1f618}\u01d8\ufb52\u0222\u4a6c';
} catch {}
let texture16 = device0.createTexture({size: {width: 105}, dimension: '1d', format: 'rgba32sint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder3.setBindGroup(2, bindGroup1, new Uint32Array(369), 55, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup1, new Uint32Array(993), 111, 0);
} catch {}
try {
commandEncoder3.resolveQuerySet(querySet0, 2, 2, buffer1, 1280);
} catch {}
let texture17 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder12 = commandEncoder14.beginComputePass({});
try {
computePassEncoder3.setBindGroup(0, bindGroup1, new Uint32Array(1949), 191, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup1, new Uint32Array(4964), 22, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 5944, new DataView(new ArrayBuffer(14761)), 3077, 576);
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let texture18 = device0.createTexture({
  size: {width: 144, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView16 = texture13.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder13 = commandEncoder3.beginComputePass({});
let renderPassEncoder1 = commandEncoder15.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -683.5, g: -635.0, b: 46.61, a: 979.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let sampler14 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 30.66,
  lodMaxClamp: 82.97,
  maxAnisotropy: 8,
});
try {
computePassEncoder3.setBindGroup(1, bindGroup0, new Uint32Array(1877), 73, 0);
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\u7f2e');
} catch {}
let sampler15 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.65,
  maxAnisotropy: 16,
});
try {
computePassEncoder6.setBindGroup(1, bindGroup3);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer11, 0);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer1, 4696, new BigUint64Array(1643), 1092, 160);
} catch {}
document.body.prepend(video0);
let commandEncoder16 = device0.createCommandEncoder({});
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 359});
try {
computePassEncoder7.setBindGroup(1, bindGroup3);
} catch {}
try {
computePassEncoder1.setBindGroup(2, bindGroup2, new Uint32Array(2129), 303, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer8, 'uint16', 1_274, 3_894);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(25).fill(0), /* required buffer size: 25 */
{offset: 25}, {width: 47, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(video0);
let commandBuffer1 = commandEncoder16.finish({label: '\u0ce3\u{1fa8d}\u{1f8f6}\uc530\u1116\uac89\u048f\u{1facc}'});
let texture19 = device0.createTexture({
  size: [288, 96, 1],
  mipLevelCount: 5,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderPassEncoder1.setVertexBuffer(3, buffer10, 208);
} catch {}
try {
computePassEncoder10.insertDebugMarker('\u5064');
} catch {}
let texture20 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView17 = texture8.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder1.end();
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'smpte240m'} });
let texture21 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder3.setBindGroup(2, bindGroup4, new Uint32Array(8642), 696, 0);
} catch {}
try {
computePassEncoder3.end();
} catch {}
try {
renderPassEncoder0.end();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 210, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder17 = device0.createCommandEncoder();
let textureView18 = texture14.createView({dimension: '2d-array'});
let sampler16 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.93,
  maxAnisotropy: 16,
});
try {
computePassEncoder5.setBindGroup(2, bindGroup2, new Uint32Array(583), 184, 0);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
let bindGroup5 = device0.createBindGroup({
  label: '\u{1f8c2}\u440b\u{1fdb5}\ubb84\u662c',
  layout: bindGroupLayout0,
  entries: [{binding: 65, resource: textureView7}],
});
let commandEncoder18 = device0.createCommandEncoder({});
let texture22 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 1},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView19 = texture9.createView({label: '\u42bb\u831b\u4ccb\u1dfc'});
try {
computePassEncoder5.setBindGroup(1, bindGroup0, []);
} catch {}
document.body.prepend(canvas0);
let buffer12 = device0.createBuffer({
  size: 25020,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView20 = texture13.createView({format: 'rgba32sint', mipLevelCount: 1});
let computePassEncoder14 = commandEncoder1.beginComputePass({});
let renderPassEncoder2 = commandEncoder17.beginRenderPass({
  colorAttachments: [{
  view: textureView17,
  clearValue: { r: -955.6, g: 401.2, b: 271.8, a: -384.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let externalTexture0 = device0.importExternalTexture({label: '\u160e\uf2ac\u{1fb77}\u0305\u10bc\u56c8\ucf78\u{1fb0c}\u722d\u{1fd69}', source: videoFrame1});
try {
computePassEncoder5.setBindGroup(3, bindGroup5, new Uint32Array(2922), 625, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle0, renderBundle0, renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer12, 'uint32', 6_508, 4_640);
} catch {}
try {
commandEncoder18.copyTextureToBuffer({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 1, y: 5, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 28 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 6440 */
  offset: 268,
  bytesPerRow: 512,
  buffer: buffer2,
}, {width: 14, height: 13, depthOrArrayLayers: 1});
} catch {}
document.body.append(video0);
let commandEncoder19 = device0.createCommandEncoder({});
try {
computePassEncoder13.setBindGroup(0, bindGroup3, new Uint32Array(71), 21, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder2.setViewport(155.64713885236762, 46.72039303486815, 40.15420910693222, 49.07784202131771, 0.49548604204251656, 0.8332288736650542);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer11, 'uint32', 148, 4_124);
} catch {}
let bindGroup6 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView8}]});
let renderPassEncoder3 = commandEncoder18.beginRenderPass({
  colorAttachments: [{
  view: textureView17,
  clearValue: { r: -286.2, g: -391.0, b: 965.2, a: 78.82, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 221882928,
});
try {
computePassEncoder14.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer11, 0, 322);
} catch {}
let buffer13 = device0.createBuffer({
  size: 954,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder20 = device0.createCommandEncoder({});
let computePassEncoder15 = commandEncoder19.beginComputePass({});
try {
renderPassEncoder3.setBindGroup(3, bindGroup3, new Uint32Array(5858), 512, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer10);
} catch {}
let commandEncoder21 = device0.createCommandEncoder({});
let texture23 = device0.createTexture({
  label: '\u090a\ub311\u{1f96e}\u{1f680}\u{1fa36}\u02a1',
  size: [32],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder16 = commandEncoder20.beginComputePass({});
try {
computePassEncoder9.setBindGroup(1, bindGroup0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
try {
textureView19.label = '\u0f18\ue53e';
} catch {}
let textureView21 = texture13.createView({mipLevelCount: 1});
let computePassEncoder17 = commandEncoder21.beginComputePass({});
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  colorSpace: 'display-p3',
});
} catch {}
let texture24 = device0.createTexture({
  size: {width: 32},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
renderPassEncoder2.setBindGroup(2, bindGroup1, new Uint32Array(1150), 110, 0);
} catch {}
try {
renderPassEncoder2.setStencilReference(1646);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer7, 'uint16', 640, 61);
} catch {}
try {
computePassEncoder1.pushDebugGroup('\u0348');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
try {
  await promise2;
} catch {}
let buffer14 = device0.createBuffer({
  size: 5253,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder22 = device0.createCommandEncoder({label: '\u08f9\u0e50\u25fd\u7fa8'});
let renderPassEncoder4 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView17,
  clearValue: { r: 851.6, g: 218.5, b: -123.8, a: -669.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 18833032,
});
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
document.body.prepend(video0);
let bindGroup7 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView7}]});
let buffer15 = device0.createBuffer({size: 761, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder23 = device0.createCommandEncoder({});
let computePassEncoder18 = commandEncoder23.beginComputePass({});
try {
renderPassEncoder4.setBindGroup(1, bindGroup5, new Uint32Array(2598), 268, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture11,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData2 = new ImageData(28, 24);
let textureView22 = texture8.createView({label: '\uf345\u{1fdd4}\u0d05\u{1fdc9}', arrayLayerCount: 1});
try {
computePassEncoder1.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas0);
let sampler17 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 33.80,
  lodMaxClamp: 47.45,
});
try {
renderPassEncoder4.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder2.setViewport(179.41301973164784, 46.86664567324412, 16.645026584822418, 4.795354506399104, 0.06473618652482682, 0.9665869605562047);
} catch {}
try {
computePassEncoder0.insertDebugMarker('\ud6de');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise3;
} catch {}
let commandEncoder24 = device0.createCommandEncoder({});
let querySet2 = device0.createQuerySet({label: '\u3d64\u{1fd7b}\u{1fe74}\ue6c5\u6035\u4fe3', type: 'occlusion', count: 704});
let computePassEncoder19 = commandEncoder24.beginComputePass({});
try {
computePassEncoder7.setBindGroup(3, bindGroup2, new Uint32Array(230), 8, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup7, []);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer12, 'uint32', 3_148, 1_381);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 12, y: 0 },
  flipY: true,
}, {
  texture: texture11,
  mipLevel: 1,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData3 = new ImageData(152, 44);
let commandEncoder25 = device0.createCommandEncoder();
let computePassEncoder20 = commandEncoder25.beginComputePass({label: '\u{1fcf1}\u0a0b\u810d\u70ce\u5eca\u0b9b\ua14d\u0a6c'});
try {
computePassEncoder1.setBindGroup(3, bindGroup2, []);
} catch {}
try {
computePassEncoder15.setBindGroup(1, bindGroup0, new Uint32Array(183), 29, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup2, new Uint32Array(2023), 202, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer8, 'uint32', 144, 1_659);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer2, 1_760, 488);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 96, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 0, y: 4 },
  flipY: false,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 10, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 5, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(454, 414);
try {
offscreenCanvas0.getContext('bitmaprenderer');
} catch {}
let commandEncoder26 = device0.createCommandEncoder({});
let textureView23 = texture4.createView({});
let computePassEncoder21 = commandEncoder26.beginComputePass({});
try {
renderPassEncoder3.setBindGroup(0, bindGroup5, new Uint32Array(1751), 396, 0);
} catch {}
try {
renderPassEncoder2.setStencilReference(1577);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer1, 'uint16', 356, 2_617);
} catch {}
let commandEncoder27 = device0.createCommandEncoder();
let textureView24 = texture10.createView({});
try {
computePassEncoder15.setBindGroup(0, bindGroup5, new Uint32Array(281), 66, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer7, 'uint16', 2_680, 175);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer2);
} catch {}
try {
commandEncoder27.copyBufferToBuffer(buffer1, 748, buffer13, 196, 24);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 112, new BigUint64Array(8765), 423, 16);
} catch {}
let computePassEncoder22 = commandEncoder27.beginComputePass({label: '\ub7d7\u0616\u06af\u080a\u0f89\ua8ac\u2e95\u{1ffdb}'});
try {
renderPassEncoder4.setBindGroup(3, bindGroup3, new Uint32Array(2342), 512, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer7, 'uint16', 5_438, 2_492);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, buffer11, 0);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
video0.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let bindGroup8 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer14, offset: 2560, size: 132}}],
});
try {
renderPassEncoder3.setBindGroup(2, bindGroup3, new Uint32Array(607), 26, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer11, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(368).fill(136), /* required buffer size: 368 */
{offset: 368, bytesPerRow: 646, rowsPerImage: 143}, {width: 40, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
await gc();
let sampler18 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 50.64,
  lodMaxClamp: 96.75,
  compare: 'less',
  maxAnisotropy: 6,
});
try {
computePassEncoder4.setBindGroup(2, bindGroup8);
} catch {}
try {
computePassEncoder7.setBindGroup(2, bindGroup1, new Uint32Array(670), 70, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder4.setScissorRect(8, 26, 46, 5);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer2, 1_184);
} catch {}
try {
buffer14.unmap();
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder2.setViewport(205.4871983279737, 77.4577080490041, 0.8287260106851418, 7.3496903428880795, 0.1656452653931203, 0.6368126903066897);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(80).fill(192), /* required buffer size: 80 */
{offset: 80}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData4 = new ImageData(56, 32);
try {
window.someLabel = device0.label;
} catch {}
let bindGroup9 = device0.createBindGroup({label: '\u8efa\ufe04', layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView7}]});
let buffer16 = device0.createBuffer({size: 2063, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder28 = device0.createCommandEncoder({});
let computePassEncoder23 = commandEncoder28.beginComputePass({});
try {
computePassEncoder21.setBindGroup(2, bindGroup5);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup5);
} catch {}
try {
buffer14.unmap();
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas0);
let bindGroup10 = device0.createBindGroup({
  label: '\u0391\u8791\u9949\u0354\u56bc',
  layout: bindGroupLayout0,
  entries: [{binding: 65, resource: textureView7}],
});
let buffer17 = device0.createBuffer({
  size: 9836,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder29 = device0.createCommandEncoder({label: '\u36d1\u{1f867}\u0eeb\u45e2\uf08d\uf797'});
let texture25 = device0.createTexture({
  size: {width: 9},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView25 = texture9.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder20.setBindGroup(2, bindGroup4);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
buffer11.unmap();
} catch {}
try {
renderPassEncoder2.insertDebugMarker('\u{1fee2}');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 2,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(1_352).fill(173), /* required buffer size: 1_352 */
{offset: 72, bytesPerRow: 8, rowsPerImage: 80}, {width: 8, height: 0, depthOrArrayLayers: 3});
} catch {}
let bindGroup11 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView7}]});
let commandEncoder30 = device0.createCommandEncoder({});
let computePassEncoder24 = commandEncoder29.beginComputePass();
try {
renderPassEncoder3.setVertexBuffer(2, buffer11);
} catch {}
document.body.prepend(canvas0);
let buffer18 = device0.createBuffer({
  size: 9440,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView26 = texture6.createView({arrayLayerCount: 5});
let computePassEncoder25 = commandEncoder30.beginComputePass({});
try {
renderPassEncoder3.setBindGroup(2, bindGroup9, new Uint32Array(613), 316, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer13, 'uint16', 12, 163);
} catch {}
let buffer19 = device0.createBuffer({size: 189, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder2.setVertexBuffer(6, buffer10, 412, 2_197);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 48, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 16, y: 117 },
  flipY: true,
}, {
  texture: texture11,
  mipLevel: 1,
  origin: {x: 22, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame2 = new VideoFrame(video0, {timestamp: 0});
try {
device0.queue.label = '\u5f6c\u{1fc38}\u{1f88e}\u0077\ud96a\u4307\u{1fc24}\ufa2d\ucf30';
} catch {}
let bindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 15,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup12 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 453, resource: textureView12},
    {binding: 102, resource: textureView15},
    {binding: 9, resource: textureView11},
  ],
});
try {
computePassEncoder14.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup12, new Uint32Array(3030), 147, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 57, y: 4 },
  flipY: true,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 39, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup13 = device0.createBindGroup({
  label: '\u{1f9a6}\u{1f6b4}\u11be',
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer18, offset: 0}}],
});
let querySet3 = device0.createQuerySet({
  label: '\u00a5\u8cd8\u23db\u071a\u66c1\ufbe0\u7065\ub499\u0ca7\u0de9\ua570',
  type: 'occlusion',
  count: 249,
});
let texture26 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup13);
} catch {}
document.body.prepend(video0);
let texture27 = device0.createTexture({
  size: [420],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder4.setBindGroup(1, bindGroup13);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer1, 'uint32', 3_492, 1_390);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(6, buffer2, 0, 675);
} catch {}
try {
computePassEncoder1.popDebugGroup();
} catch {}
let bindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 228,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 172, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
  ],
});
let buffer20 = device0.createBuffer({size: 1126, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder31 = device0.createCommandEncoder({});
let renderPassEncoder5 = commandEncoder31.beginRenderPass({
  label: '\u07ef\u{1fe0c}\u90a0\u021a\ub4a4\u{1f6b4}\ud1ab\u0528\u1f91',
  colorAttachments: [{
  view: textureView24,
  clearValue: { r: -182.7, g: -378.0, b: -60.35, a: 266.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 207305325,
});
try {
renderPassEncoder4.setBlendConstant({ r: -439.8, g: -776.4, b: -881.8, a: 895.7, });
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer7, 'uint16', 564, 426);
} catch {}
let buffer21 = device0.createBuffer({size: 19081, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let commandEncoder32 = device0.createCommandEncoder({});
try {
renderPassEncoder5.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup2, new Uint32Array(7749), 1_187, 0);
} catch {}
let img0 = await imageWithData(64, 27, '#10101010', '#20202020');
let commandEncoder33 = device0.createCommandEncoder({});
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer12, 'uint16', 7_308, 6_356);
} catch {}
let arrayBuffer0 = buffer0.getMappedRange(2384, 4);
try {
commandEncoder33.copyTextureToTexture({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 54, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture16,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer16, 752, new Float32Array(3318), 1575, 16);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise5;
} catch {}
let renderPassEncoder6 = commandEncoder33.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: 696.7, g: 371.9, b: 172.5, a: 88.53, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 295440756,
});
let sampler19 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.39,
  lodMaxClamp: 82.28,
  maxAnisotropy: 11,
});
let externalTexture1 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
renderPassEncoder4.setBindGroup(0, bindGroup9);
} catch {}
try {
window.someLabel = querySet1.label;
} catch {}
let bindGroup14 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView8}]});
let commandEncoder34 = device0.createCommandEncoder({});
let querySet4 = device0.createQuerySet({label: '\u1b40\u5cd6\u098b\u0575\u787f', type: 'occlusion', count: 1189});
let computePassEncoder26 = commandEncoder32.beginComputePass({});
try {
commandEncoder34.copyTextureToBuffer({
  texture: texture19,
  mipLevel: 2,
  origin: {x: 5, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 96 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 5136 */
  offset: 5136,
  bytesPerRow: 256,
  buffer: buffer1,
}, {width: 12, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 0,
  origin: {x: 98, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 4298 */
  offset: 4298,
  bytesPerRow: 768,
  rowsPerImage: 68,
  buffer: buffer21,
}, {
  texture: texture26,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['stencil8'],
  colorSpace: 'srgb',
});
} catch {}
let imageData5 = new ImageData(88, 4);
let textureView27 = texture4.createView({dimension: '2d-array'});
let computePassEncoder27 = commandEncoder34.beginComputePass({label: '\u{1f608}\u864c\ue0c1\u0eb6\ue494'});
try {
computePassEncoder26.setBindGroup(1, bindGroup4, new Uint32Array(1858), 86, 0);
} catch {}
let arrayBuffer1 = buffer0.getMappedRange(2584, 84);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture11,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder35 = device0.createCommandEncoder({});
let texture28 = device0.createTexture({
  size: {width: 2900, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'astc-10x6-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView28 = texture4.createView({dimension: '2d-array'});
let computePassEncoder28 = commandEncoder35.beginComputePass({label: '\u0839\u0a8b\u2669\ud4b8\u{1ff9a}\u{1f676}\u0576'});
try {
computePassEncoder27.setBindGroup(1, bindGroup5, new Uint32Array(4461), 1_352, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup8, new Uint32Array(4592), 593, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder36 = device0.createCommandEncoder({});
let texture29 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 397},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView29 = texture20.createView({dimension: '2d-array'});
let computePassEncoder29 = commandEncoder36.beginComputePass({});
let sampler20 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 40.98,
  lodMaxClamp: 91.66,
});
let externalTexture2 = device0.importExternalTexture({source: video0});
try {
computePassEncoder26.setBindGroup(3, bindGroup10);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup14, new Uint32Array(41), 7, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let texture30 = device0.createTexture({size: {width: 39}, dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.STORAGE_BINDING});
try {
renderPassEncoder4.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup3, new Uint32Array(147), 21, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer7, 'uint16', 526, 642);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, buffer12, 0);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST, colorSpace: 'display-p3'});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['stencil8'],
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(56).fill(234), /* required buffer size: 56 */
{offset: 56}, {width: 108, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture31 = device0.createTexture({
  size: [32, 32, 16],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture3 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder25.setBindGroup(2, bindGroup10);
} catch {}
try {
computePassEncoder0.setBindGroup(3, bindGroup14, new Uint32Array(2821), 550, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroupLayout5 = device0.createBindGroupLayout({
  label: '\u9de4\u{1fa1d}\u{1fbec}\u7fd4\u119d\u308e\u5057\u{1f77d}',
  entries: [
    {
      binding: 18,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let buffer22 = device0.createBuffer({
  size: 1279,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView30 = texture29.createView({label: '\u94e6\u{1ff1e}\u0838\u70d3', dimension: '3d', baseMipLevel: 0});
try {
renderPassEncoder6.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint16', 610, 3_523);
} catch {}
try {
  await promise6;
} catch {}
let externalTexture4 = device0.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder2.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer16, 'uint32', 436, 174);
} catch {}
let bindGroup15 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer10, offset: 0, size: 1048}}],
});
let texture32 = device0.createTexture({
  label: '\u004b\u02ab\u3dfe\u0861',
  size: [288],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView31 = texture12.createView({dimension: '2d', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder5.setBindGroup(0, bindGroup0);
} catch {}
let commandEncoder37 = device0.createCommandEncoder({});
let computePassEncoder30 = commandEncoder37.beginComputePass({});
try {
computePassEncoder6.setBindGroup(0, bindGroup9, new Uint32Array(1214), 109, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle0]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 48, y: 12, z: 0},
  aspect: 'all',
}, new Uint8Array(460).fill(114), /* required buffer size: 460 */
{offset: 460, rowsPerImage: 179}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise4;
} catch {}
let buffer23 = device0.createBuffer({size: 24232, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder6.setVertexBuffer(7, buffer12, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer13, 356, new Int16Array(13261), 4334, 12);
} catch {}
let texture33 = device0.createTexture({
  size: [144, 48, 1],
  sampleCount: 1,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup5, new Uint32Array(236), 8, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup14);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 336, new BigUint64Array(49505), 1682, 28);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 96, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 53, y: 329 },
  flipY: true,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 24, y: 35, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 60, height: 3, depthOrArrayLayers: 0});
} catch {}
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 293});
let textureView32 = texture6.createView({dimension: 'cube'});
try {
renderPassEncoder6.setIndexBuffer(buffer22, 'uint16', 34, 276);
} catch {}
try {
computePassEncoder0.setBindGroup(1, bindGroup10, new Uint32Array(2163), 195, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(5, buffer11, 320);
} catch {}
let buffer24 = device0.createBuffer({size: 3662, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let commandEncoder38 = device0.createCommandEncoder({});
try {
computePassEncoder24.setBindGroup(3, bindGroup11, new Uint32Array(3988), 632, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer13, 'uint16', 336, 81);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer13, 0, 164);
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 448 */
  offset: 448,
  bytesPerRow: 512,
  rowsPerImage: 1106,
  buffer: buffer18,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 1, y: 6 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
try {
device0.queue.label = '\u{1fd25}\u97e8\u{1f846}\u0ac1';
} catch {}
let bindGroup16 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView8}]});
let buffer25 = device0.createBuffer({
  size: 3608,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let commandEncoder39 = device0.createCommandEncoder({});
let texture34 = device0.createTexture({
  size: [210, 1, 32],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView33 = texture14.createView({dimension: '2d-array'});
let sampler21 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 77.35,
});
try {
device0.queue.writeBuffer(buffer18, 184, new Int16Array(5782), 1702);
} catch {}
let buffer26 = device0.createBuffer({
  size: 8001,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView34 = texture25.createView({mipLevelCount: 1});
let computePassEncoder31 = commandEncoder38.beginComputePass({});
try {
renderPassEncoder2.setBindGroup(2, bindGroup16);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup8, new Uint32Array(839), 168, 0);
} catch {}
await gc();
let buffer27 = device0.createBuffer({size: 21516, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true});
let textureView35 = texture6.createView({label: '\u088a\u08f5\ufba3\u0d16\u04e0\uf81f\u01b6', dimension: 'cube', baseArrayLayer: 1});
let computePassEncoder32 = commandEncoder39.beginComputePass({});
try {
computePassEncoder27.setBindGroup(2, bindGroup13);
} catch {}
try {
computePassEncoder14.setBindGroup(1, bindGroup9, new Uint32Array(1949), 293, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup7, new Uint32Array(1223), 163, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
let buffer28 = device0.createBuffer({
  size: 19019,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let externalTexture5 = device0.importExternalTexture({source: video0});
try {
computePassEncoder6.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup16, new Uint32Array(189), 8, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer28, 'uint16', 3_560, 8_141);
} catch {}
let buffer29 = device0.createBuffer({
  size: 50484,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder40 = device0.createCommandEncoder({});
let texture35 = device0.createTexture({
  size: {width: 19, height: 33, depthOrArrayLayers: 35},
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder33 = commandEncoder40.beginComputePass({});
try {
renderPassEncoder2.setVertexBuffer(1, buffer13);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeBuffer(buffer14, 460, new Int16Array(5123), 486, 20);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 19, y: 5 },
  flipY: true,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 63, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 32, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 659});
let sampler22 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 89.26,
  lodMaxClamp: 91.25,
  maxAnisotropy: 15,
});
try {
renderPassEncoder3.setIndexBuffer(buffer28, 'uint32', 1_476, 1_004);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer2, 0, 1_009);
} catch {}
try {
computePassEncoder5.pushDebugGroup('\u0333');
} catch {}
let canvas1 = document.createElement('canvas');
let bindGroup17 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 15, resource: {buffer: buffer5, offset: 0}}]});
try {
computePassEncoder5.setBindGroup(1, bindGroup11);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle0]);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer30 = device0.createBuffer({
  size: 1199,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder8.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(49).fill(98), /* required buffer size: 49 */
{offset: 49}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let sampler23 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMaxClamp: 85.04,
});
try {
computePassEncoder23.setBindGroup(1, bindGroup17);
} catch {}
try {
computePassEncoder28.setBindGroup(3, bindGroup16, new Uint32Array(584), 67, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup9, new Uint32Array(906), 1, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer8, 'uint32', 356, 3_635);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
video0.height = 16;
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'log'} });
let texture36 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView36 = texture20.createView({aspect: 'all', baseMipLevel: 0, arrayLayerCount: 1});
let sampler24 = device0.createSampler({
  label: '\u86fb\ue0b3\ue6b0',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 4.018,
  lodMaxClamp: 75.33,
});
try {
renderPassEncoder2.setVertexBuffer(3, buffer13, 0, 70);
} catch {}
let bindGroup18 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView10}]});
let pipelineLayout3 = device0.createPipelineLayout({label: '\u7ea0\ua2ec\uc354\u056a\u92b5', bindGroupLayouts: [bindGroupLayout4, bindGroupLayout5]});
let buffer31 = device0.createBuffer({
  label: '\u1564\u{1ffa4}\ufe82\u2b2d',
  size: 4051,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM,
});
let texture37 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rg32float'],
});
try {
computePassEncoder17.setBindGroup(1, bindGroup15, []);
} catch {}
try {
computePassEncoder8.setBindGroup(2, bindGroup6, new Uint32Array(1521), 457, 0);
} catch {}
try {
computePassEncoder5.popDebugGroup();
} catch {}
let img1 = await imageWithData(3, 12, '#10101010', '#20202020');
let sampler25 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.90,
});
try {
computePassEncoder14.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder6.end();
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer22, 'uint16', 58, 114);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer21, 6112, new Float32Array(1793), 528, 264);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 19, y: 31 },
  flipY: false,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 4, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 7, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
window.someLabel = externalTexture3.label;
} catch {}
let bindGroup19 = device0.createBindGroup({
  label: '\u{1fdf2}\u{1f9c9}',
  layout: bindGroupLayout4,
  entries: [
    {binding: 228, resource: {buffer: buffer14, offset: 512, size: 8}},
    {binding: 172, resource: sampler23},
  ],
});
let externalTexture6 = device0.importExternalTexture({source: video0});
try {
renderPassEncoder3.setVertexBuffer(6, undefined, 0, 358_084_494);
} catch {}
try {
device0.queue.submit([]);
} catch {}
canvas0.width = 45;
try {
window.someLabel = externalTexture1.label;
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 143 max align: 1 */
struct T0 {
  @align(1) @size(7) f0: f16,
  @align(1) @size(9) f1: atomic<i32>,
  @align(1) @size(127) f2: array<atomic<i32>>,
}
@id(5465) override override3 : u32;
@id(58123) override override1 : i32 = 56;
override override5 : i32 = -10;
@id(4628) override override2 : bool = false;
override override0 : f32 = -0.8236;
@id(3554) override override4 : u32;
@id(53048) override override6 : bool;
@group(0) @binding(228) var<storage, read_write> buffer32: T0;
@group(0) @binding(172) var sam0: sampler;
@group(1) @binding(18) var tex0: texture_depth_2d;

@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(global_invocation_id) a0: vec3u) {
  _ = override5;
}`,
  sourceMap: {},
});
let bindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 86,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 277,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
  ],
});
let buffer33 = device0.createBuffer({
  size: 4742,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture38 = device0.createTexture({
  size: [840],
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView37 = texture22.createView({dimension: '2d-array'});
try {
computePassEncoder22.setBindGroup(1, bindGroup12);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup12);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
buffer12.unmap();
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let texture39 = device0.createTexture({
  label: '\u0431\ucada\u{1fd16}',
  size: [19],
  sampleCount: 1,
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle0]);
} catch {}
try {
window.someLabel = externalTexture1.label;
} catch {}
let textureView38 = texture39.createView({dimension: '1d', aspect: 'all', format: 'r32uint', baseMipLevel: 0});
let texture40 = device0.createTexture({
  size: {width: 288},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView39 = texture13.createView({mipLevelCount: 1, baseArrayLayer: 0});
let sampler26 = device0.createSampler({
  label: '\u23fd\u{1fab5}\u2456\u{1f6ab}\u0d35\uee79\u0207',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 55.02,
  lodMaxClamp: 64.17,
  compare: 'less',
});
try {
renderPassEncoder3.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder2.end();
} catch {}
try {
buffer4.unmap();
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup3, new Uint32Array(3184), 71, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer28, 'uint16', 13_056, 953);
} catch {}
try {
window.someLabel = externalTexture6.label;
} catch {}
let commandEncoder41 = device0.createCommandEncoder({});
let commandBuffer2 = commandEncoder41.finish({label: '\u043e\ue586\u17d7\u51e0\u{1f8ad}\u846d\u2f45\u{1fc29}\u536d\u0307'});
let texture41 = device0.createTexture({
  label: '\u3416\ubf74',
  size: [9, 16, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder18.setBindGroup(3, bindGroup16, new Uint32Array(2239), 143, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup12, new Uint32Array(285), 26, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let bindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {binding: 145, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 328,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 110,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
  ],
});
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout2]});
let texture42 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder8.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer30, 0, 51);
} catch {}
try {
buffer14.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder42 = device0.createCommandEncoder({});
let textureView40 = texture34.createView({label: '\u0310\ud467\u2d3e\ud4b8\u{1f855}\uc4c6\u{1ff92}\ufa37\u{1f8ac}', mipLevelCount: 1});
let renderPassEncoder7 = commandEncoder42.beginRenderPass({
  colorAttachments: [{
  view: textureView24,
  clearValue: { r: -943.3, g: 563.3, b: 534.3, a: 946.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder4.setScissorRect(73, 63, 72, 12);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, buffer13, 0, 378);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(7).fill(68), /* required buffer size: 7 */
{offset: 7, bytesPerRow: 55}, {width: 26, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext1 = canvas1.getContext('webgpu');
try {
computePassEncoder33.setBindGroup(1, bindGroup8);
} catch {}
try {
computePassEncoder9.setBindGroup(2, bindGroup6, new Uint32Array(12), 0, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer5, 'uint32', 972, 477);
} catch {}
let imageBitmap0 = await createImageBitmap(imageData3);
let buffer34 = device0.createBuffer({size: 848, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
try {
renderPassEncoder3.setBindGroup(0, bindGroup11, new Uint32Array(23), 1, 0);
} catch {}
let buffer35 = device0.createBuffer({
  size: 2816,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture43 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let texture44 = gpuCanvasContext0.getCurrentTexture();
try {
renderPassEncoder3.setBindGroup(2, bindGroup12);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 453, resource: textureView36},
    {binding: 9, resource: textureView18},
    {binding: 102, resource: textureView23},
  ],
});
try {
computePassEncoder31.setBindGroup(2, bindGroup18);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup10, new Uint32Array(87), 4, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer29, 'uint32', 2_576, 10_195);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer30);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
try {
device0.queue.writeBuffer(buffer30, 100, new DataView(new ArrayBuffer(20807)), 2357, 132);
} catch {}
let imageBitmap1 = await createImageBitmap(imageData2);
let texture45 = device0.createTexture({
  label: '\uf646\ub6aa\u2c98',
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView41 = texture13.createView({dimension: '2d-array', mipLevelCount: 1});
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(21_124).fill(42), /* required buffer size: 21_124 */
{offset: 82, bytesPerRow: 63, rowsPerImage: 167}, {width: 10, height: 0, depthOrArrayLayers: 3});
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let pipeline0 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
try {
computePassEncoder18.setBindGroup(1, bindGroup6);
} catch {}
try {
computePassEncoder27.setBindGroup(1, bindGroup10, new Uint32Array(1605), 105, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 2572, new BigUint64Array(10750), 92, 140);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 4, y: 27 },
  flipY: true,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 47, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder43 = device0.createCommandEncoder({});
let texture46 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder34 = commandEncoder43.beginComputePass({});
try {
computePassEncoder21.setBindGroup(0, bindGroup9, new Uint32Array(2728), 600, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer1, 'uint32', 6_984, 2_195);
} catch {}
try {
computePassEncoder11.insertDebugMarker('\u8cba');
} catch {}
await gc();
let bindGroup21 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 15, resource: {buffer: buffer10, offset: 256}}]});
let commandEncoder44 = device0.createCommandEncoder({});
let texture47 = device0.createTexture({
  size: [290, 20, 1],
  mipLevelCount: 3,
  format: 'astc-10x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView42 = texture26.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder10.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder15.setBindGroup(1, bindGroup0, new Uint32Array(347), 16, 0);
} catch {}
try {
computePassEncoder34.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer22, 'uint16', 54, 152);
} catch {}
try {
commandEncoder44.copyBufferToBuffer(buffer21, 4920, buffer30, 304, 92);
} catch {}
try {
commandEncoder44.copyTextureToBuffer({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 1, y: 4, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1048 */
  offset: 1048,
  buffer: buffer18,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let texture48 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  dimension: '2d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let texture49 = gpuCanvasContext1.getCurrentTexture();
let textureView43 = texture28.createView({aspect: 'all', mipLevelCount: 1});
try {
renderPassEncoder4.setBindGroup(3, bindGroup11);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer34, 0, 90);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 2, y: 2 },
  flipY: false,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 23, height: 1, depthOrArrayLayers: 0});
} catch {}
video0.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let buffer36 = device0.createBuffer({
  label: '\u{1fefc}\u{1fd9f}\u{1f6c7}\ud12e\u{1f9b6}\u4c2b\u035f\u0f52\u0f49\u85a3',
  size: 25452,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
});
let texture50 = device0.createTexture({
  label: '\u{1fa16}\uff85\u0ee5',
  size: [210],
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView44 = texture4.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder24.setBindGroup(3, bindGroup9);
} catch {}
try {
computePassEncoder24.setBindGroup(2, bindGroup11, new Uint32Array(408), 221, 0);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer12, 'uint16', 3_570, 1_967);
} catch {}
try {
device0.queue.writeBuffer(buffer16, 428, new Int16Array(5194), 287, 176);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise7;
} catch {}
let computePassEncoder35 = commandEncoder44.beginComputePass();
try {
computePassEncoder24.setBindGroup(3, bindGroup9);
} catch {}
try {
  await buffer15.mapAsync(GPUMapMode.WRITE, 0, 48);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup9);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer20, 'uint32', 44, 337);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer11, 0, 2_374);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
let bindGroup22 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 265, resource: {buffer: buffer9, offset: 0}}]});
let buffer37 = device0.createBuffer({
  label: '\u02ab\u9e8a\u{1fbaf}\u0e82\u7925\u01ca\u{1fdd0}',
  size: 4200,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let sampler27 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 52.25,
  lodMaxClamp: 58.42,
  compare: 'never',
});
try {
computePassEncoder24.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer26, 'uint32', 808, 591);
} catch {}
try {
buffer24.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 3, y: 5 },
  flipY: false,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 6, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder45 = device0.createCommandEncoder({});
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
let arrayBuffer2 = buffer29.getMappedRange(0, 23032);
try {
commandEncoder45.copyTextureToBuffer({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 7, y: 7, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 19 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 4573 */
  offset: 4573,
  bytesPerRow: 256,
  buffer: buffer10,
}, {width: 19, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder3.insertDebugMarker('\u7d4c');
} catch {}
try {
device0.queue.writeBuffer(buffer19, 8, new Int16Array(38244), 9799, 4);
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 23 max align: 1 */
struct T0 {
  @align(1) @size(23) f0: vec4f,
}
/* target size: 16 max align: 16 */
struct T1 {
  @size(16) f0: i32,
}
/* target size: 23 max align: 1 */
struct T2 {
  @align(1) @size(3) f0: f16,
  @align(1) @size(20) f1: vec4f,
}
override override14 : f32 = -0.8613;
@id(13366) override override7 : bool;
override override13 : i32;
@id(11852) override override8 : i32;
@id(39019) override override11 : u32;
override override10 : f16 = -28933.6;
@id(57407) override override12 : i32 = 288;
@id(25195) override override9 : bool = false;
@group(0) @binding(265) var<storage, read_write> buffer38: array<T2>;

@vertex
fn vertex0() -> @builtin(position) vec4f {
  var out: vec4f;
  _ = override9;
  _ = override11;
  return out;
}`,
  hints: {},
});
let buffer39 = device0.createBuffer({
  size: 2679,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder9.setBindGroup(3, bindGroup0);
} catch {}
let bindGroup23 = device0.createBindGroup({
  label: '\u4284\u0514\u09c1\u0ccf\u{1f74a}\u8093\ue0c4\u0220\uecbc\u08b8',
  layout: bindGroupLayout6,
  entries: [{binding: 277, resource: textureView38}, {binding: 86, resource: sampler21}],
});
let textureView45 = texture34.createView({format: 'rgba32sint', mipLevelCount: 1});
let computePassEncoder36 = commandEncoder45.beginComputePass({});
let sampler28 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMaxClamp: 85.91,
});
try {
renderPassEncoder4.setBindGroup(3, bindGroup15);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer17, 4_916, 31);
} catch {}
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'gamma28curve'} });
let textureView46 = texture5.createView({dimension: '2d-array'});
try {
computePassEncoder20.setBindGroup(3, bindGroup22);
} catch {}
try {
computePassEncoder17.setBindGroup(2, bindGroup7, new Uint32Array(2166), 224, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer16, 'uint32', 116, 652);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
renderPassEncoder3.pushDebugGroup('\u05ae');
} catch {}
await gc();
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup10);
} catch {}
let arrayBuffer3 = buffer9.getMappedRange(8, 28);
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture51 = device0.createTexture({
  size: {width: 420, height: 1, depthOrArrayLayers: 47},
  mipLevelCount: 5,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler29 = device0.createSampler({
  label: '\ub440\u6e53\u{1fc68}\u{1fc95}\u93be\u38a0\u{1fe3b}\u825a\u{1f775}\u04ae\uef91',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 74.15,
  lodMaxClamp: 91.11,
});
try {
computePassEncoder15.setBindGroup(3, bindGroup10, new Uint32Array(2678), 282, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup19, new Uint32Array(1796), 272, 0);
} catch {}
try {
window.someLabel = computePassEncoder2.label;
} catch {}
let texture52 = device0.createTexture({
  size: {width: 9},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], stencilReadOnly: true});
let renderBundle1 = renderBundleEncoder1.finish({label: '\uf824\u61df\u0769\ua8c0\u8967\udd1d\u{1fd68}\ude1e\u1970'});
let sampler30 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 21.22,
  lodMaxClamp: 66.10,
  maxAnisotropy: 18,
});
try {
computePassEncoder10.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, buffer34);
} catch {}
try {
renderPassEncoder7.insertDebugMarker('\u0704');
} catch {}
let buffer40 = device0.createBuffer({
  size: 21276,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let textureView47 = texture6.createView({dimension: 'cube', baseArrayLayer: 4});
let texture53 = device0.createTexture({size: [78, 132, 1], format: 'r8unorm', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder28.setBindGroup(0, bindGroup13);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup18, []);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint16', 12_366, 2_886);
} catch {}
try {
  await promise8;
} catch {}
document.body.append(video0);
try {
textureView25.label = '\uba9e\u2e41\u81fb\u691e\u7bf1\u41f3\uc765\u{1f61e}';
} catch {}
let commandEncoder46 = device0.createCommandEncoder({});
let texture54 = device0.createTexture({
  size: {width: 19},
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture55 = device0.createTexture({
  size: {width: 420},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let renderPassEncoder8 = commandEncoder46.beginRenderPass({
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: 382.2, g: -461.6, b: -298.9, a: 968.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder35.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup18);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.prepend(video0);
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte432', transfer: 'pq'} });
let commandEncoder47 = device0.createCommandEncoder();
let computePassEncoder37 = commandEncoder47.beginComputePass({});
try {
computePassEncoder18.setBindGroup(2, bindGroup14);
} catch {}
try {
computePassEncoder10.setBindGroup(3, bindGroup8, new Uint32Array(810), 443, 0);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup20);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer8, 'uint32', 7_668, 1_451);
} catch {}
try {
renderPassEncoder7.insertDebugMarker('\ue158');
} catch {}
let commandEncoder48 = device0.createCommandEncoder({});
let querySet7 = device0.createQuerySet({type: 'occlusion', count: 245});
let texture56 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 8},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView48 = texture24.createView({});
let computePassEncoder38 = commandEncoder48.beginComputePass({});
try {
renderPassEncoder7.setBindGroup(0, bindGroup11);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer7, 'uint32', 1_264, 4_120);
} catch {}
try {
renderPassEncoder3.popDebugGroup();
} catch {}
let pipeline1 = await device0.createComputePipelineAsync({label: '\ubcd4\u8bdc\ud7cd\u5fa9\u8b35', layout: pipelineLayout3, compute: {module: shaderModule0}});
let commandEncoder49 = device0.createCommandEncoder({label: '\u{1fabb}\uf81e'});
let texture57 = device0.createTexture({
  size: [210, 1, 1],
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder33.setBindGroup(2, bindGroup2, new Uint32Array(1601), 205, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup19, new Uint32Array(11), 1, 0);
} catch {}
let arrayBuffer4 = buffer25.getMappedRange(0, 676);
let imageData6 = new ImageData(32, 8);
let bindGroup24 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView9}]});
let sampler31 = device0.createSampler({label: '\u{1fc22}\u6972\u{1f850}\u04c3', addressModeU: 'clamp-to-edge', lodMaxClamp: 97.35});
try {
computePassEncoder14.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 1552, new DataView(new ArrayBuffer(13671)), 901, 2808);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap1,
  origin: { x: 1, y: 2 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView49 = texture13.createView({mipLevelCount: 1});
let computePassEncoder39 = commandEncoder49.beginComputePass({});
let bindGroup25 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer26, offset: 1536, size: 1372}}],
});
let buffer41 = device0.createBuffer({
  label: '\u3609\u5286',
  size: 27613,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView50 = texture54.createView({});
let texture58 = device0.createTexture({size: [32, 32, 16], dimension: '2d', format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder23.setBindGroup(3, bindGroup19);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let textureView51 = texture48.createView({label: '\u0fed\u{1fd89}\u556c\u0cb2\u0f91\u{1fec0}\ud453', dimension: 'cube', baseArrayLayer: 2});
try {
device0.pushErrorScope('internal');
} catch {}
let arrayBuffer5 = buffer9.getMappedRange(0, 0);
document.body.prepend(video0);
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 246});
let texture59 = device0.createTexture({
  size: [72, 24, 1],
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView52 = texture6.createView({baseArrayLayer: 3, arrayLayerCount: 1});
try {
computePassEncoder25.setBindGroup(1, bindGroup4, new Uint32Array(285), 41, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup8, []);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup19, new Uint32Array(2366), 1_732, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer25, 'uint16', 56, 1_321);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer35, 280);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
let bindGroup26 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView9}]});
let commandEncoder50 = device0.createCommandEncoder({});
let computePassEncoder40 = commandEncoder50.beginComputePass({});
let sampler32 = device0.createSampler({addressModeW: 'mirror-repeat', mipmapFilter: 'nearest', lodMinClamp: 61.36, lodMaxClamp: 87.12});
let externalTexture7 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'});
try {
computePassEncoder24.setBindGroup(2, bindGroup5);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup11, new Uint32Array(901), 173, 0);
} catch {}
try {
renderPassEncoder3.setViewport(33.79223377674566, 22.293974658486444, 107.81136512754443, 45.00193840472067, 0.21089880108780446, 0.5200477192310429);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer40, 308, 2_984);
} catch {}
let commandEncoder51 = device0.createCommandEncoder();
let renderPassEncoder9 = commandEncoder51.beginRenderPass({colorAttachments: [{view: textureView17, loadOp: 'load', storeOp: 'store'}]});
let sampler33 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 52.85,
  lodMaxClamp: 69.24,
  maxAnisotropy: 20,
});
try {
computePassEncoder7.setBindGroup(0, bindGroup10);
} catch {}
try {
computePassEncoder13.setBindGroup(0, bindGroup20, new Uint32Array(4905), 2_730, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer29, 0, 19_026);
} catch {}
try {
device0.queue.writeBuffer(buffer16, 52, new Int16Array(20410), 2129, 108);
} catch {}
let commandEncoder52 = device0.createCommandEncoder();
let texture60 = device0.createTexture({
  label: '\u90f3\u0567\udf74\u0aa7',
  size: [39, 66, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder1.setPipeline(pipeline1);
} catch {}
let commandEncoder53 = device0.createCommandEncoder();
let commandBuffer3 = commandEncoder53.finish({});
let textureView53 = texture39.createView({mipLevelCount: 1});
let computePassEncoder41 = commandEncoder52.beginComputePass({});
let sampler34 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMinClamp: 2.917,
  lodMaxClamp: 58.56,
});
let externalTexture8 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder11.setBindGroup(2, bindGroup13, new Uint32Array(4917), 1_513, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup8, new Uint32Array(2492), 135, 0);
} catch {}
try {
  await promise9;
} catch {}
let bindGroup27 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 102, resource: textureView43},
    {binding: 9, resource: textureView46},
    {binding: 453, resource: textureView1},
  ],
});
let textureView54 = texture52.createView({label: '\u{1f8a3}\u0d99\u81d0\u{1fcbc}\u2dbd\u9274\u0daa\u8ede'});
let sampler35 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 41.84,
  lodMaxClamp: 79.60,
  compare: 'less-equal',
  maxAnisotropy: 19,
});
try {
computePassEncoder39.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup26, []);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer26, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder54 = device0.createCommandEncoder({});
let texture61 = device0.createTexture({
  label: '\u2aea\u7967',
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder42 = commandEncoder54.beginComputePass({});
try {
computePassEncoder39.setBindGroup(1, bindGroup12, new Uint32Array(1556), 362, 0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup13, new Uint32Array(561), 88, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder4.setScissorRect(45, 3, 23, 3);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer26, 'uint16', 1_680, 2_935);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer21, 1712, new DataView(new ArrayBuffer(5591)), 813, 1352);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup28 = device0.createBindGroup({
  label: '\u16b0\u{1ffcc}\u0065\u{1f7d4}\u0692\u{1fa6d}',
  layout: bindGroupLayout1,
  entries: [
    {binding: 102, resource: textureView24},
    {binding: 9, resource: textureView33},
    {binding: 453, resource: textureView39},
  ],
});
let texture62 = device0.createTexture({
  size: {width: 840},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler36 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 61.20,
  lodMaxClamp: 92.50,
});
try {
computePassEncoder27.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup12);
} catch {}
let bindGroup29 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 110, resource: sampler31},
    {binding: 328, resource: {buffer: buffer33, offset: 2304, size: 833}},
    {binding: 145, resource: sampler0},
  ],
});
let textureView55 = texture38.createView({});
try {
renderPassEncoder7.executeBundles([renderBundle0, renderBundle0]);
} catch {}
let bindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 191,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 100,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
  ],
});
let bindGroup30 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 328, resource: {buffer: buffer35, offset: 512, size: 9}},
    {binding: 145, resource: sampler34},
    {binding: 110, resource: sampler13},
  ],
});
let buffer42 = device0.createBuffer({
  label: '\u{1fbb8}\u071d\u86d3\uc161\u{1fec3}\u1dae\ucc4b\u{1fe8e}\u2d3b',
  size: 24346,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let textureView56 = texture39.createView({aspect: 'all', mipLevelCount: 1});
let sampler37 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 5.840,
  lodMaxClamp: 14.49,
  maxAnisotropy: 3,
});
try {
computePassEncoder31.setBindGroup(1, bindGroup16);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline1);
} catch {}
try {
buffer41.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer0, 5424, new DataView(new ArrayBuffer(29260)), 7074, 2736);
} catch {}
try {
adapter0.label = '\u8cd1\u2f02\u09dc\u6cbf';
} catch {}
let commandEncoder55 = device0.createCommandEncoder({});
let textureView57 = texture5.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 0});
let textureView58 = texture51.createView({mipLevelCount: 1});
try {
computePassEncoder18.setBindGroup(1, bindGroup26);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup3, new Uint32Array(1271), 2, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer16, 'uint16', 578, 447);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer26, 20, 64);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['bgra8unorm'],
  colorSpace: 'display-p3',
});
} catch {}
document.body.append(img1);
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: []});
let computePassEncoder43 = commandEncoder55.beginComputePass({});
try {
renderPassEncoder7.setVertexBuffer(1, buffer5);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
document.body.append(canvas0);
let commandEncoder56 = device0.createCommandEncoder({});
let texture63 = device0.createTexture({
  label: '\u{1fdaf}\u9127\u79e4',
  size: {width: 420, height: 1, depthOrArrayLayers: 6},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler38 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 48.21,
  lodMaxClamp: 73.80,
});
try {
computePassEncoder4.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup27, new Uint32Array(3869), 2_414, 0);
} catch {}
try {
buffer10.unmap();
} catch {}
try {
commandEncoder56.clearBuffer(buffer27);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 520, new Float32Array(8190), 1738, 48);
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpteRp431', transfer: 'iec6196624'} });
try {
  await adapter0.requestAdapterInfo();
} catch {}
let externalTexture9 = device0.importExternalTexture({source: videoFrame2});
try {
computePassEncoder35.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup13, new Uint32Array(6420), 1_270, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer26, 580, 415);
} catch {}
try {
commandEncoder56.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 73, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let commandEncoder57 = device0.createCommandEncoder({});
let texture64 = device0.createTexture({
  size: [32, 32, 16],
  mipLevelCount: 2,
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder10 = commandEncoder56.beginRenderPass({
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: 757.5, g: -321.4, b: -769.1, a: -237.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder8.setBindGroup(0, bindGroup14, new Uint32Array(873), 76, 0);
} catch {}
try {
renderPassEncoder9.setStencilReference(324);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer22, 'uint32', 92, 228);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 110, y: 26, z: 0},
  aspect: 'all',
}, new Uint8Array(220).fill(46), /* required buffer size: 220 */
{offset: 220, bytesPerRow: 98, rowsPerImage: 38}, {width: 37, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u{1ff1b}\u{1f6ef}\u5238\ud208\u976b\u09a2\u02bb\u5c80\u8d55\u{1f77e}';
} catch {}
let computePassEncoder44 = commandEncoder57.beginComputePass({label: '\u0d8b\u093d\u{1feaf}\u2187\uc7c6'});
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(7, undefined);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 20, z: 0},
  aspect: 'all',
}, new Uint8Array(375).fill(126), /* required buffer size: 375 */
{offset: 375, bytesPerRow: 201, rowsPerImage: 30}, {width: 25, height: 27, depthOrArrayLayers: 0});
} catch {}
let commandEncoder58 = device0.createCommandEncoder({});
let texture65 = device0.createTexture({
  label: '\u073e\uba5b\u{1f8f5}\u0b4d\u6e50\u0a84\u{1f7d6}\u7e93',
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView59 = texture43.createView({dimension: '2d-array', baseArrayLayer: 0});
let sampler39 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 17.92,
  lodMaxClamp: 75.02,
});
try {
computePassEncoder0.end();
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer7, 'uint16', 726, 1_596);
} catch {}
let buffer43 = device0.createBuffer({
  size: 14510,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 128});
let texture66 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 7},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView60 = texture63.createView({mipLevelCount: 1});
let computePassEncoder45 = commandEncoder2.beginComputePass({});
try {
computePassEncoder45.setBindGroup(2, bindGroup18, new Uint32Array(866), 48, 0);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(5, buffer29, 3_288, 2_129);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
commandEncoder58.copyTextureToBuffer({
  texture: texture11,
  mipLevel: 1,
  origin: {x: 31, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 39 widthInBlocks: 39 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 492 */
  offset: 492,
  bytesPerRow: 768,
  buffer: buffer14,
}, {width: 39, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture43,
  mipLevel: 0,
  origin: {x: 1, y: 5, z: 0},
  aspect: 'all',
},
{
  texture: texture31,
  mipLevel: 0,
  origin: {x: 6, y: 2, z: 0},
  aspect: 'all',
},
{width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer10, 52, new DataView(new ArrayBuffer(38352)), 6950, 264);
} catch {}
let buffer44 = device0.createBuffer({
  size: 5778,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView61 = texture38.createView({});
let computePassEncoder46 = commandEncoder58.beginComputePass({});
let sampler40 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  lodMinClamp: 4.484,
  lodMaxClamp: 20.98,
});
try {
computePassEncoder17.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup8);
} catch {}
try {
buffer43.unmap();
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(135, 225);
let videoFrame7 = new VideoFrame(videoFrame4, {timestamp: 0});
let textureView62 = texture32.createView({dimension: '1d', format: 'rg32float'});
let texture67 = device0.createTexture({
  label: '\u055f\u0b4d\u0d5d\u05e9\u0bcf\u8d5e\ua3aa\u{1fe4b}\u{1fdaf}\u3ed5',
  size: [105, 1, 8],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder10.setVertexBuffer(4_294_967_294, undefined);
} catch {}
let querySet10 = device0.createQuerySet({type: 'occlusion', count: 2230});
try {
computePassEncoder42.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup16, new Uint32Array(5900), 2_865, 0);
} catch {}
try {
renderPassEncoder10.end();
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer11, 'uint16', 520, 7_133);
} catch {}
let bindGroup31 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 328, resource: {buffer: buffer17, offset: 1024}},
    {binding: 110, resource: sampler12},
    {binding: 145, resource: sampler38},
  ],
});
let commandEncoder59 = device0.createCommandEncoder({label: '\u00a0\u0cf5\u7ed0\u03b7\u0ea8\uac70\u012c\ubd56'});
try {
computePassEncoder9.setBindGroup(2, bindGroup23);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer12, 760, 155);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 6, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView63 = texture4.createView({dimension: '2d-array', arrayLayerCount: 1});
let computePassEncoder47 = commandEncoder59.beginComputePass({});
try {
computePassEncoder40.setPipeline(pipeline0);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 16, y: 8 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 20, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData7 = new ImageData(56, 24);
let querySet11 = device0.createQuerySet({type: 'occlusion', count: 611});
let texture68 = device0.createTexture({size: {width: 78}, dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder10.setBindGroup(1, bindGroup16, new Uint32Array(3916), 78, 0);
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: -353.0, g: -113.2, b: -138.7, a: -561.4, });
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer17, 0, 432);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let textureView64 = texture61.createView({mipLevelCount: 1});
try {
renderPassEncoder9.setBindGroup(1, bindGroup28, new Uint32Array(1924), 279, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer20, 'uint16', 8, 154);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(137).fill(55), /* required buffer size: 137 */
{offset: 137, bytesPerRow: 26}, {width: 3, height: 5, depthOrArrayLayers: 0});
} catch {}
let buffer45 = device0.createBuffer({size: 7198, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let sampler41 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 92.97,
  lodMaxClamp: 99.98,
  maxAnisotropy: 1,
});
try {
renderPassEncoder7.setBindGroup(1, bindGroup15);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); };
} catch {}
video0.width = 30;
video0.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
try {
externalTexture0.label = '\u9086\u779f\u06d4\u0756\u0067\u6c6d\u09a4\u0151\u{1fbe4}';
} catch {}
let commandEncoder60 = device0.createCommandEncoder({label: '\u{1f9fa}\u{1f60c}\u0e3f\u{1f98c}\u0792\u194d\u0c20'});
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 528});
let computePassEncoder48 = commandEncoder60.beginComputePass({});
try {
computePassEncoder17.setBindGroup(3, bindGroup15, new Uint32Array(1422), 712, 0);
} catch {}
try {
computePassEncoder6.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup24, new Uint32Array(942), 181, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer12, 0);
} catch {}
try {
  await buffer0.mapAsync(GPUMapMode.READ, 3080, 1488);
} catch {}
let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu');
try {
computePassEncoder28.setPipeline(pipeline1);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let offscreenCanvas2 = new OffscreenCanvas(356, 120);
try {
texture52.label = '\u9ea1\u0ed3\u0ce0';
} catch {}
let bindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 313,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 388, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 21,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 56,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 33,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 103,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 309,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 528, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 57,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32float', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 286,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 159,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 238, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {
      binding: 151,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let texture69 = device0.createTexture({
  size: [840],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture70 = device0.createTexture({
  label: '\u{1fc3f}\u{1fb39}\u0348\u6144\ueab9\uc182\uff70\ue646\u1303',
  size: {width: 32, height: 32, depthOrArrayLayers: 575},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder36.setBindGroup(1, bindGroup27, new Uint32Array(7270), 25, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup27);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup14, new Uint32Array(203), 8, 0);
} catch {}
document.body.prepend(video0);
let imageData8 = new ImageData(116, 44);
let buffer46 = device0.createBuffer({size: 9017, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX, mappedAtCreation: false});
let commandEncoder61 = device0.createCommandEncoder({});
let textureView65 = texture69.createView({label: '\ua4ae\u6e11\u168b'});
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle0]);
} catch {}
let querySet13 = device0.createQuerySet({type: 'occlusion', count: 671});
try {
renderPassEncoder3.setVertexBuffer(6, buffer35, 0);
} catch {}
try {
computePassEncoder46.pushDebugGroup('\u9082');
} catch {}
let commandEncoder62 = device0.createCommandEncoder({});
let textureView66 = texture37.createView({dimension: '2d'});
let renderPassEncoder11 = commandEncoder61.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: -398.5, g: -829.7, b: 306.9, a: -381.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], depthReadOnly: true});
try {
renderPassEncoder7.setBindGroup(2, bindGroup29, new Uint32Array(5274), 256, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer26, 'uint32', 464, 295);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer24, 'uint32', 768, 90);
} catch {}
try {
commandEncoder62.copyBufferToBuffer(buffer20, 232, buffer27, 12176, 200);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 2408, new Float32Array(13133), 1791, 1164);
} catch {}
let textureView67 = texture52.createView({});
let computePassEncoder49 = commandEncoder62.beginComputePass({});
try {
computePassEncoder5.setBindGroup(2, bindGroup8);
} catch {}
try {
computePassEncoder18.setBindGroup(3, bindGroup10, new Uint32Array(745), 289, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup2, new Uint32Array(1711), 83, 0);
} catch {}
try {
renderPassEncoder11.setScissorRect(11, 3, 0, 2);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer12, 'uint16', 9_158, 8_005);
} catch {}
let buffer47 = device0.createBuffer({
  size: 6376,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
try {
renderPassEncoder11.setBindGroup(3, bindGroup6, new Uint32Array(2482), 660, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup26, []);
} catch {}
let videoFrame8 = videoFrame0.clone();
let commandEncoder63 = device0.createCommandEncoder({label: '\u2242\ufae6\u36e2\u0007\u34e1\u{1fce4}\u094a'});
let computePassEncoder50 = commandEncoder63.beginComputePass({});
let renderBundle2 = renderBundleEncoder2.finish({label: '\ud5aa\u069a'});
try {
renderPassEncoder4.setBindGroup(0, bindGroup7, new Uint32Array(194), 47, 0);
} catch {}
try {
renderPassEncoder11.setBlendConstant({ r: 741.5, g: 403.1, b: 398.4, a: -433.6, });
} catch {}
try {
renderPassEncoder11.setVertexBuffer(4, buffer2);
} catch {}
let arrayBuffer6 = buffer0.getMappedRange(3080, 48);
let commandEncoder64 = device0.createCommandEncoder({label: '\u0bfb\uc8ea\u5622\u0bd6\u{1feeb}\u035a'});
let computePassEncoder51 = commandEncoder64.beginComputePass();
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm']});
try {
renderPassEncoder7.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer29);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup20);
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture68,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(95).fill(47), /* required buffer size: 95 */
{offset: 95, bytesPerRow: 171}, {width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img1);
let bindGroup32 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 103, resource: textureView42},
    {binding: 528, resource: sampler34},
    {binding: 56, resource: textureView11},
    {binding: 313, resource: {buffer: buffer22, offset: 256, size: 36}},
    {binding: 57, resource: textureView65},
    {binding: 159, resource: {buffer: buffer33, offset: 1024, size: 1988}},
    {binding: 388, resource: {buffer: buffer33, offset: 256, size: 213}},
    {binding: 309, resource: textureView14},
    {binding: 238, resource: sampler4},
    {binding: 151, resource: {buffer: buffer1, offset: 2560, size: 1766}},
    {binding: 21, resource: textureView8},
    {binding: 286, resource: sampler36},
    {binding: 33, resource: {buffer: buffer6, offset: 256, size: 3223}},
  ],
});
let buffer48 = device0.createBuffer({
  size: 215,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let externalTexture10 = device0.importExternalTexture({source: video0, colorSpace: 'display-p3'});
try {
computePassEncoder41.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer48, 'uint32', 36, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(2, buffer2, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let gpuCanvasContext3 = offscreenCanvas2.getContext('webgpu');
let imageData9 = new ImageData(96, 32);
let commandEncoder65 = device0.createCommandEncoder({});
let commandBuffer4 = commandEncoder65.finish({});
let texture71 = device0.createTexture({
  size: [72],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder22.setBindGroup(1, bindGroup16, new Uint32Array(1150), 145, 0);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup25, new Uint32Array(2799), 151, 0);
} catch {}
try {
computePassEncoder30.pushDebugGroup('\u171d');
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 143 max align: 1 */
struct T0 {
  @align(1) @size(40) f0: atomic<i32>,
  @align(1) @size(8) f1: array<atomic<i32>, 1>,
  @align(1) @size(95) f2: array<atomic<u32>>,
}
/* target size: 143 max align: 1 */
struct T1 {
  @align(1) f0: array<vec4h, 2>,
  @align(1) @size(127) f1: array<atomic<u32>>,
}
/* target size: 143 max align: 1 */
struct T2 {
  @align(1) f0: mat2x3f,
  @align(1) @size(8) f1: vec3h,
  @align(1) @size(8) f2: atomic<u32>,
  @align(1) @size(95) f3: array<i32>,
}
@id(11616) override override15 : i32 = 152;
@group(1) @binding(18) var tex1: texture_3d<u32>;
@group(0) @binding(172) var sam1: sampler;
@group(0) @binding(228) var<storage, read_write> buffer49: T1;
struct VertexOutput0 {
  @builtin(position) f0: vec4f
}

@vertex
fn vertex0() -> VertexOutput0 {
  var out: VertexOutput0;
  if bool(override15) {
    out.f0 = vec4f(bitcast<f32>(override15));
  }
  return out;
}

@fragment
fn fragment0(@builtin(position) a0: vec4f) -> @location(200) @interpolate(perspective, center) vec3f {
  var out: vec3f;
  _ = buffer49.f0[1];
  _ = atomicExchange(&buffer49.f1[arrayLength(&buffer49.f1)], 194);
  return out;
}
struct FragmentOutput0 {
  @location(1) f0: vec3f,
  @location(2) f1: vec4i,
  @location(0) f2: vec4i
}

@fragment
fn fragment1(@builtin(front_facing) a0: bool) -> FragmentOutput0 {
  var out: FragmentOutput0;
  _ = a0;
  _ = override15;
  _ = buffer49.f1[0];
  _ = buffer49;
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(workgroup_id) a0: vec3u) {
}`,
  sourceMap: {},
  hints: {},
});
let pipelineLayout7 = device0.createPipelineLayout({label: '\u0f8b\ub563\u075c\u{1fc8e}', bindGroupLayouts: []});
let textureView68 = texture4.createView({dimension: '2d'});
let sampler42 = device0.createSampler({
  label: '\u0df9\u4066\u{1f8cc}\u897f\u898b\u511b',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 7.241,
  lodMaxClamp: 43.24,
  compare: 'less',
});
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder50.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup0, new Uint32Array(2654), 79, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(3, bindGroup13);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer13, 'uint32', 60, 84);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer26, 0, 392);
} catch {}
let texture72 = device0.createTexture({size: [39, 66, 1], format: 'rgba32sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
try {
computePassEncoder13.setBindGroup(3, bindGroup7, new Uint32Array(116), 5, 0);
} catch {}
try {
computePassEncoder47.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer20, 'uint32', 24, 76);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 694, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(265).fill(54), /* required buffer size: 265 */
{offset: 265}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
let textureView69 = texture7.createView({label: '\uaa3e\u0228\u88e7\u028a\u0fa8\ud096\u7678\ue653', mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder32.setBindGroup(1, bindGroup13);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer30, 12, 195);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer48, 'uint32', 52, 13);
} catch {}
let texture73 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView70 = texture65.createView({dimension: 'cube-array', format: 'rgba32sint', baseArrayLayer: 1, arrayLayerCount: 6});
let sampler43 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 60.46,
  lodMaxClamp: 70.28,
});
try {
computePassEncoder31.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup25, new Uint32Array(1574), 31, 0);
} catch {}
try {
renderPassEncoder11.setBlendConstant({ r: -345.4, g: -171.0, b: 396.0, a: 569.4, });
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer13, 'uint32', 24, 44);
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt709', transfer: 'smpte170m'} });
let bindGroup33 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView8}]});
let textureView71 = texture6.createView({
  label: '\u0e00\u05b4\u{1fa0b}\u84c8\u3722\u{1fe74}\u5b4a\u{1f9ab}',
  dimension: '2d',
  baseArrayLayer: 2,
});
let renderBundle3 = renderBundleEncoder3.finish({});
let sampler44 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 19.93,
  lodMaxClamp: 47.31,
});
try {
computePassEncoder39.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder9.setViewport(217.46658623462133, 63.89212755236049, 63.741212245780474, 3.3731589895585286, 0.6975485541797137, 0.7146052770412455);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer24, 'uint16', 246, 101);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer42);
} catch {}
await gc();
let querySet14 = device0.createQuerySet({label: '\u0dce\u1aef\u{1febe}\u04a7\u{1fadc}\u7585\uaaec\u74e1\ufecb', type: 'occlusion', count: 326});
try {
computePassEncoder17.setBindGroup(0, bindGroup16);
} catch {}
try {
computePassEncoder37.setBindGroup(1, bindGroup14, new Uint32Array(221), 6, 0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer47, 'uint32', 1_116, 949);
} catch {}
let arrayBuffer7 = buffer47.getMappedRange(0, 4);
try {
device0.queue.writeBuffer(buffer46, 360, new BigUint64Array(8944), 173, 116);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
try {
computePassEncoder17.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer17, 0, 1_916);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); };
} catch {}
let externalTexture11 = device0.importExternalTexture({source: video0});
try {
renderPassEncoder11.setBindGroup(1, bindGroup3, new Uint32Array(665), 20, 0);
} catch {}
let arrayBuffer8 = buffer9.getMappedRange(40, 36);
let buffer50 = device0.createBuffer({
  size: 43550,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
try {
computePassEncoder9.setPipeline(pipeline1);
} catch {}
let texture74 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView72 = texture42.createView({aspect: 'all', arrayLayerCount: 1});
try {
computePassEncoder33.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer12, 'uint32', 3_572, 46);
} catch {}
try {
buffer48.unmap();
} catch {}
try {
device0.queue.submit([]);
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: []});
let externalTexture12 = device0.importExternalTexture({label: '\ue781\u05e0\ua975\u10bc\u2e6e\u863c\u073e', source: video0, colorSpace: 'display-p3'});
try {
computePassEncoder37.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup25, new Uint32Array(931), 43, 0);
} catch {}
try {
renderPassEncoder7.setViewport(4.025581714729629, 11.10133604549093, 4.46851761290232, 2.3844370388202396, 0.04044478081166192, 0.9350265670453058);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let buffer51 = device0.createBuffer({
  size: 15428,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let texture75 = device0.createTexture({
  size: [19, 33, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({label: '\uea67\u0dd0', colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], depthReadOnly: true});
let renderBundle4 = renderBundleEncoder4.finish();
try {
computePassEncoder47.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder43.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(4, buffer34, 20);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 7, y: 28, z: 0},
  aspect: 'all',
}, new Uint8Array(32).fill(107), /* required buffer size: 32 */
{offset: 32, bytesPerRow: 84, rowsPerImage: 101}, {width: 4, height: 3, depthOrArrayLayers: 0});
} catch {}
let textureView73 = texture42.createView({dimension: '2d-array'});
try {
computePassEncoder28.setBindGroup(0, bindGroup3);
} catch {}
let bindGroup34 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 453, resource: textureView20},
    {binding: 9, resource: textureView46},
    {binding: 102, resource: textureView72},
  ],
});
try {
computePassEncoder15.setPipeline(pipeline0);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\ue429');
} catch {}
let buffer52 = device0.createBuffer({size: 33028, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: true});
let texture76 = device0.createTexture({size: [39], dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
try {
computePassEncoder22.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup9, new Uint32Array(1176), 311, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer35, 728, 819);
} catch {}
try {
  await promise11;
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'pq'} });
let bindGroup35 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [{binding: 100, resource: textureView8}, {binding: 191, resource: textureView23}],
});
let commandEncoder66 = device0.createCommandEncoder({});
let computePassEncoder52 = commandEncoder66.beginComputePass({});
let sampler45 = device0.createSampler({
  label: '\u0f82\ube42\u{1f6ec}\u{1feb0}\u01fc\u{1ff60}\uf9f2\u0cae\u0ee9\u{1fb30}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 11.18,
  lodMaxClamp: 85.93,
});
try {
computePassEncoder30.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.pushDebugGroup('\u09ff');
} catch {}
document.body.append(video0);
let bindGroup36 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [{binding: 100, resource: textureView8}, {binding: 191, resource: textureView68}],
});
let texture77 = device0.createTexture({
  size: [39],
  sampleCount: 1,
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
let sampler46 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMinClamp: 23.89,
  lodMaxClamp: 71.80,
  maxAnisotropy: 1,
});
try {
computePassEncoder25.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer16, 'uint16', 202, 571);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup34);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup1, new Uint32Array(2264), 361, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer12, 'uint16', 110, 639);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(6, buffer40, 592, 19);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let bindGroup37 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [{binding: 86, resource: sampler12}, {binding: 277, resource: textureView56}],
});
let textureView74 = texture42.createView({dimension: '2d-array'});
try {
renderPassEncoder11.setBindGroup(3, bindGroup30);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer5, 'uint16', 3_752, 247);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(3, buffer40, 0, 8_094);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup36);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(7, buffer5, 0);
} catch {}
let arrayBuffer9 = buffer52.getMappedRange(6448, 6244);
document.body.append(video0);
let renderBundle5 = renderBundleEncoder5.finish();
try {
computePassEncoder13.setBindGroup(2, bindGroup0);
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let textureView75 = texture32.createView({aspect: 'all'});
let computePassEncoder53 = commandEncoder67.beginComputePass({});
try {
computePassEncoder48.setBindGroup(3, bindGroup19);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setViewport(90.97591209617181, 69.82174880998119, 126.91603853893857, 6.809728662811698, 0.025778320016492717, 0.5407176029085576);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
await gc();
let video1 = await videoWithData(26);
let imageData10 = new ImageData(80, 16);
let buffer53 = device0.createBuffer({
  label: '\u8d57\u0816\uc5b9\u942f\u9247\u1969\u39cc\u{1f601}\u0b62',
  size: 29188,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let sampler47 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 9.129,
  lodMaxClamp: 89.13,
  maxAnisotropy: 9,
});
try {
computePassEncoder49.setBindGroup(3, bindGroup11);
} catch {}
try {
computePassEncoder26.setBindGroup(3, bindGroup33, new Uint32Array(53), 3, 0);
} catch {}
try {
computePassEncoder53.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup0, new Uint32Array(287), 68, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint32', 4_604, 425);
} catch {}
try {
computePassEncoder30.popDebugGroup();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer54 = device0.createBuffer({size: 13100, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder68 = device0.createCommandEncoder({});
let textureView76 = texture65.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6});
let computePassEncoder54 = commandEncoder68.beginComputePass({});
try {
computePassEncoder54.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder37.insertDebugMarker('\u{1f96e}');
} catch {}
let buffer55 = device0.createBuffer({
  size: 5306,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder69 = device0.createCommandEncoder({label: '\u1012\u{1f7fc}\u6d50\u8bb6\uda00\u{1f8b2}\u5324\u{1fb79}\u00e2\u84ea\u10da'});
let computePassEncoder55 = commandEncoder69.beginComputePass({});
try {
computePassEncoder18.setBindGroup(3, bindGroup14);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let textureView77 = texture58.createView({dimension: 'cube', format: 'rgba16float', baseArrayLayer: 1});
try {
device0.queue.writeTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 232, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(65).fill(149), /* required buffer size: 65 */
{offset: 65}, {width: 53, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder70 = device0.createCommandEncoder({});
let querySet15 = device0.createQuerySet({type: 'occlusion', count: 319});
let computePassEncoder56 = commandEncoder70.beginComputePass({});
let sampler48 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 66.77,
  lodMaxClamp: 83.99,
});
try {
computePassEncoder17.setBindGroup(3, bindGroup1, new Uint32Array(5611), 29, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup14, new Uint32Array(260), 55, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer43, 'uint32', 4_536, 2_481);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer18, 1_128, 370);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline2 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment1',
  targets: [{format: 'rgba32sint', writeMask: 0}, {format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {module: shaderModule2, constants: {}, buffers: []},
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'jedecP22Phosphors', transfer: 'unspecified'} });
let bindGroup38 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 102, resource: textureView15},
    {binding: 453, resource: textureView49},
    {binding: 9, resource: textureView27},
  ],
});
let buffer56 = device0.createBuffer({
  label: '\u0a30\u0431\u{1f84a}\u9783\u{1f819}\u715b\u{1f99d}\u0b04',
  size: 912,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder71 = device0.createCommandEncoder({});
let texture78 = device0.createTexture({
  size: {width: 840},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder57 = commandEncoder71.beginComputePass();
let sampler49 = device0.createSampler({
  label: '\udb4e\u{1fc21}\uf866\u9517\u0dec\ubc5c\ub38b\u1356\u0bc3',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
});
let externalTexture13 = device0.importExternalTexture({source: video0});
try {
computePassEncoder37.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint32', 2_048, 1_565);
} catch {}
try {
renderPassEncoder3.popDebugGroup();
} catch {}
document.body.prepend(img0);
offscreenCanvas2.width = 18;
let buffer57 = device0.createBuffer({
  label: '\u0039\ue313\u{1fa96}\u4cdf',
  size: 2668,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder48.setBindGroup(1, bindGroup37);
} catch {}
try {
computePassEncoder54.setBindGroup(0, bindGroup15, new Uint32Array(4999), 1_699, 0);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
let buffer58 = device0.createBuffer({
  size: 1492,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder72 = device0.createCommandEncoder({});
let computePassEncoder58 = commandEncoder72.beginComputePass({});
try {
computePassEncoder23.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup16);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup1, new Uint32Array(2838), 480, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer17, 3_280);
} catch {}
let buffer59 = device0.createBuffer({
  size: 25642,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView78 = texture45.createView({dimension: '2d-array'});
try {
computePassEncoder38.setBindGroup(2, bindGroup3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 3 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt470bg', transfer: 'bt2020_12bit'} });
let bindGroup39 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 228, resource: {buffer: buffer9, offset: 0, size: 48}}, {binding: 172, resource: sampler17}],
});
let commandEncoder73 = device0.createCommandEncoder();
let texture79 = device0.createTexture({
  size: {width: 39, height: 66, depthOrArrayLayers: 178},
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let textureView79 = texture32.createView({label: '\uf663\uc3b2\u0f97\ub1b2\u{1ff0e}\u{1f73a}\u{1f982}\ufe78', dimension: '1d'});
try {
computePassEncoder31.setBindGroup(0, bindGroup37, new Uint32Array(3653), 958, 0);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle0, renderBundle5]);
} catch {}
await gc();
let commandEncoder74 = device0.createCommandEncoder({});
let textureView80 = texture67.createView({mipLevelCount: 1});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder27.setBindGroup(0, bindGroup19);
} catch {}
try {
computePassEncoder58.setBindGroup(0, bindGroup15, new Uint32Array(115), 8, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer12, 'uint16', 264, 648);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer41, 0, 1_147);
} catch {}
try {
buffer52.unmap();
} catch {}
let textureView81 = texture33.createView({dimension: '2d'});
let renderBundle6 = renderBundleEncoder6.finish();
let sampler50 = device0.createSampler({
  label: '\u503e\u0afc\u{1f8cd}\u{1fd99}\ub14d\u{1f971}\ua5d8\u{1ff3b}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 87.06,
});
try {
computePassEncoder49.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer48, 20, 17);
} catch {}
let texture80 = device0.createTexture({size: [32], dimension: '1d', format: 'r16float', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder11.end();
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
let bindGroup40 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView10}]});
let buffer60 = device0.createBuffer({
  size: 8805,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder7.setBindGroup(3, bindGroup40);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer50, 'uint32', 2_096, 35_454);
} catch {}
try {
  await promise10;
} catch {}
let imageBitmap2 = await createImageBitmap(offscreenCanvas1);
let shaderModule3 = device0.createShaderModule({
  label: '\u{1fb23}\u05ef\u1e0a\u8a84\u{1fd11}\u0c24\u07b8\u{1fa58}',
  code: `
enable f16;
/* target size: 143 max align: 1 */
struct T0 {
  @align(1) @size(4) f0: f16,
  @align(1) @size(90) f1: atomic<i32>,
  @align(1) @size(16) f2: array<array<atomic<i32>, 1>, 1>,
  @align(1) @size(22) f3: array<atomic<u32>, 5>,
  @align(1) @size(5) f4: u32,
  @align(1) @size(6) f5: array<atomic<u32>, 1>,
}
@id(8882) override override16 : f32;
@group(0) @binding(228) var<storage, read_write> buffer61: T0;
@group(0) @binding(172) var sam2: sampler;
@group(1) @binding(18) var tex2: texture_2d<u32>;
struct S0 {
  @location(5) f0: vec2f
}
struct VertexOutput1 {
  @builtin(position) f1: vec4f
}

@vertex
fn vertex0(@location(13) @interpolate(perspective, sample) a0: vec2f, @location(0) a1: vec4f, @location(11) a2: vec3i, @location(4) a3: vec4f, @builtin(instance_index) a4: u32, a5: S0) -> VertexOutput1 {
  var out: VertexOutput1;
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
  _ = override16;
  if bool(override16) {
    return;
  }
}`,
  sourceMap: {},
});
let commandEncoder75 = device0.createCommandEncoder();
try {
computePassEncoder28.setBindGroup(1, bindGroup9);
} catch {}
try {
computePassEncoder50.setBindGroup(1, bindGroup24, new Uint32Array(540), 141, 0);
} catch {}
try {
computePassEncoder58.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageData9,
  origin: { x: 50, y: 1 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 17, y: 23, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 11, height: 8, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas1);
let buffer62 = device0.createBuffer({size: 11743, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let texture81 = device0.createTexture({
  label: '\u{1f994}\uaa41\u0e19\u0813',
  size: {width: 210, height: 1, depthOrArrayLayers: 14},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler51 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.38,
  maxAnisotropy: 16,
});
try {
computePassEncoder44.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4_294_967_294, undefined, 0);
} catch {}
try {
commandEncoder74.copyTextureToBuffer({
  texture: texture67,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 384 */
  offset: 384,
  buffer: buffer14,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let buffer63 = device0.createBuffer({
  label: '\u071e\u0bd0\u055f\u67e5\u0471\u189f\u{1fb65}\u{1fa43}\u{1fd2c}\udb23\u5b46',
  size: 4853,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
try {
computePassEncoder32.setBindGroup(3, bindGroup27, new Uint32Array(2097), 6, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle3, renderBundle0]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer60, 'uint16', 978, 364);
} catch {}
try {
externalTexture4.label = '\u2a11\u652b\u66d5\u08ff\u37fb\u{1f88e}\u013f\u{1fe8e}\u0b95\uc75d';
} catch {}
let bindGroup41 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 228, resource: {buffer: buffer10, offset: 1024}}, {binding: 172, resource: sampler48}],
});
let querySet16 = device0.createQuerySet({type: 'occlusion', count: 521});
let texture82 = device0.createTexture({
  size: {width: 15, height: 15, depthOrArrayLayers: 1},
  format: 'astc-5x5-unorm',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder59 = commandEncoder73.beginComputePass({});
let externalTexture14 = device0.importExternalTexture({source: videoFrame9, colorSpace: 'display-p3'});
document.body.prepend(canvas1);
let offscreenCanvas3 = new OffscreenCanvas(76, 218);
try {
computePassEncoder45.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer28, 'uint32', 68, 3_270);
} catch {}
try {
commandEncoder74.copyBufferToBuffer(buffer2, 3012, buffer56, 204, 608);
} catch {}
try {
commandEncoder74.copyTextureToTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture59,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{width: 38, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder75.clearBuffer(buffer25, 740);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
await gc();
let buffer64 = device0.createBuffer({
  size: 45828,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView82 = texture19.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1});
try {
computePassEncoder23.setBindGroup(1, bindGroup36, new Uint32Array(1337), 47, 0);
} catch {}
try {
computePassEncoder59.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup16, new Uint32Array(224), 9, 0);
} catch {}
try {
renderPassEncoder9.setScissorRect(2, 6, 26, 45);
} catch {}
try {
computePassEncoder27.pushDebugGroup('\ub802');
} catch {}
let buffer65 = device0.createBuffer({size: 22624, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
try {
renderPassEncoder4.setIndexBuffer(buffer47, 'uint32', 176, 207);
} catch {}
try {
commandEncoder75.copyTextureToTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 7, y: 26, z: 0},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 1,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder46.popDebugGroup();
} catch {}
try {
computePassEncoder14.setBindGroup(3, bindGroup0, new Uint32Array(842), 44, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup2);
} catch {}
try {
commandEncoder74.copyBufferToBuffer(buffer36, 3024, buffer56, 156, 20);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 12, y: 2 },
  flipY: true,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 2, y: 71, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 17, height: 2, depthOrArrayLayers: 0});
} catch {}
let texture83 = device0.createTexture({
  size: [105, 1, 199],
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder60 = commandEncoder74.beginComputePass({});
try {
computePassEncoder5.setBindGroup(0, bindGroup37, new Uint32Array(1244), 147, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup39);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer26, 'uint32', 1_764, 1_391);
} catch {}
let textureView83 = texture67.createView({mipLevelCount: 1});
let textureView84 = texture5.createView({aspect: 'depth-only', baseArrayLayer: 0});
let sampler52 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 37.18,
  lodMaxClamp: 38.92,
  compare: 'always',
  maxAnisotropy: 7,
});
try {
computePassEncoder1.setBindGroup(3, bindGroup12);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup19, new Uint32Array(2497), 326, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(2, buffer17, 0, 1_274);
} catch {}
let commandEncoder76 = device0.createCommandEncoder({});
let textureView85 = texture43.createView({
  label: '\u{1f7c2}\u33d1\u{1fc38}\u{1f695}\u337b\u702b',
  aspect: 'all',
  format: 'r8unorm',
  mipLevelCount: 1,
});
let computePassEncoder61 = commandEncoder75.beginComputePass({});
let sampler53 = device0.createSampler({
  label: '\u85c0\uc483\u3201\u{1f912}\u111b\u00ed\u99bf',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 44.99,
  lodMaxClamp: 64.51,
});
try {
renderPassEncoder7.setVertexBuffer(6, buffer34, 0, 187);
} catch {}
try {
commandEncoder76.copyBufferToBuffer(buffer55, 916, buffer2, 1088, 380);
} catch {}
let gpuCanvasContext4 = offscreenCanvas3.getContext('webgpu');
try {
gpuCanvasContext2.unconfigure();
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
let querySet17 = device0.createQuerySet({type: 'occlusion', count: 1652});
let textureView86 = texture13.createView({dimension: '2d-array', mipLevelCount: 1});
let externalTexture15 = device0.importExternalTexture({source: video1});
try {
computePassEncoder61.setBindGroup(0, bindGroup18);
} catch {}
try {
computePassEncoder16.setBindGroup(2, bindGroup9, new Uint32Array(2253), 839, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle5, renderBundle5, renderBundle0]);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer64, 'uint32', 18_660, 4_275);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer60, 3_260, 1_108);
} catch {}
try {
commandEncoder77.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 238, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 100 widthInBlocks: 25 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1208 */
  offset: 1208,
  bytesPerRow: 1024,
  buffer: buffer65,
}, {width: 25, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer50, 3324, new Float32Array(6974), 345, 1908);
} catch {}
let bindGroup42 = device0.createBindGroup({
  label: '\u09eb\u5367\u060e',
  layout: bindGroupLayout8,
  entries: [{binding: 100, resource: textureView8}, {binding: 191, resource: textureView23}],
});
let commandEncoder78 = device0.createCommandEncoder({});
let computePassEncoder62 = commandEncoder78.beginComputePass({});
try {
computePassEncoder46.setPipeline(pipeline1);
} catch {}
try {
buffer52.unmap();
} catch {}
let bindGroup43 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer14, offset: 768, size: 1780}}],
});
let pipelineLayout9 = device0.createPipelineLayout({label: '\u07e0\ube08\u{1fe25}', bindGroupLayouts: [bindGroupLayout8]});
let commandEncoder79 = device0.createCommandEncoder({});
let textureView87 = texture59.createView({dimension: '2d'});
let sampler54 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 55.75,
  lodMaxClamp: 72.09,
  maxAnisotropy: 3,
});
try {
renderPassEncoder3.setVertexBuffer(0, buffer26, 0, 2_958);
} catch {}
await gc();
let bindGroup44 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [{binding: 277, resource: textureView53}, {binding: 86, resource: sampler25}],
});
let commandEncoder80 = device0.createCommandEncoder({});
let texture84 = device0.createTexture({
  size: [78],
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView88 = texture9.createView({});
let renderPassEncoder12 = commandEncoder76.beginRenderPass({
  colorAttachments: [{
  view: textureView24,
  clearValue: { r: 347.9, g: 566.0, b: -516.7, a: -798.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet6,
});
let sampler55 = device0.createSampler({
  label: '\u0fd7\u7f40\u25e8\u0c86\uf745\u085b\u0a05\u0ccc',
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 84.64,
  lodMaxClamp: 97.35,
});
try {
computePassEncoder58.setBindGroup(1, bindGroup22);
} catch {}
try {
computePassEncoder8.setBindGroup(1, bindGroup18, new Uint32Array(4569), 4, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup24);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let textureView89 = texture19.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder18.setBindGroup(0, bindGroup36);
} catch {}
try {
computePassEncoder52.setBindGroup(2, bindGroup43, new Uint32Array(2101), 415, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer46, 2_272, 1_164);
} catch {}
try {
commandEncoder77.copyTextureToTexture({
  texture: texture57,
  mipLevel: 0,
  origin: {x: 127, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture55,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
},
{width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView90 = texture48.createView({dimension: 'cube'});
let texture85 = device0.createTexture({
  size: [72, 24, 583],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder63 = commandEncoder80.beginComputePass({});
try {
computePassEncoder49.setBindGroup(1, bindGroup33, new Uint32Array(727), 102, 0);
} catch {}
try {
computePassEncoder52.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(9);
} catch {}
try {
renderPassEncoder3.setScissorRect(44, 0, 27, 22);
} catch {}
try {
renderPassEncoder4.setStencilReference(1708);
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'iec61966-2-1'} });
let buffer66 = device0.createBuffer({
  size: 9432,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder81 = device0.createCommandEncoder({label: '\u087a\u{1fc0a}\u{1ff2b}\ue40a\u050f\u046e\ue78e\u{1ff1b}\u092a\u7d73'});
let textureView91 = texture5.createView({dimension: '2d-array', aspect: 'depth-only', format: 'depth24plus'});
try {
computePassEncoder38.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer64, 0, 8_107);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 5048, new BigUint64Array(13708), 1450, 732);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 57, y: 0, z: 8},
  aspect: 'all',
}, new Uint8Array(32_306).fill(47), /* required buffer size: 32_306 */
{offset: 92, bytesPerRow: 78, rowsPerImage: 59}, {width: 7, height: 0, depthOrArrayLayers: 8});
} catch {}
let buffer67 = device0.createBuffer({size: 38794, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let computePassEncoder64 = commandEncoder81.beginComputePass({});
try {
computePassEncoder40.setBindGroup(1, bindGroup40, new Uint32Array(701), 53, 0);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer1, 'uint32', 1_960, 4_787);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer35, 1_896);
} catch {}
try {
commandEncoder79.copyBufferToTexture({
  /* bytesInLastRow: 1072 widthInBlocks: 134 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2704 */
  offset: 2704,
  buffer: buffer54,
}, {
  texture: texture78,
  mipLevel: 0,
  origin: {x: 126, y: 0, z: 0},
  aspect: 'all',
}, {width: 134, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder27.popDebugGroup();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let shaderModule4 = device0.createShaderModule({
  label: '\u021a\u76c4\u020a',
  code: `
enable f16;
/* target size: 23 max align: 1 */
struct T0 {
  @align(1) f0: atomic<u32>,
  @align(1) @size(19) f1: array<mat2x2h, 1>,
}
override override21 : f32 = -0.8020;
override override17 : bool;
@id(811) override override18 : f16;
@id(34096) override override22 : u32;
@id(34112) override override24 : bool = false;
override override19 : bool = true;
override override23 : i32;
override override20 : i32;
@group(0) @binding(265) var<storage, read_write> buffer68: array<T0>;
struct S1 {
  @location(4) @interpolate(flat) f0: vec3i,
  @location(1) f1: f16,
  @location(7) f2: i32,
  @location(10) @interpolate(perspective, centroid) f3: vec4h
}
struct VertexOutput2 {
  @location(3) f2: vec3f,
  @location(15) f3: f32,
  @location(7) f4: vec2u,
  @builtin(position) f5: vec4f,
  @location(8) @interpolate(linear, sample) f6: vec2h
}

@vertex
fn vertex0(a0: S1, @location(13) @interpolate(flat, sample) a1: i32) -> VertexOutput2 {
  var out: VertexOutput2;
  out.f4 |= vec2u(bitcast<u32>(override20));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(workgroup_id) a0: vec3u) {
  _ = override19;
  _ = buffer68[arrayLength(&buffer68)].f1[0];
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup45 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 328, resource: {buffer: buffer47, offset: 512, size: 3605}},
    {binding: 145, resource: sampler44},
    {binding: 110, resource: sampler36},
  ],
});
let textureView92 = texture58.createView({
  label: '\u{1fb4f}\u0a45\ud8bd\u0a93\u9149\u07d5\u81ad\u91ee\u4cc4\u{1fde6}\u{1f803}',
  dimension: 'cube',
  baseArrayLayer: 10,
});
let texture86 = device0.createTexture({
  size: {width: 210},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView93 = texture0.createView({mipLevelCount: 1});
let computePassEncoder65 = commandEncoder77.beginComputePass();
try {
computePassEncoder9.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup12, new Uint32Array(358), 115, 0);
} catch {}
try {
renderPassEncoder3.end();
} catch {}
try {
commandEncoder79.copyBufferToBuffer(buffer12, 7560, buffer18, 3684, 112);
} catch {}
let textureView94 = texture84.createView({label: '\u6321\u0934\u3be7\u6726\u6c1b\u{1f7ac}\ue22f\u0a1c\u02b6\u19f3\u{1ff0a}'});
let computePassEncoder66 = commandEncoder79.beginComputePass({});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder23.setBindGroup(3, bindGroup45, new Uint32Array(67), 6, 0);
} catch {}
try {
computePassEncoder64.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let bindGroup46 = device0.createBindGroup({
  label: '\ubb28\u4131\uf83c\u{1fd7d}\u0841\u056b\u36c1\uaac7',
  layout: bindGroupLayout6,
  entries: [{binding: 86, resource: sampler45}, {binding: 277, resource: textureView50}],
});
let texture87 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder48.setBindGroup(1, bindGroup43);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(2, buffer12, 0, 3_822);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(0, buffer47, 252, 2_369);
} catch {}
let bindGroup47 = device0.createBindGroup({
  label: '\u4395\u8d05\u71fe\u{1f7d4}\u0f6f\u644f\u562a\u9591\u23ab\u02b7\u0a03',
  layout: bindGroupLayout0,
  entries: [{binding: 65, resource: textureView8}],
});
let commandEncoder82 = device0.createCommandEncoder({});
let textureView95 = texture57.createView({dimension: '2d', aspect: 'all', format: 'rg32float', mipLevelCount: 1});
let computePassEncoder67 = commandEncoder82.beginComputePass({});
try {
computePassEncoder57.setBindGroup(0, bindGroup26);
} catch {}
try {
computePassEncoder20.setBindGroup(3, bindGroup28, new Uint32Array(2541), 556, 0);
} catch {}
try {
computePassEncoder65.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup18, new Uint32Array(2021), 179, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let bindGroup48 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 172, resource: sampler49}, {binding: 228, resource: {buffer: buffer57, offset: 256}}],
});
try {
renderPassEncoder12.setIndexBuffer(buffer48, 'uint16', 30, 3);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup6);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(3, buffer66, 0, 2_583);
} catch {}
let textureView96 = texture87.createView({aspect: 'all', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder61.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup44, []);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup9, new Uint32Array(1038), 93, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer1, 'uint16', 286, 4_150);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup16, new Uint32Array(2375), 449, 0);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer11, 'uint32', 14_832, 1_413);
} catch {}
try {
computePassEncoder34.pushDebugGroup('\u2618');
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
let commandEncoder83 = device0.createCommandEncoder();
let textureView97 = texture11.createView({
  label: '\uf644\u0a1c\u{1fcda}\u{1f643}\ufa96\u3d0c\u08e2\u0ea8\u71dd\u{1ff60}\u{1f705}',
  dimension: '2d-array',
  mipLevelCount: 1,
});
let renderPassEncoder13 = commandEncoder83.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 82.80, g: 0.2277, b: 308.9, a: -782.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet5,
  maxDrawCount: 264766835,
});
let sampler56 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 54.05,
  lodMaxClamp: 74.68,
  maxAnisotropy: 8,
});
try {
computePassEncoder39.setBindGroup(1, bindGroup20, new Uint32Array(2218), 266, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(4, buffer53, 14_812, 682);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup27);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture88 = device0.createTexture({
  size: [72, 24, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView98 = texture33.createView({});
let externalTexture16 = device0.importExternalTexture({label: '\u{1fd7e}\u0f21\ufe51\u3168\u0584', source: videoFrame6, colorSpace: 'display-p3'});
try {
computePassEncoder47.setBindGroup(1, bindGroup26);
} catch {}
try {
computePassEncoder67.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup30, new Uint32Array(6784), 102, 0);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup26, new Uint32Array(1058), 56, 0);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(5, buffer55, 0, 2_046);
} catch {}
try {
computePassEncoder52.pushDebugGroup('\ud892');
} catch {}
try {
computePassEncoder52.popDebugGroup();
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u4a26');
} catch {}
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'film', transfer: 'smpteSt4281'} });
let texture89 = device0.createTexture({
  size: [288, 96, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder41.setBindGroup(3, bindGroup12, new Uint32Array(401), 17, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(4, buffer12);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup35, new Uint32Array(441), 59, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let bindGroup49 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 265, resource: {buffer: buffer10, offset: 0}}]});
try {
computePassEncoder14.setBindGroup(3, bindGroup14, new Uint32Array(364), 59, 0);
} catch {}
try {
computePassEncoder51.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer5, 'uint16', 262, 369);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup44, new Uint32Array(175), 85, 0);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(5, buffer35);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(278).fill(11), /* required buffer size: 278 */
{offset: 278}, {width: 47, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
document.body.append(img1);
let texture90 = device0.createTexture({
  label: '\u{1fd46}\u{1f9bd}\u91cd\uf820\u{1f654}\u9831\u0aed',
  size: {width: 840, height: 1, depthOrArrayLayers: 88},
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder33.end();
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup9);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer20, 'uint32', 104, 116);
} catch {}
try {
computePassEncoder34.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer1, 2968, new BigUint64Array(5303), 1209, 104);
} catch {}
let textureView99 = texture65.createView({dimension: 'cube-array', arrayLayerCount: 6});
let computePassEncoder68 = commandEncoder40.beginComputePass({});
let externalTexture17 = device0.importExternalTexture({source: video1});
try {
renderPassEncoder4.setStencilReference(360);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup20);
} catch {}
await gc();
let textureView100 = texture69.createView({});
let texture91 = device0.createTexture({size: {width: 9}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.COPY_DST});
let textureView101 = texture90.createView({});
try {
computePassEncoder55.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer40, 'uint16', 4_964, 3_494);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(1058), 33, 0);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer33, 'uint16', 770, 439);
} catch {}
try {
  await buffer23.mapAsync(GPUMapMode.READ);
} catch {}
let texture92 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder62.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder4.setStencilReference(397);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup5);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup11, new Uint32Array(136), 11, 0);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer12, 'uint16', 98, 12_649);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 832, new DataView(new ArrayBuffer(17261)), 2431, 596);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 16},
  aspect: 'all',
}, new Uint8Array(24_516).fill(246), /* required buffer size: 24_516 */
{offset: 360, bytesPerRow: 61, rowsPerImage: 36}, {width: 7, height: 0, depthOrArrayLayers: 12});
} catch {}
let buffer69 = device0.createBuffer({
  size: 2372,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder84 = device0.createCommandEncoder({});
let textureView102 = texture62.createView({
  label: '\u0302\u{1fdaf}\u366c\u08f3\u{1fd32}\ubb87\u{1f877}\u0ff1\u{1ff38}\u0342\u{1fd15}',
  aspect: 'all',
});
let textureView103 = texture64.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 11});
let computePassEncoder69 = commandEncoder84.beginComputePass();
try {
computePassEncoder59.setBindGroup(2, bindGroup8);
} catch {}
try {
computePassEncoder4.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setViewport(286.34424697332287, 38.23749164095892, 0.6593294212163189, 29.43889692408601, 0.5645667842753657, 0.8449359954871521);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(6, buffer57);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(624).fill(28), /* required buffer size: 624 */
{offset: 624, rowsPerImage: 45}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap3 = await createImageBitmap(imageData5);
let bindGroup50 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 145, resource: sampler36},
    {binding: 110, resource: sampler50},
    {binding: 328, resource: {buffer: buffer25, offset: 256}},
  ],
});
try {
computePassEncoder14.setBindGroup(1, bindGroup49);
} catch {}
try {
computePassEncoder60.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder13.setViewport(22.292581303925488, 5.595608266731265, 1.7686192223260775, 5.465290157470396, 0.7874806835953446, 0.9049382748397639);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(2, buffer57, 440, 608);
} catch {}
await gc();
let canvas2 = document.createElement('canvas');
let imageBitmap4 = await createImageBitmap(canvas0);
let bindGroup51 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer36, offset: 3840, size: 1668}}],
});
try {
computePassEncoder26.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer13, 'uint32', 96, 122);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(5, undefined, 0, 704_649_199);
} catch {}
try {
buffer43.unmap();
} catch {}
let commandEncoder85 = device0.createCommandEncoder({});
let textureView104 = texture57.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder70 = commandEncoder85.beginComputePass({});
let renderBundle7 = renderBundleEncoder7.finish({});
try {
computePassEncoder14.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(76);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 5, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(252).fill(203), /* required buffer size: 252 */
{offset: 252, bytesPerRow: 328, rowsPerImage: 78}, {width: 288, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 16}
*/
{
  source: imageData7,
  origin: { x: 15, y: 0 },
  flipY: false,
}, {
  texture: texture31,
  mipLevel: 1,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 7, height: 2, depthOrArrayLayers: 0});
} catch {}
let bindGroup52 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [{binding: 86, resource: sampler30}, {binding: 277, resource: textureView55}],
});
try {
computePassEncoder40.setBindGroup(3, bindGroup1, []);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup46, new Uint32Array(284), 2, 0);
} catch {}
try {
renderPassEncoder7.end();
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle3]);
} catch {}
let bindGroup53 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer59, offset: 9216, size: 4428}}],
});
let texture93 = device0.createTexture({
  size: [78, 132, 31],
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let buffer70 = device0.createBuffer({
  label: '\u0404\u004b\ud2be\u5ba2\ua0d8\u625d\u{1fe4f}\u7c8e\ua3a8\u6ddd',
  size: 19882,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder57.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBlendConstant({ r: -42.57, g: -299.2, b: 3.987, a: -778.7, });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture51,
  mipLevel: 4,
  origin: {x: 7, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(90).fill(18), /* required buffer size: 90 */
{offset: 90, bytesPerRow: 41}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext5 = canvas2.getContext('webgpu');
let textureView105 = texture10.createView({arrayLayerCount: 1});
let sampler57 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 47.76,
  lodMaxClamp: 57.14,
  maxAnisotropy: 1,
});
try {
computePassEncoder27.end();
} catch {}
try {
computePassEncoder69.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup36, new Uint32Array(727), 123, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer11, 'uint16', 2_590, 304);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer41, 2_568);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 5 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1225 */
  offset: 1225,
  bytesPerRow: 1280,
  buffer: buffer62,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 37, y: 6, z: 0},
  aspect: 'all',
}, {width: 5, height: 73, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let buffer71 = device0.createBuffer({size: 4168, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let texture94 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder12.setBindGroup(3, bindGroup43);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer41, 5_864, 1_158);
} catch {}
try {
window.someLabel = texture40.label;
} catch {}
let buffer72 = device0.createBuffer({size: 5954, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let textureView106 = texture48.createView({dimension: 'cube-array', arrayLayerCount: 6});
let computePassEncoder71 = commandEncoder34.beginComputePass({label: '\u{1f848}\u45f9\u{1f8eb}\uc83b\u4a75\u{1f8a2}\uf5e9'});
try {
computePassEncoder60.setBindGroup(2, bindGroup10);
} catch {}
try {
computePassEncoder68.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setBlendConstant({ r: -375.7, g: -835.5, b: -948.3, a: -293.2, });
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer48, 'uint16', 12, 51);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer48);
} catch {}
let buffer73 = device0.createBuffer({size: 6757, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder13.setBindGroup(1, bindGroup44);
} catch {}
try {
texture73.destroy();
} catch {}
try {
  await promise12;
} catch {}
try {
computePassEncoder12.setBindGroup(1, bindGroup9, []);
} catch {}
try {
computePassEncoder66.setPipeline(pipeline0);
} catch {}
document.body.prepend(img0);
let texture95 = device0.createTexture({
  label: '\u{1f9b2}\u56d2\ud5d7\ue6cb\u7084\u{1fb02}\u3692\u{1fb6a}\u0bd3\u0770\u0167',
  size: {width: 19, height: 33, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView107 = texture24.createView({format: 'rgba16sint'});
try {
computePassEncoder59.setBindGroup(1, bindGroup10, new Uint32Array(190), 45, 0);
} catch {}
try {
computePassEncoder70.setPipeline(pipeline0);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 15, y: 0 },
  flipY: false,
}, {
  texture: texture92,
  mipLevel: 0,
  origin: {x: 15, y: 9, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup42, new Uint32Array(2648), 82, 0);
} catch {}
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'log'} });
let sampler58 = device0.createSampler({
  label: '\u{1ffd3}\u954a',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 44.12,
  lodMaxClamp: 50.33,
  maxAnisotropy: 1,
});
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpteSt4281', transfer: 'logSqrt'} });
let bindGroup54 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 102, resource: textureView23},
    {binding: 453, resource: textureView12},
    {binding: 9, resource: textureView46},
  ],
});
let buffer74 = device0.createBuffer({
  label: '\ue3e5\u58f5\u1f79\u991f',
  size: 17833,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder86 = device0.createCommandEncoder({label: '\u{1fb3b}\ufbfb\u0b92\u4dd0\u3443\u2e25\uf380\u{1f8cf}\u173d\u00dc\u{1fe0c}'});
let texture96 = device0.createTexture({
  size: [78, 132, 1],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder72 = commandEncoder86.beginComputePass({});
try {
computePassEncoder71.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup9);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
computePassEncoder36.insertDebugMarker('\u03aa');
} catch {}
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {
  fullRange: false,
  matrix: 'unspecified',
  primaries: 'smpteSt4281',
  transfer: 'bt1361ExtendedColourGamut',
} });
let bindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 414,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 78,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 221,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 47,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 261,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 313, hasDynamicOffset: false },
    },
    {
      binding: 164,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 311,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 79,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 26,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 270,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 119,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 667,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d-array' },
    },
    {binding: 54, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 337,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 141, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
  ],
});
let buffer75 = device0.createBuffer({
  size: 6779,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let querySet18 = device0.createQuerySet({type: 'occlusion', count: 2341});
let texture97 = device0.createTexture({
  size: [9, 16, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder72.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup12);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup22, new Uint32Array(2656), 1_001, 0);
} catch {}
try {
renderPassEncoder13.beginOcclusionQuery(73);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer41, 3_280, 745);
} catch {}
try {
buffer23.unmap();
} catch {}
try {
computePassEncoder34.pushDebugGroup('\u0bd0');
} catch {}
let buffer76 = device0.createBuffer({
  label: '\u0257\u1b39\u18ae\uc0ab\u22dd',
  size: 5303,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let textureView108 = texture97.createView({dimension: '2d-array'});
let textureView109 = texture3.createView({
  label: '\u5427\u0546\ufb9a\u{1ff9f}\uf33d\u3713\uf50b\ufef7\u078e\u{1faaa}',
  dimension: '2d-array',
  aspect: 'all',
  mipLevelCount: 1,
  arrayLayerCount: 1,
});
try {
renderPassEncoder9.setBindGroup(0, bindGroup27);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle3, renderBundle0]);
} catch {}
let texture98 = device0.createTexture({
  label: '\u2dc9\u0444\u8cc0\u{1fdc1}\u{1f84b}',
  size: {width: 210},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture99 = device0.createTexture({
  size: [840, 1, 1],
  mipLevelCount: 8,
  dimension: '2d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture18 = device0.importExternalTexture({source: video0});
try {
computePassEncoder42.setBindGroup(1, bindGroup46);
} catch {}
try {
computePassEncoder42.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(70);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(6, buffer53, 0);
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer5, offset: 0, size: 48}}],
});
let texture100 = device0.createTexture({
  size: [144],
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture101 = device0.createTexture({size: [19], dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.COPY_SRC});
let sampler59 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.01,
  lodMaxClamp: 78.11,
  maxAnisotropy: 17,
});
try {
computePassEncoder58.setBindGroup(1, bindGroup55, new Uint32Array(253), 61, 0);
} catch {}
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.setScissorRect(63, 35, 62, 15);
} catch {}
let bindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 212,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let buffer77 = device0.createBuffer({size: 13005, usage: GPUBufferUsage.MAP_READ});
let commandEncoder87 = device0.createCommandEncoder({});
let textureView110 = texture71.createView({mipLevelCount: 1, arrayLayerCount: 1});
let texture102 = device0.createTexture({
  label: '\u03ac\u0819\uc4e7',
  size: [144, 48, 1],
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder40.setBindGroup(2, bindGroup45);
} catch {}
try {
computePassEncoder47.setBindGroup(2, bindGroup16, new Uint32Array(23), 3, 0);
} catch {}
try {
computePassEncoder49.end();
} catch {}
try {
renderPassEncoder4.setViewport(281.93009736606916, 58.68316114935871, 3.2857068897058217, 6.675820986011656, 0.07501886016973891, 0.28658787056988133);
} catch {}
try {
device0.queue.writeBuffer(buffer35, 704, new DataView(new ArrayBuffer(4397)), 2406, 112);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let buffer78 = device0.createBuffer({
  size: 21607,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView111 = texture100.createView({});
let computePassEncoder73 = commandEncoder62.beginComputePass({label: '\u1bf7\u{1ff55}\u0538\ue0ff\u0ca5\u5d07\u0d20\u01a7'});
try {
computePassEncoder73.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup49);
} catch {}
try {
commandEncoder87.copyTextureToTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture88,
  mipLevel: 0,
  origin: {x: 16, y: 1, z: 0},
  aspect: 'all',
},
{width: 19, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder1.insertDebugMarker('\u{1fade}');
} catch {}
let commandEncoder88 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  size: [420],
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView112 = texture51.createView({mipLevelCount: 1});
let renderPassEncoder14 = commandEncoder88.beginRenderPass({
  label: '\u615c\u1140\ua771\u2f2e\u1339\u3419\u0211\u0312',
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: -244.2, g: 117.4, b: 634.8, a: 787.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet11,
});
let sampler60 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 83.19,
});
try {
renderPassEncoder9.setBindGroup(3, bindGroup51);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer75, 'uint32', 664, 835);
} catch {}
try {
commandEncoder87.copyBufferToBuffer(buffer78, 1568, buffer69, 308, 636);
} catch {}
try {
commandEncoder87.copyTextureToBuffer({
  texture: texture89,
  mipLevel: 1,
  origin: {x: 2, y: 4, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 37 widthInBlocks: 37 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1584 */
  offset: 1584,
  bytesPerRow: 512,
  buffer: buffer64,
}, {width: 37, height: 27, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder34.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(325).fill(130), /* required buffer size: 325 */
{offset: 325, bytesPerRow: 106}, {width: 5, height: 6, depthOrArrayLayers: 0});
} catch {}
let buffer79 = device0.createBuffer({
  label: '\u42a0\u{1fd09}\u{1ff0b}\u{1fa4f}\u0f96\u{1fcd5}\u7c14',
  size: 10275,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder89 = device0.createCommandEncoder({});
let textureView113 = texture98.createView({label: '\u0b1a\u01a4\u3a6a\ub0f8\ueab9\u280c\ubbfd\u61e6\u1af7'});
let computePassEncoder74 = commandEncoder87.beginComputePass();
try {
computePassEncoder74.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup38);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(48);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer74, 0, 2_231);
} catch {}
try {
commandEncoder89.clearBuffer(buffer46, 200, 156);
} catch {}
let buffer80 = device0.createBuffer({
  size: 8532,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let textureView114 = texture68.createView({});
let sampler61 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 38.71,
  lodMaxClamp: 86.62,
});
try {
computePassEncoder14.setBindGroup(0, bindGroup39);
} catch {}
try {
computePassEncoder60.setBindGroup(0, bindGroup19, new Uint32Array(1193), 91, 0);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer11, 'uint16', 2_810, 1_001);
} catch {}
let bindGroup56 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 228, resource: {buffer: buffer48, offset: 0, size: 60}}, {binding: 172, resource: sampler44}],
});
let texture104 = device0.createTexture({
  label: '\u0ab9\u{1fc9c}\ub579\u0b65',
  size: {width: 78, height: 132, depthOrArrayLayers: 67},
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder75 = commandEncoder89.beginComputePass();
try {
computePassEncoder75.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup14);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle3, renderBundle6, renderBundle6, renderBundle3, renderBundle6]);
} catch {}
try {
renderPassEncoder12.setViewport(6.823243153485289, 2.7622719837818366, 1.9801738347992452, 5.031005275393344, 0.7715814471557502, 0.9454324529026976);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(6, buffer10, 68, 758);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 1304, new BigUint64Array(24668), 12764, 0);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let bindGroup57 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [{binding: 100, resource: textureView8}, {binding: 191, resource: textureView23}],
});
let buffer81 = device0.createBuffer({size: 1640, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: true});
let commandEncoder90 = device0.createCommandEncoder({label: '\u2b7b\udd54\u3f5d\u0fdc'});
let texture105 = device0.createTexture({
  size: [19, 33, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView115 = texture13.createView({label: '\u{1f70d}\u5547\u01af\ue0c8\u0658\u8363', dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder12.setBindGroup(3, bindGroup11, new Uint32Array(847), 209, 0);
} catch {}
try {
renderPassEncoder13.end();
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder90.copyTextureToBuffer({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 6, y: 9, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 13 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 2860 */
  offset: 2860,
  bytesPerRow: 512,
  buffer: buffer50,
}, {width: 13, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder90.copyTextureToTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 2, y: 4, z: 0},
  aspect: 'all',
},
{
  texture: texture37,
  mipLevel: 0,
  origin: {x: 22, y: 3, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup58 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView8}]});
let texture106 = device0.createTexture({
  size: [32, 32, 24],
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder76 = commandEncoder90.beginComputePass({label: '\ud922\u0e45\u8aba\u0dca\u23c0\u0f1c\udb88\u{1f88a}\u{1fda5}\u0280\u0603'});
try {
computePassEncoder21.setBindGroup(0, bindGroup14);
} catch {}
try {
computePassEncoder76.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer11, 'uint32', 3_744, 1_036);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer26, 1_308, 265);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 156, new DataView(new ArrayBuffer(799)), 139, 4);
} catch {}
let commandEncoder91 = device0.createCommandEncoder({label: '\u0ce0\ua5de\u{1f99d}\ufefb\u{1f695}'});
let texture107 = device0.createTexture({
  size: {width: 19, height: 33, depthOrArrayLayers: 1},
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler62 = device0.createSampler({
  label: '\u{1ff6f}\uaa4a\u44fa',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 96.48,
  lodMaxClamp: 97.72,
  maxAnisotropy: 14,
});
try {
renderPassEncoder4.setBindGroup(2, bindGroup33);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup18, new Uint32Array(496), 81, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(6, buffer46, 2_744, 541);
} catch {}
try {
buffer62.unmap();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let buffer82 = device0.createBuffer({
  label: '\u{1f76e}\u8baa\u0516\u0552\u91a2\u{1f9a5}\u0cb4\ue6d4\u0cce\u405a',
  size: 4691,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
});
let commandEncoder92 = device0.createCommandEncoder({});
let texture108 = device0.createTexture({
  size: [420, 1, 34],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView116 = texture80.createView({
  label: '\u9537\u2e21\u0b9e\u0fb6\u84b2\ud251\u0661\u0774\u0067\ud227\u0d77',
  format: 'r16float',
  baseMipLevel: 0,
});
let computePassEncoder77 = commandEncoder92.beginComputePass({label: '\u086d\u0e2b\u{1ffec}\uab44\uc2ac'});
try {
computePassEncoder64.setBindGroup(1, bindGroup18, new Uint32Array(50), 22, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup37, new Uint32Array(3521), 10, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture77,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(76).fill(139), /* required buffer size: 76 */
{offset: 76}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise14;
} catch {}
let buffer83 = device0.createBuffer({
  size: 18084,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder93 = device0.createCommandEncoder({});
try {
renderPassEncoder4.setBindGroup(0, bindGroup53);
} catch {}
try {
renderPassEncoder9.setBlendConstant({ r: 366.3, g: 577.5, b: 86.62, a: 947.2, });
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer41, 0);
} catch {}
try {
  await buffer67.mapAsync(GPUMapMode.WRITE, 1952, 8784);
} catch {}
try {
commandEncoder91.copyTextureToTexture({
  texture: texture93,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 5, y: 3, z: 0},
  aspect: 'all',
},
{width: 15, height: 76, depthOrArrayLayers: 0});
} catch {}
let buffer84 = device0.createBuffer({size: 1364, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder94 = device0.createCommandEncoder({});
let texture109 = device0.createTexture({
  size: {width: 210},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder78 = commandEncoder93.beginComputePass({});
try {
computePassEncoder78.setPipeline(pipeline1);
} catch {}
try {
commandEncoder94.copyTextureToBuffer({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 72 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2048 */
  offset: 2048,
  buffer: buffer26,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let commandBuffer5 = commandEncoder91.finish();
try {
computePassEncoder77.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup11, []);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer24, 'uint32', 708, 436);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 106,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 74,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 20,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let buffer85 = device0.createBuffer({
  size: 16189,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture110 = device0.createTexture({
  size: [72, 24, 149],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture111 = device0.createTexture({
  size: [420, 1, 78],
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView117 = texture16.createView({});
let renderPassEncoder15 = commandEncoder94.beginRenderPass({
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: -309.0, g: -320.4, b: -423.5, a: -46.43, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet17,
  maxDrawCount: 280817823,
});
let sampler63 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 88.88,
  lodMaxClamp: 97.22,
  maxAnisotropy: 19,
});
try {
computePassEncoder48.setBindGroup(1, bindGroup24);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer17);
} catch {}
let arrayBuffer10 = buffer9.getMappedRange(80, 120);
try {
buffer17.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer64, 24380, new Float32Array(6238), 3213);
} catch {}
let bindGroup59 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 102, resource: textureView44},
    {binding: 453, resource: textureView21},
    {binding: 9, resource: textureView18},
  ],
});
let commandEncoder95 = device0.createCommandEncoder({});
let textureView118 = texture110.createView({mipLevelCount: 1});
let computePassEncoder79 = commandEncoder95.beginComputePass();
let sampler64 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 50.16,
  lodMaxClamp: 85.58,
  compare: 'greater',
});
try {
device0.queue.submit([commandBuffer5]);
} catch {}
try {
device0.queue.writeBuffer(buffer59, 12072, new Float32Array(780), 12, 12);
} catch {}
let buffer86 = device0.createBuffer({
  size: 8990,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder96 = device0.createCommandEncoder({});
let textureView119 = texture97.createView({format: 'bgra8unorm'});
let computePassEncoder80 = commandEncoder96.beginComputePass({});
let sampler65 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 88.16,
  lodMaxClamp: 99.74,
});
try {
renderPassEncoder9.setBindGroup(0, bindGroup33, new Uint32Array(15), 2, 0);
} catch {}
try {
renderPassEncoder14.setViewport(140.9403220895795, 0.44376561914827584, 10.080177606878319, 0.3523782808152427, 0.700612243555561, 0.9803185346597096);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView120 = texture97.createView({dimension: '2d-array', mipLevelCount: 1});
let texture112 = device0.createTexture({
  size: [19, 33, 1],
  mipLevelCount: 2,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder53.setBindGroup(0, bindGroup47);
} catch {}
try {
computePassEncoder80.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(4_294_967_294, undefined, 0, 651_433_212);
} catch {}
try {
buffer52.unmap();
} catch {}
let textureView121 = texture100.createView({mipLevelCount: 1});
let texture113 = device0.createTexture({
  label: '\u38f6\u0611\u4fe3\u{1fce6}\u0e9e\u2c6b',
  size: [144, 48, 1],
  sampleCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler66 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 57.19,
  lodMaxClamp: 99.37,
  maxAnisotropy: 20,
});
try {
computePassEncoder43.setBindGroup(0, bindGroup1, []);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup34, new Uint32Array(720), 71, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(56);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
let bindGroup60 = device0.createBindGroup({
  label: '\u0789\u221c\u0455\uf348\u7dde\uf07a\u72f0\u{1f9e2}\u7a7f',
  layout: bindGroupLayout1,
  entries: [
    {binding: 9, resource: textureView33},
    {binding: 453, resource: textureView36},
    {binding: 102, resource: textureView87},
  ],
});
let buffer87 = device0.createBuffer({
  label: '\u0ffc\u0e2f\u24ff\uc2f6\u8391\u0b56\ud2c2\uafe4\ub813\u8fe3\u01d5',
  size: 228,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView122 = texture40.createView({});
try {
computePassEncoder79.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer74, 'uint16', 1_348, 5_156);
} catch {}
let promise15 = adapter0.requestAdapterInfo();
let commandEncoder97 = device0.createCommandEncoder({});
let commandBuffer6 = commandEncoder97.finish({label: '\u6f4e\u00c3\u{1f849}'});
let textureView123 = texture9.createView({dimension: '2d-array'});
try {
renderPassEncoder12.setBindGroup(0, bindGroup16, new Uint32Array(124), 3, 0);
} catch {}
try {
renderPassEncoder14.setViewport(4.1647048936099225, 0.31641430641989887, 41.00202897172312, 0.6286358330394834, 0.10875236901414498, 0.8321235181026336);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(4, buffer40);
} catch {}
try {
  await buffer45.mapAsync(GPUMapMode.WRITE, 0, 244);
} catch {}
let commandEncoder98 = device0.createCommandEncoder({});
try {
renderPassEncoder9.setBindGroup(1, bindGroup60, new Uint32Array(183), 1, 0);
} catch {}
try {
commandEncoder98.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 336 */
  offset: 336,
  buffer: buffer31,
}, {
  texture: texture106,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 2},
  aspect: 'all',
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u017b\ue62f\u637f\ue766\u3ba0\u982b';
} catch {}
try {
window.someLabel = externalTexture15.label;
} catch {}
let commandEncoder99 = device0.createCommandEncoder({});
try {
computePassEncoder50.setBindGroup(3, bindGroup14);
} catch {}
try {
computePassEncoder71.setBindGroup(1, bindGroup25, new Uint32Array(307), 68, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle5, renderBundle5]);
} catch {}
try {
commandEncoder99.copyTextureToBuffer({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 11, y: 4, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 3392 */
  offset: 3392,
  bytesPerRow: 512,
  buffer: buffer73,
}, {width: 2, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer6]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(95).fill(37), /* required buffer size: 95 */
{offset: 95, rowsPerImage: 12}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 9, y: 2 },
  flipY: true,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 197, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup61 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [{binding: 100, resource: textureView8}, {binding: 191, resource: textureView69}],
});
let commandEncoder100 = device0.createCommandEncoder({label: '\u49b8\u5897\u0ffb\u35a2\u9392\u966f'});
let renderPassEncoder16 = commandEncoder100.beginRenderPass({
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: -848.3, g: 921.2, b: 15.74, a: -941.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder60.setBindGroup(3, bindGroup46, new Uint32Array(732), 138, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer36, 'uint16', 340, 2_535);
} catch {}
try {
  await promise13;
} catch {}
let bindGroup62 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 228, resource: {buffer: buffer63, offset: 0, size: 332}},
    {binding: 172, resource: sampler21},
  ],
});
let querySet19 = device0.createQuerySet({type: 'occlusion', count: 17});
let textureView124 = texture110.createView({mipLevelCount: 1});
let computePassEncoder81 = commandEncoder98.beginComputePass();
try {
computePassEncoder24.setBindGroup(1, bindGroup35, new Uint32Array(1750), 44, 0);
} catch {}
try {
computePassEncoder81.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(5, buffer60, 0, 618);
} catch {}
try {
buffer9.unmap();
} catch {}
let buffer88 = device0.createBuffer({
  label: '\u7f8b\u0c2f\u0e71\u0b19',
  size: 27407,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let texture114 = device0.createTexture({
  label: '\u{1fa8b}\u042c\u{1fc12}',
  size: {width: 39, height: 66, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder82 = commandEncoder99.beginComputePass({label: '\u02ff\u1359\ub8e2\ueaec\u{1f927}\u74ef\u7286\u4e1a\u7405\ua796'});
try {
computePassEncoder82.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.end();
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer86);
} catch {}
try {
buffer57.unmap();
} catch {}
try {
  await promise15;
} catch {}
let texture115 = device0.createTexture({
  size: [78, 132, 1],
  mipLevelCount: 3,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView125 = texture57.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder29.setBindGroup(0, bindGroup12);
} catch {}
try {
buffer80.unmap();
} catch {}
document.body.prepend(img0);
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt2020', transfer: 'smpteSt4281'} });
let bindGroup63 = device0.createBindGroup({
  label: '\u07b8\u1d86\u{1f921}',
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer6, offset: 512, size: 288}}],
});
let querySet20 = device0.createQuerySet({type: 'occlusion', count: 188});
let textureView126 = texture84.createView({});
let sampler67 = device0.createSampler({
  label: '\u0f42\u{1f932}\uacc7\udd0b\ucd9e\u060c\u0180\u{1fc8c}\ue314\u{1f64d}\u899e',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 56.04,
  lodMaxClamp: 91.94,
  maxAnisotropy: 6,
});
try {
computePassEncoder64.setBindGroup(0, bindGroup39);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer24, 'uint32', 232, 626);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(5, buffer48);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 34}
*/
{
  source: videoFrame11,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 101, y: 0, z: 10},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas1);
let bindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 123,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {
      binding: 97,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let buffer89 = device0.createBuffer({size: 518, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder101 = device0.createCommandEncoder({label: '\u5d05\u5f02\u0acf\u04c5'});
let texture116 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView127 = texture13.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder83 = commandEncoder101.beginComputePass({});
try {
computePassEncoder83.setPipeline(pipeline0);
} catch {}
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); };
} catch {}
let textureView128 = texture116.createView({aspect: 'all'});
let textureView129 = texture26.createView({label: '\u{1fa0e}\u0ce8\uf844\u{1f746}\u0447\ua036\ud3c5\u0806\u7678\u131c', mipLevelCount: 1});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({
  label: '\uc7d8\uc68d\u0688\u{1fe5e}\u043a\u1d57\u06b1\u0a05\u{1fabb}\u{1f87d}\ub80c',
  colorFormats: ['r16float', 'rg16sint'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
let externalTexture19 = device0.importExternalTexture({source: video0});
try {
computePassEncoder14.setBindGroup(1, bindGroup11);
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup57);
} catch {}
try {
renderPassEncoder15.setScissorRect(17, 0, 69, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer29);
} catch {}
let imageData11 = new ImageData(24, 16);
let shaderModule5 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 23 max align: 1 */
struct T0 {
  @align(1) @size(23) f0: mat2x3h,
}
/* target size: 19 max align: 1 */
struct T1 {
  @align(1) f0: array<mat2x2h, 1>,
  @align(1) @size(11) f1: mat2x2h,
}
@id(54810) override override27 : u32;
@id(43754) override override25 : f16;
override override28 : f16;
@id(18298) override override26 : f16;
@group(0) @binding(265) var<storage, read_write> buffer90: T0;
struct VertexOutput3 {
  @location(12) @interpolate(flat) f7: vec3i,
  @builtin(position) f8: vec4f,
  @location(6) @interpolate(linear, center) f9: f32,
  @location(15) f10: vec3h,
  @location(0) @interpolate(flat, centroid) f11: vec2u,
  @location(1) f12: vec4h
}

@vertex
fn vertex0(@location(11) @interpolate(flat) a0: vec2h) -> VertexOutput3 {
  var out: VertexOutput3;
  if bool(override27) {
    var v: vec4f;
  }
  return out;
}

@compute @workgroup_size(4, 1, 1)
fn compute0() {
}

fn coverageHelper0() {
  _ = cross(vec3(), vec3());
  _ = min((1<<62), (1<<33));
  _ = max((1<<62), (1<<33));
  _ = determinant(mat2x2(vec2(), vec2()));
  _ = determinant(mat3x3(vec3(), vec3(), vec3()));
  _ = determinant(mat4x4(vec4(), vec4(), vec4(), vec4()));

  const_assert true;
  switch 1 {
    case 1, default { break; }
  }
  for (var i: f32 = 0; i < 10; i+=1) { break; }
  for (var i: i32 = 0; i < 10; i++) { continue; }
  for (var i: u32 = 10; i > 0; i--) { continue; }
  loop {
    continue;
    continuing {
      break if true;
    }
  }
  while true {
    break;
  }

  var i32_: i32 = 1;
  var u32_: u32 = 1;
  var f32_: f32 = .1;
  var f16_: f16 = .1;
  var bool_: bool = true;
  var vec2b_ = vec2<bool>();
  var vec3b_ = vec3<bool>();
  var vec4b_ = vec4<bool>();
  var vec2i_ = vec2i(1);
  var vec3i_ = vec3i(1);
  var vec4i_ = vec4i(1);
  var vec2u_ = vec2u(1);
  var vec3u_ = vec3u(1);
  var vec4u_ = vec4u(1);
  var vec2f_ = vec2f(.1);
  var vec3f_ = vec3f(.1);
  var vec4f_ = vec4f(.1);
  var vec2h_ = vec2h(.1);
  var vec3h_ = vec3h(.1);
  var vec4h_ = vec4h(.1);
  var mat3x2f_ = mat3x2f();
  var mat3x3f_ = mat3x3f();
  var mat3x4f_ = mat3x4f();
  var mat4x4f_ = mat4x4f();
  var mat4x3f_ = mat4x3f();
  var mat4x2f_ = mat4x2f();
  var mat2x4f_ = mat2x4f();
  var mat2x3f_ = mat2x3f();
  var mat2x2f_ = mat2x2f();
  var mat3x2h_ = mat3x2h();
  var mat3x3h_ = mat3x3h();
  var mat3x4h_ = mat3x4h();
  var mat4x4h_ = mat4x4h();
  var mat4x3h_ = mat4x3h();
  var mat4x2h_ = mat4x2h();
  var mat2x4h_ = mat2x4h();
  var mat2x3h_ = mat2x3h();
  var mat2x2h_ = mat2x2h();

  if true {
    var h = 0x1p-24h;
  } else if false {
    var h = 0x1p-24h;
  } else {
    var h = 0x1p-24h;
  }

  _ = bitcast<i32>(0i);
  _ = bitcast<i32>(0u);
  _ = bitcast<i32>(0f);
  _ = bitcast<i32>(0);
  _ = bitcast<i32>(0.);
  _ = bitcast<u32>(0i);
  _ = bitcast<u32>(0u);
  _ = bitcast<u32>(0f);
  _ = bitcast<u32>(0);
  _ = bitcast<u32>(0.);
  _ = bitcast<f32>(0i);
  _ = bitcast<f32>(0u);
  _ = bitcast<f32>(0f);
  _ = bitcast<f32>(0);
  _ = bitcast<f32>(0.);
  _ = bitcast<vec2i>(vec2i_);
  _ = bitcast<vec2i>(vec2u_);
  _ = bitcast<vec2i>(vec2f_);
  _ = bitcast<vec2i>(vec2());
  _ = bitcast<vec2i>(vec2(0.));
  _ = bitcast<vec2u>(vec2i_);
  _ = bitcast<vec2u>(vec2u_);
  _ = bitcast<vec2u>(vec2f_);
  _ = bitcast<vec2u>(vec2());
  _ = bitcast<vec2u>(vec2(0.));
  _ = bitcast<vec2f>(vec2i_);
  _ = bitcast<vec2f>(vec2u_);
  _ = bitcast<vec2f>(vec2f_);
  _ = bitcast<vec2f>(vec2());
  _ = bitcast<vec2f>(vec2(0.));
  _ = bitcast<vec3i>(vec3i_);
  _ = bitcast<vec3i>(vec3u_);
  _ = bitcast<vec3i>(vec3f_);
  _ = bitcast<vec3i>(vec3());
  _ = bitcast<vec3i>(vec3(0.));
  _ = bitcast<vec3u>(vec3i_);
  _ = bitcast<vec3u>(vec3u_);
  _ = bitcast<vec3u>(vec3f_);
  _ = bitcast<vec3u>(vec3());
  _ = bitcast<vec3u>(vec3(0.));
  _ = bitcast<vec3f>(vec3i_);
  _ = bitcast<vec3f>(vec3u_);
  _ = bitcast<vec3f>(vec3f_);
  _ = bitcast<vec3f>(vec3());
  _ = bitcast<vec3f>(vec3(0.));
  _ = bitcast<vec4i>(vec4i_);
  _ = bitcast<vec4i>(vec4u_);
  _ = bitcast<vec4i>(vec4f_);
  _ = bitcast<vec4i>(vec4());
  _ = bitcast<vec4i>(vec4(0.));
  _ = bitcast<vec4u>(vec4i_);
  _ = bitcast<vec4u>(vec4u_);
  _ = bitcast<vec4u>(vec4f_);
  _ = bitcast<vec4u>(vec4());
  _ = bitcast<vec4u>(vec4(0.));
  _ = bitcast<vec4f>(vec4i_);
  _ = bitcast<vec4f>(vec4u_);
  _ = bitcast<vec4f>(vec4f_);
  _ = bitcast<vec4f>(vec4());
  _ = bitcast<vec4f>(vec4(0.));

  _ = bitcast<vec2h>(0);
  _ = bitcast<vec2h>(0.);
  _ = bitcast<vec2h>(0u);
  _ = bitcast<vec2h>(0i);
  _ = bitcast<vec2h>(0f);
  _ = bitcast<vec4h>(vec2());
  _ = bitcast<vec4h>(vec2(0.));
  _ = bitcast<vec4h>(vec2u_);
  _ = bitcast<vec4h>(vec2i_);
  _ = bitcast<vec4h>(vec2f_);
  _ = bitcast<u32>(vec2h_);
  _ = bitcast<i32>(vec2h_);
  _ = bitcast<f32>(vec2h_);
  _ = bitcast<vec2u>(vec4h_);
  _ = bitcast<vec2i>(vec4h_);
  _ = bitcast<vec2f>(vec4h_);

  _ = array(frexp(f32_), frexp(f32_), frexp(f32_), frexp(f32_));
  _ = array(frexp(f16_), frexp(f16_), frexp(f16_));
  _ = array(modf(f32_), modf(f32_));
  _ = array(modf(f16_), modf(f16_), modf(f16_), modf(f16_), modf(f16_));

  _ = !bool_;
  _ = !vec2b_;
  _ = !vec3b_;
  _ = !vec4b_;
  _ = bool_ || bool_;
  _ = bool_ && bool_;
  _ = bool_ | bool_;
  _ = vec2b_ | vec2b_;
  _ = vec3b_ | vec3b_;
  _ = vec4b_ | vec4b_;
  _ = i32_ | i32_;
  _ = u32_ | u32_;
  _ = vec2i_ | vec2i_;
  _ = vec3i_ | vec3i_;
  _ = vec4i_ | vec4i_;
  _ = vec2u_ | vec2u_;
  _ = vec3u_ | vec3u_;
  _ = vec4u_ | vec4u_;
  _ = bool_ & bool_;
  _ = vec2b_ & vec2b_;
  _ = vec3b_ & vec3b_;
  _ = vec4b_ & vec4b_;
  _ = i32_ & i32_;
  _ = u32_ & u32_;
  _ = vec2i_ & vec2i_;
  _ = vec3i_ & vec3i_;
  _ = vec4i_ & vec4i_;
  _ = vec2u_ & vec2u_;
  _ = vec3u_ & vec3u_;
  _ = vec4u_ & vec4u_;
  _ = -f32_;
  _ = -i32_;
  _ = -f16_;
  _ = -vec2f_;
  _ = -vec3f_;
  _ = -vec4f_;
  _ = -vec2i_;
  _ = -vec3i_;
  _ = -vec4i_;
  _ = -vec2h_;
  _ = -vec3h_;
  _ = -vec4h_;
  _ = i32_ - i32_;
  _ = u32_ - u32_;
  _ = f32_ - f32_;
  _ = f16_ - f16_;
  _ = vec2i_ - i32_;
  _ = vec3i_ - i32_;
  _ = vec4i_ - i32_;
  _ = vec2u_ - u32_;
  _ = vec3u_ - u32_;
  _ = vec4u_ - u32_;
  _ = vec2f_ - f32_;
  _ = vec3f_ - f32_;
  _ = vec4f_ - f32_;
  _ = vec2h_ - f16_;
  _ = vec3h_ - f16_;
  _ = vec4h_ - f16_;
  _ = i32_ - vec2i_;
  _ = i32_ - vec3i_;
  _ = i32_ - vec4i_;
  _ = u32_ - vec2u_;
  _ = u32_ - vec3u_;
  _ = u32_ - vec4u_;
  _ = f32_ - vec2f_;
  _ = f32_ - vec3f_;
  _ = f32_ - vec4f_;
  _ = f16_ - vec2h_;
  _ = f16_ - vec3h_;
  _ = f16_ - vec4h_;
  _ = vec2i_ - vec2i_;
  _ = vec3i_ - vec3i_;
  _ = vec4i_ - vec4i_;
  _ = vec2u_ - vec2u_;
  _ = vec3u_ - vec3u_;
  _ = vec4u_ - vec4u_;
  _ = vec2f_ - vec2f_;
  _ = vec3f_ - vec3f_;
  _ = vec4f_ - vec4f_;
  _ = vec2h_ - vec2h_;
  _ = vec3h_ - vec3h_;
  _ = vec4h_ - vec4h_;
  _ = mat2x2f_ - mat2x2f_;
  _ = mat2x3f_ - mat2x3f_;
  _ = mat2x4f_ - mat2x4f_;
  _ = mat3x2f_ - mat3x2f_;
  _ = mat3x3f_ - mat3x3f_;
  _ = mat3x4f_ - mat3x4f_;
  _ = mat4x2f_ - mat4x2f_;
  _ = mat4x3f_ - mat4x3f_;
  _ = mat4x4f_ - mat4x4f_;
  _ = mat2x2h_ - mat2x2h_;
  _ = mat2x3h_ - mat2x3h_;
  _ = mat2x4h_ - mat2x4h_;
  _ = mat3x2h_ - mat3x2h_;
  _ = mat3x3h_ - mat3x3h_;
  _ = mat3x4h_ - mat3x4h_;
  _ = mat4x2h_ - mat4x2h_;
  _ = mat4x3h_ - mat4x3h_;
  _ = mat4x4h_ - mat4x4h_;
  _ = i32_ + i32_;
  _ = u32_ + u32_;
  _ = f32_ + f32_;
  _ = f16_ + f16_;
  _ = vec2i_ + i32_;
  _ = vec3i_ + i32_;
  _ = vec4i_ + i32_;
  _ = vec2u_ + u32_;
  _ = vec3u_ + u32_;
  _ = vec4u_ + u32_;
  _ = vec2f_ + f32_;
  _ = vec3f_ + f32_;
  _ = vec4f_ + f32_;
  _ = vec2h_ + f16_;
  _ = vec3h_ + f16_;
  _ = vec4h_ + f16_;
  _ = i32_ + vec2i_;
  _ = i32_ + vec3i_;
  _ = i32_ + vec4i_;
  _ = u32_ + vec2u_;
  _ = u32_ + vec3u_;
  _ = u32_ + vec4u_;
  _ = f32_ + vec2f_;
  _ = f32_ + vec3f_;
  _ = f32_ + vec4f_;
  _ = f16_ + vec2h_;
  _ = f16_ + vec3h_;
  _ = f16_ + vec4h_;
  _ = vec2i_ + vec2i_;
  _ = vec3i_ + vec3i_;
  _ = vec4i_ + vec4i_;
  _ = vec2u_ + vec2u_;
  _ = vec3u_ + vec3u_;
  _ = vec4u_ + vec4u_;
  _ = vec2f_ + vec2f_;
  _ = vec3f_ + vec3f_;
  _ = vec4f_ + vec4f_;
  _ = vec2h_ + vec2h_;
  _ = vec3h_ + vec3h_;
  _ = vec4h_ + vec4h_;
  _ = mat2x2f_ + mat2x2f_;
  _ = mat2x3f_ + mat2x3f_;
  _ = mat2x4f_ + mat2x4f_;
  _ = mat3x2f_ + mat3x2f_;
  _ = mat3x3f_ + mat3x3f_;
  _ = mat3x4f_ + mat3x4f_;
  _ = mat4x2f_ + mat4x2f_;
  _ = mat4x3f_ + mat4x3f_;
  _ = mat4x4f_ + mat4x4f_;
  _ = mat2x2h_ + mat2x2h_;
  _ = mat2x3h_ + mat2x3h_;
  _ = mat2x4h_ + mat2x4h_;
  _ = mat3x2h_ + mat3x2h_;
  _ = mat3x3h_ + mat3x3h_;
  _ = mat3x4h_ + mat3x4h_;
  _ = mat4x2h_ + mat4x2h_;
  _ = mat4x3h_ + mat4x3h_;
  _ = mat4x4h_ + mat4x4h_;
  _ = i32_ % i32_;
  _ = u32_ % u32_;
  _ = f32_ % f32_;
  _ = f16_ % f16_;
  _ = vec2i_ % i32_;
  _ = vec3i_ % i32_;
  _ = vec4i_ % i32_;
  _ = vec2u_ % u32_;
  _ = vec3u_ % u32_;
  _ = vec4u_ % u32_;
  _ = vec2f_ % f32_;
  _ = vec3f_ % f32_;
  _ = vec4f_ % f32_;
  _ = vec2h_ % f16_;
  _ = vec3h_ % f16_;
  _ = vec4h_ % f16_;
  _ = i32_ % vec2i_;
  _ = i32_ % vec3i_;
  _ = i32_ % vec4i_;
  _ = u32_ % vec2u_;
  _ = u32_ % vec3u_;
  _ = u32_ % vec4u_;
  _ = f32_ % vec2f_;
  _ = f32_ % vec3f_;
  _ = f32_ % vec4f_;
  _ = f16_ % vec2h_;
  _ = f16_ % vec3h_;
  _ = f16_ % vec4h_;
  _ = vec2i_ % vec2i_;
  _ = vec3i_ % vec3i_;
  _ = vec4i_ % vec4i_;
  _ = vec2u_ % vec2u_;
  _ = vec3u_ % vec3u_;
  _ = vec4u_ % vec4u_;
  _ = vec2f_ % vec2f_;
  _ = vec3f_ % vec3f_;
  _ = vec4f_ % vec4f_;
  _ = vec2h_ % vec2h_;
  _ = vec3h_ % vec3h_;
  _ = vec4h_ % vec4h_;
  _ = i32_ * i32_;
  _ = u32_ * u32_;
  _ = f32_ * f32_;
  _ = f16_ * f16_;
  _ = vec2i_ * i32_;
  _ = vec3i_ * i32_;
  _ = vec4i_ * i32_;
  _ = vec2u_ * u32_;
  _ = vec3u_ * u32_;
  _ = vec4u_ * u32_;
  _ = vec2f_ * f32_;
  _ = vec3f_ * f32_;
  _ = vec4f_ * f32_;
  _ = vec2h_ * f16_;
  _ = vec3h_ * f16_;
  _ = vec4h_ * f16_;
  _ = i32_ * vec2i_;
  _ = i32_ * vec3i_;
  _ = i32_ * vec4i_;
  _ = u32_ * vec2u_;
  _ = u32_ * vec3u_;
  _ = u32_ * vec4u_;
  _ = f32_ * vec2f_;
  _ = f32_ * vec3f_;
  _ = f32_ * vec4f_;
  _ = f16_ * vec2h_;
  _ = f16_ * vec3h_;
  _ = f16_ * vec4h_;
  _ = vec2i_ * vec2i_;
  _ = vec3i_ * vec3i_;
  _ = vec4i_ * vec4i_;
  _ = vec2u_ * vec2u_;
  _ = vec3u_ * vec3u_;
  _ = vec4u_ * vec4u_;
  _ = vec2f_ * vec2f_;
  _ = vec3f_ * vec3f_;
  _ = vec4f_ * vec4f_;
  _ = vec2h_ * vec2h_;
  _ = vec3h_ * vec3h_;
  _ = vec4h_ * vec4h_;
  _ = mat2x2f_ * f32_;
  _ = mat2x3f_ * f32_;
  _ = mat2x4f_ * f32_;
  _ = mat3x2f_ * f32_;
  _ = mat3x3f_ * f32_;
  _ = mat3x4f_ * f32_;
  _ = mat4x2f_ * f32_;
  _ = mat4x3f_ * f32_;
  _ = mat4x4f_ * f32_;
  _ = mat2x2h_ * f16_;
  _ = mat2x3h_ * f16_;
  _ = mat2x4h_ * f16_;
  _ = mat3x2h_ * f16_;
  _ = mat3x3h_ * f16_;
  _ = mat3x4h_ * f16_;
  _ = mat4x2h_ * f16_;
  _ = mat4x3h_ * f16_;
  _ = mat4x4h_ * f16_;
  _ = f32_ * mat2x2f_;
  _ = f32_ * mat2x3f_;
  _ = f32_ * mat2x4f_;
  _ = f32_ * mat3x2f_;
  _ = f32_ * mat3x3f_;
  _ = f32_ * mat3x4f_;
  _ = f32_ * mat4x2f_;
  _ = f32_ * mat4x3f_;
  _ = f32_ * mat4x4f_;
  _ = f16_ * mat2x2h_;
  _ = f16_ * mat2x3h_;
  _ = f16_ * mat2x4h_;
  _ = f16_ * mat3x2h_;
  _ = f16_ * mat3x3h_;
  _ = f16_ * mat3x4h_;
  _ = f16_ * mat4x2h_;
  _ = f16_ * mat4x3h_;
  _ = f16_ * mat4x4h_;
  _ = mat2x2f_ * vec2f_;
  _ = mat2x3f_ * vec2f_;
  _ = mat2x4f_ * vec2f_;
  _ = mat3x2f_ * vec3f_;
  _ = mat3x3f_ * vec3f_;
  _ = mat3x4f_ * vec3f_;
  _ = mat4x2f_ * vec4f_;
  _ = mat4x3f_ * vec4f_;
  _ = mat4x4f_ * vec4f_;
  _ = mat2x2h_ * vec2h_;
  _ = mat2x3h_ * vec2h_;
  _ = mat2x4h_ * vec2h_;
  _ = mat3x2h_ * vec3h_;
  _ = mat3x3h_ * vec3h_;
  _ = mat3x4h_ * vec3h_;
  _ = mat4x2h_ * vec4h_;
  _ = mat4x3h_ * vec4h_;
  _ = mat4x4h_ * vec4h_;
  _ = vec2f_ * mat2x2f_;
  _ = vec3f_ * mat2x3f_;
  _ = vec4f_ * mat2x4f_;
  _ = vec2f_ * mat3x2f_;
  _ = vec3f_ * mat3x3f_;
  _ = vec4f_ * mat3x4f_;
  _ = vec2f_ * mat4x2f_;
  _ = vec3f_ * mat4x3f_;
  _ = vec4f_ * mat4x4f_;
  _ = vec2h_ * mat2x2h_;
  _ = vec3h_ * mat2x3h_;
  _ = vec4h_ * mat2x4h_;
  _ = vec2h_ * mat3x2h_;
  _ = vec3h_ * mat3x3h_;
  _ = vec4h_ * mat3x4h_;
  _ = vec2h_ * mat4x2h_;
  _ = vec3h_ * mat4x3h_;
  _ = vec4h_ * mat4x4h_;
  _ = mat2x2f_ * mat2x2f_;
  _ = mat3x2f_ * mat2x3f_;
  _ = mat4x2f_ * mat2x4f_;
  _ = mat2x3f_ * mat2x2f_;
  _ = mat3x3f_ * mat2x3f_;
  _ = mat4x3f_ * mat2x4f_;
  _ = mat2x4f_ * mat2x2f_;
  _ = mat3x4f_ * mat2x3f_;
  _ = mat4x4f_ * mat2x4f_;
  _ = mat2x2f_ * mat3x2f_;
  _ = mat3x2f_ * mat3x3f_;
  _ = mat4x2f_ * mat3x4f_;
  _ = mat2x3f_ * mat3x2f_;
  _ = mat3x3f_ * mat3x3f_;
  _ = mat4x3f_ * mat3x4f_;
  _ = mat2x4f_ * mat3x2f_;
  _ = mat3x4f_ * mat3x3f_;
  _ = mat4x4f_ * mat3x4f_;
  _ = mat2x2f_ * mat4x2f_;
  _ = mat3x2f_ * mat4x3f_;
  _ = mat4x2f_ * mat4x4f_;
  _ = mat2x3f_ * mat4x2f_;
  _ = mat3x3f_ * mat4x3f_;
  _ = mat4x3f_ * mat4x4f_;
  _ = mat2x4f_ * mat4x2f_;
  _ = mat3x4f_ * mat4x3f_;
  _ = mat4x4f_ * mat4x4f_;
  _ = mat2x2h_ * mat2x2h_;
  _ = mat3x2h_ * mat2x3h_;
  _ = mat4x2h_ * mat2x4h_;
  _ = mat2x3h_ * mat2x2h_;
  _ = mat3x3h_ * mat2x3h_;
  _ = mat4x3h_ * mat2x4h_;
  _ = mat2x4h_ * mat2x2h_;
  _ = mat3x4h_ * mat2x3h_;
  _ = mat4x4h_ * mat2x4h_;
  _ = mat2x2h_ * mat3x2h_;
  _ = mat3x2h_ * mat3x3h_;
  _ = mat4x2h_ * mat3x4h_;
  _ = mat2x3h_ * mat3x2h_;
  _ = mat3x3h_ * mat3x3h_;
  _ = mat4x3h_ * mat3x4h_;
  _ = mat2x4h_ * mat3x2h_;
  _ = mat3x4h_ * mat3x3h_;
  _ = mat4x4h_ * mat3x4h_;
  _ = mat2x2h_ * mat4x2h_;
  _ = mat3x2h_ * mat4x3h_;
  _ = mat4x2h_ * mat4x4h_;
  _ = mat2x3h_ * mat4x2h_;
  _ = mat3x3h_ * mat4x3h_;
  _ = mat4x3h_ * mat4x4h_;
  _ = mat2x4h_ * mat4x2h_;
  _ = mat3x4h_ * mat4x3h_;
  _ = mat4x4h_ * mat4x4h_;
  _ = i32_ / i32_;
  _ = u32_ / u32_;
  _ = f32_ / f32_;
  _ = f16_ / f16_;
  _ = vec2i_ / i32_;
  _ = vec3i_ / i32_;
  _ = vec4i_ / i32_;
  _ = vec2u_ / u32_;
  _ = vec3u_ / u32_;
  _ = vec4u_ / u32_;
  _ = vec2f_ / f32_;
  _ = vec3f_ / f32_;
  _ = vec4f_ / f32_;
  _ = vec2h_ / f16_;
  _ = vec3h_ / f16_;
  _ = vec4h_ / f16_;
  _ = i32_ / vec2i_;
  _ = i32_ / vec3i_;
  _ = i32_ / vec4i_;
  _ = u32_ / vec2u_;
  _ = u32_ / vec3u_;
  _ = u32_ / vec4u_;
  _ = f32_ / vec2f_;
  _ = f32_ / vec3f_;
  _ = f32_ / vec4f_;
  _ = f16_ / vec2h_;
  _ = f16_ / vec3h_;
  _ = f16_ / vec4h_;
  _ = vec2i_ / vec2i_;
  _ = vec3i_ / vec3i_;
  _ = vec4i_ / vec4i_;
  _ = vec2u_ / vec2u_;
  _ = vec3u_ / vec3u_;
  _ = vec4u_ / vec4u_;
  _ = vec2f_ / vec2f_;
  _ = vec3f_ / vec3f_;
  _ = vec4f_ / vec4f_;
  _ = vec2h_ / vec2h_;
  _ = vec3h_ / vec3h_;
  _ = vec4h_ / vec4h_;
  _ = i32_ % i32_;
  _ = u32_ % u32_;
  _ = f32_ % f32_;
  _ = f16_ % f16_;
  _ = vec2i_ % i32_;
  _ = vec3i_ % i32_;
  _ = vec4i_ % i32_;
  _ = vec2u_ % u32_;
  _ = vec3u_ % u32_;
  _ = vec4u_ % u32_;
  _ = vec2f_ % f32_;
  _ = vec3f_ % f32_;
  _ = vec4f_ % f32_;
  _ = vec2h_ % f16_;
  _ = vec3h_ % f16_;
  _ = vec4h_ % f16_;
  _ = i32_ % vec2i_;
  _ = i32_ % vec3i_;
  _ = i32_ % vec4i_;
  _ = u32_ % vec2u_;
  _ = u32_ % vec3u_;
  _ = u32_ % vec4u_;
  _ = f32_ % vec2f_;
  _ = f32_ % vec3f_;
  _ = f32_ % vec4f_;
  _ = f16_ % vec2h_;
  _ = f16_ % vec3h_;
  _ = f16_ % vec4h_;
  _ = vec2i_ % vec2i_;
  _ = vec3i_ % vec3i_;
  _ = vec4i_ % vec4i_;
  _ = vec2u_ % vec2u_;
  _ = vec3u_ % vec3u_;
  _ = vec4u_ % vec4u_;
  _ = vec2f_ % vec2f_;
  _ = vec3f_ % vec3f_;
  _ = vec4f_ % vec4f_;
  _ = vec2h_ % vec2h_;
  _ = vec3h_ % vec3h_;
  _ = vec4h_ % vec4h_;
  _ = i32_ == i32_;
  _ = u32_ == u32_;
  _ = f32_ == f32_;
  _ = f16_ == f16_;
  _ = bool_ == bool_;
  _ = vec2i_ == vec2i_;
  _ = vec3i_ == vec3i_;
  _ = vec4i_ == vec4i_;
  _ = vec2u_ == vec2u_;
  _ = vec3u_ == vec3u_;
  _ = vec4u_ == vec4u_;
  _ = vec2f_ == vec2f_;
  _ = vec3f_ == vec3f_;
  _ = vec4f_ == vec4f_;
  _ = vec2h_ == vec2h_;
  _ = vec3h_ == vec3h_;
  _ = vec4h_ == vec4h_;
  _ = vec2b_ == vec2b_;
  _ = vec3b_ == vec3b_;
  _ = vec4b_ == vec4b_;
  _ = i32_ != i32_;
  _ = u32_ != u32_;
  _ = f32_ != f32_;
  _ = f16_ != f16_;
  _ = bool_ != bool_;
  _ = vec2i_ != vec2i_;
  _ = vec3i_ != vec3i_;
  _ = vec4i_ != vec4i_;
  _ = vec2u_ != vec2u_;
  _ = vec3u_ != vec3u_;
  _ = vec4u_ != vec4u_;
  _ = vec2f_ != vec2f_;
  _ = vec3f_ != vec3f_;
  _ = vec4f_ != vec4f_;
  _ = vec2h_ != vec2h_;
  _ = vec3h_ != vec3h_;
  _ = vec4h_ != vec4h_;
  _ = vec2b_ != vec2b_;
  _ = vec3b_ != vec3b_;
  _ = vec4b_ != vec4b_;
  _ = i32_ < i32_;
  _ = u32_ < u32_;
  _ = f32_ < f32_;
  _ = f16_ < f16_;
  _ = vec2i_ < vec2i_;
  _ = vec3i_ < vec3i_;
  _ = vec4i_ < vec4i_;
  _ = vec2u_ < vec2u_;
  _ = vec3u_ < vec3u_;
  _ = vec4u_ < vec4u_;
  _ = vec2f_ < vec2f_;
  _ = vec3f_ < vec3f_;
  _ = vec4f_ < vec4f_;
  _ = vec2h_ < vec2h_;
  _ = vec3h_ < vec3h_;
  _ = vec4h_ < vec4h_;
  _ = i32_ <= i32_;
  _ = u32_ <= u32_;
  _ = f32_ <= f32_;
  _ = f16_ <= f16_;
  _ = vec2i_ <= vec2i_;
  _ = vec3i_ <= vec3i_;
  _ = vec4i_ <= vec4i_;
  _ = vec2u_ <= vec2u_;
  _ = vec3u_ <= vec3u_;
  _ = vec4u_ <= vec4u_;
  _ = vec2f_ <= vec2f_;
  _ = vec3f_ <= vec3f_;
  _ = vec4f_ <= vec4f_;
  _ = vec2h_ <= vec2h_;
  _ = vec3h_ <= vec3h_;
  _ = vec4h_ <= vec4h_;
  _ = i32_ > i32_;
  _ = u32_ > u32_;
  _ = f32_ > f32_;
  _ = f16_ > f16_;
  _ = vec2i_ > vec2i_;
  _ = vec3i_ > vec3i_;
  _ = vec4i_ > vec4i_;
  _ = vec2u_ > vec2u_;
  _ = vec3u_ > vec3u_;
  _ = vec4u_ > vec4u_;
  _ = vec2f_ > vec2f_;
  _ = vec3f_ > vec3f_;
  _ = vec4f_ > vec4f_;
  _ = vec2h_ > vec2h_;
  _ = vec3h_ > vec3h_;
  _ = vec4h_ > vec4h_;
  _ = i32_ >= i32_;
  _ = u32_ >= u32_;
  _ = f32_ >= f32_;
  _ = f16_ >= f16_;
  _ = vec2i_ >= vec2i_;
  _ = vec3i_ >= vec3i_;
  _ = vec4i_ >= vec4i_;
  _ = vec2u_ >= vec2u_;
  _ = vec3u_ >= vec3u_;
  _ = vec4u_ >= vec4u_;
  _ = vec2f_ >= vec2f_;
  _ = vec3f_ >= vec3f_;
  _ = vec4f_ >= vec4f_;
  _ = vec2h_ >= vec2h_;
  _ = vec3h_ >= vec3h_;
  _ = vec4h_ >= vec4h_;
  _ = ~i32_;
  _ = ~u32_;
  _ = ~vec2i_;
  _ = ~vec3i_;
  _ = ~vec4i_;
  _ = ~vec2u_;
  _ = ~vec3u_;
  _ = ~vec4u_;
  _ = i32_ ^ i32_;
  _ = u32_ ^ u32_;
  _ = vec2i_ ^ vec2i_;
  _ = vec3i_ ^ vec3i_;
  _ = vec4i_ ^ vec4i_;
  _ = vec2u_ ^ vec2u_;
  _ = vec3u_ ^ vec3u_;
  _ = vec4u_ ^ vec4u_;
  _ = i32_ << u32_;
  _ = u32_ << u32_;
  _ = vec2i_ << vec2u_;
  _ = vec3i_ << vec3u_;
  _ = vec4i_ << vec4u_;
  _ = vec2u_ << vec2u_;
  _ = vec3u_ << vec3u_;
  _ = vec4u_ << vec4u_;
  _ = i32_ >> u32_;
  _ = u32_ >> u32_;
  _ = vec2i_ >> vec2u_;
  _ = vec3i_ >> vec3u_;
  _ = vec4i_ >> vec4u_;
  _ = vec2u_ >> vec2u_;
  _ = vec3u_ >> vec3u_;
  _ = vec4u_ >> vec4u_;

  _ = bool();
  _ = bool(i32_);
  _ = bool(u32_);
  _ = bool(f32_);
  _ = bool(f16_);
  _ = bool(bool_);
  _ = i32();
  _ = i32(i32_);
  _ = i32(u32_);
  _ = i32(f32_);
  _ = i32(f16_);
  _ = i32(bool_);
  _ = u32();
  _ = u32(i32_);
  _ = u32(u32_);
  _ = u32(f32_);
  _ = u32(f16_);
  _ = u32(bool_);
  _ = f32();
  _ = f32(i32_);
  _ = f32(u32_);
  _ = f32(f32_);
  _ = f32(f16_);
  _ = f32(bool_);
  _ = f16();
  _ = f16(i32_);
  _ = f16(u32_);
  _ = f16(f32_);
  _ = f16(f16_);
  _ = f16(bool_);
  _ = vec2();
  _ = vec2();
  _ = vec2();
  _ = vec2();
  _ = vec2();
  _ = vec2(i32_);
  _ = vec2(u32_);
  _ = vec2(f32_);
  _ = vec2(f16_);
  _ = vec2(bool_);
  _ = vec2(vec2i_);
  _ = vec2(vec2u_);
  _ = vec2(vec2f_);
  _ = vec2(vec2h_);
  _ = vec2(vec2b_);
  _ = vec2(vec2i_);
  _ = vec2(vec2u_);
  _ = vec2(vec2f_);
  _ = vec2(vec2h_);
  _ = vec2(vec2b_);
  _ = vec2(vec2i_);
  _ = vec2(vec2u_);
  _ = vec2(vec2f_);
  _ = vec2(vec2h_);
  _ = vec2(vec2b_);
  _ = vec2(vec2i_);
  _ = vec2(vec2u_);
  _ = vec2(vec2f_);
  _ = vec2(vec2h_);
  _ = vec2(vec2b_);
  _ = vec2(vec2i_);
  _ = vec2(vec2u_);
  _ = vec2(vec2f_);
  _ = vec2(vec2h_);
  _ = vec2(vec2b_);
  _ = vec2(vec2i_);
  _ = vec2(vec2u_);
  _ = vec2(vec2f_);
  _ = vec2(vec2h_);
  _ = vec2(vec2b_);
  _ = vec2(i32_, i32_);
  _ = vec2(u32_, u32_);
  _ = vec2(f32_, f32_);
  _ = vec2(f16_, f16_);
  _ = vec2(bool_, bool_);
  _ = vec2();
  _ = vec3();
  _ = vec3();
  _ = vec3();
  _ = vec3();
  _ = vec3();
  _ = vec3(i32_);
  _ = vec3(u32_);
  _ = vec3(f32_);
  _ = vec3(f16_);
  _ = vec3(bool_);
  _ = vec3(vec3i_);
  _ = vec3(vec3u_);
  _ = vec3(vec3f_);
  _ = vec3(vec3h_);
  _ = vec3(vec3b_);
  _ = vec3(vec3i_);
  _ = vec3(vec3u_);
  _ = vec3(vec3f_);
  _ = vec3(vec3h_);
  _ = vec3(vec3b_);
  _ = vec3(vec3i_);
  _ = vec3(vec3u_);
  _ = vec3(vec3f_);
  _ = vec3(vec3h_);
  _ = vec3(vec3b_);
  _ = vec3(vec3i_);
  _ = vec3(vec3u_);
  _ = vec3(vec3f_);
  _ = vec3(vec3h_);
  _ = vec3(vec3b_);
  _ = vec3(vec3i_);
  _ = vec3(vec3u_);
  _ = vec3(vec3f_);
  _ = vec3(vec3h_);
  _ = vec3(vec3b_);
  _ = vec3(vec3i_);
  _ = vec3(vec3u_);
  _ = vec3(vec3f_);
  _ = vec3(vec3h_);
  _ = vec3(vec3b_);
  _ = vec3(i32_, i32_, i32_);
  _ = vec3(u32_, u32_, u32_);
  _ = vec3(f32_, f32_, f32_);
  _ = vec3(f16_, f16_, f16_);
  _ = vec3(bool_, bool_, bool_);
  _ = vec3(vec2i_, i32_);
  _ = vec3(vec2u_, u32_);
  _ = vec3(vec2f_, f32_);
  _ = vec3(vec2h_, f16_);
  _ = vec3(vec2b_, bool_);
  _ = vec3(i32_, vec2i_);
  _ = vec3(u32_, vec2u_);
  _ = vec3(f32_, vec2f_);
  _ = vec3(f16_, vec2h_);
  _ = vec3(bool_, vec2b_);
  _ = vec3();
  _ = vec4();
  _ = vec4();
  _ = vec4();
  _ = vec4();
  _ = vec4();
  _ = vec4(i32_);
  _ = vec4(u32_);
  _ = vec4(f32_);
  _ = vec4(f16_);
  _ = vec4(bool_);
  _ = vec4(vec4i_);
  _ = vec4(vec4u_);
  _ = vec4(vec4f_);
  _ = vec4(vec4h_);
  _ = vec4(vec4b_);
  _ = vec4(vec4i_);
  _ = vec4(vec4u_);
  _ = vec4(vec4f_);
  _ = vec4(vec4h_);
  _ = vec4(vec4b_);
  _ = vec4(vec4i_);
  _ = vec4(vec4u_);
  _ = vec4(vec4f_);
  _ = vec4(vec4h_);
  _ = vec4(vec4b_);
  _ = vec4(vec4i_);
  _ = vec4(vec4u_);
  _ = vec4(vec4f_);
  _ = vec4(vec4h_);
  _ = vec4(vec4b_);
  _ = vec4(vec4i_);
  _ = vec4(vec4u_);
  _ = vec4(vec4f_);
  _ = vec4(vec4h_);
  _ = vec4(vec4b_);
  _ = vec4(vec4i_);
  _ = vec4(vec4u_);
  _ = vec4(vec4f_);
  _ = vec4(vec4h_);
  _ = vec4(vec4b_);
  _ = vec4(i32_, i32_, i32_, i32_);
  _ = vec4(u32_, u32_, u32_, u32_);
  _ = vec4(f32_, f32_, f32_, f32_);
  _ = vec4(f16_, f16_, f16_, f16_);
  _ = vec4(bool_, bool_, bool_, bool_);
  _ = vec4(i32_, vec2i_, i32_);
  _ = vec4(u32_, vec2u_, u32_);
  _ = vec4(f32_, vec2f_, f32_);
  _ = vec4(f16_, vec2h_, f16_);
  _ = vec4(bool_, vec2b_, bool_);
  _ = vec4(i32_, i32_, vec2i_);
  _ = vec4(u32_, u32_, vec2u_);
  _ = vec4(f32_, f32_, vec2f_);
  _ = vec4(f16_, f16_, vec2h_);
  _ = vec4(bool_, bool_, vec2b_);
  _ = vec4(vec2i_, i32_, i32_);
  _ = vec4(vec2u_, u32_, u32_);
  _ = vec4(vec2f_, f32_, f32_);
  _ = vec4(vec2h_, f16_, f16_);
  _ = vec4(vec2b_, bool_, bool_);
  _ = vec4(vec2i_, vec2i_);
  _ = vec4(vec2u_, vec2u_);
  _ = vec4(vec2f_, vec2f_);
  _ = vec4(vec2h_, vec2h_);
  _ = vec4(vec2b_, vec2b_);
  _ = vec4(vec3i_, i32_);
  _ = vec4(vec3u_, u32_);
  _ = vec4(vec3f_, f32_);
  _ = vec4(vec3h_, f16_);
  _ = vec4(vec3b_, bool_);
  _ = vec4(i32_, vec3i_);
  _ = vec4(u32_, vec3u_);
  _ = vec4(f32_, vec3f_);
  _ = vec4(f16_, vec3h_);
  _ = vec4(bool_, vec3b_);
  _ = vec4();
  _ = mat2x2(mat2x2f_);
  _ = mat2x2(mat2x2h_);
  _ = mat2x2(mat2x2f_);
  _ = mat2x2(mat2x2h_);
  _ = mat2x2(mat2x2f_);
  _ = mat2x2(mat2x2h_);
  _ = mat2x2(f32_, f32_, f32_, f32_);
  _ = mat2x2(f16_, f16_, f16_, f16_);
  _ = mat2x2(vec2f_, vec2f_);
  _ = mat2x2(vec2h_, vec2h_);
  _ = mat2x3(mat2x3f_);
  _ = mat2x3(mat2x3h_);
  _ = mat2x3(mat2x3f_);
  _ = mat2x3(mat2x3h_);
  _ = mat2x3(mat2x3f_);
  _ = mat2x3(mat2x3h_);
  _ = mat2x3(f32_, f32_, f32_, f32_, f32_, f32_);
  _ = mat2x3(f16_, f16_, f16_, f16_, f16_, f16_);
  _ = mat2x3(vec3f_, vec3f_);
  _ = mat2x3(vec3h_, vec3h_);
  _ = mat2x4(mat2x4f_);
  _ = mat2x4(mat2x4h_);
  _ = mat2x4(mat2x4f_);
  _ = mat2x4(mat2x4h_);
  _ = mat2x4(mat2x4f_);
  _ = mat2x4(mat2x4h_);
  _ = mat2x4(f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_);
  _ = mat2x4(f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_);
  _ = mat2x4(vec4f_, vec4f_);
  _ = mat2x4(vec4h_, vec4h_);
  _ = mat3x2(mat3x2f_);
  _ = mat3x2(mat3x2h_);
  _ = mat3x2(mat3x2f_);
  _ = mat3x2(mat3x2h_);
  _ = mat3x2(mat3x2f_);
  _ = mat3x2(mat3x2h_);
  _ = mat3x2(f32_, f32_, f32_, f32_, f32_, f32_);
  _ = mat3x2(f16_, f16_, f16_, f16_, f16_, f16_);
  _ = mat3x2(vec2f_, vec2f_, vec2f_);
  _ = mat3x2(vec2h_, vec2h_, vec2h_);
  _ = mat3x3(mat3x3f_);
  _ = mat3x3(mat3x3h_);
  _ = mat3x3(mat3x3f_);
  _ = mat3x3(mat3x3h_);
  _ = mat3x3(mat3x3f_);
  _ = mat3x3(mat3x3h_);
  _ = mat3x3(f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_);
  _ = mat3x3(f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_);
  _ = mat3x3(vec3f_, vec3f_, vec3f_);
  _ = mat3x3(vec3h_, vec3h_, vec3h_);
  _ = mat3x4(mat3x4f_);
  _ = mat3x4(mat3x4h_);
  _ = mat3x4(mat3x4f_);
  _ = mat3x4(mat3x4h_);
  _ = mat3x4(mat3x4f_);
  _ = mat3x4(mat3x4h_);
  _ = mat3x4(f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_);
  _ = mat3x4(f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_);
  _ = mat3x4(vec4f_, vec4f_, vec4f_);
  _ = mat3x4(vec4h_, vec4h_, vec4h_);
  _ = mat4x2(mat4x2f_);
  _ = mat4x2(mat4x2h_);
  _ = mat4x2(mat4x2f_);
  _ = mat4x2(mat4x2h_);
  _ = mat4x2(mat4x2f_);
  _ = mat4x2(mat4x2h_);
  _ = mat4x2(f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_);
  _ = mat4x2(f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_);
  _ = mat4x2(vec2f_, vec2f_, vec2f_, vec2f_);
  _ = mat4x2(vec2h_, vec2h_, vec2h_, vec2h_);
  _ = mat4x3(mat4x3f_);
  _ = mat4x3(mat4x3h_);
  _ = mat4x3(mat4x3f_);
  _ = mat4x3(mat4x3h_);
  _ = mat4x3(mat4x3f_);
  _ = mat4x3(mat4x3h_);
  _ = mat4x3(f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_);
  _ = mat4x3(f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_);
  _ = mat4x3(vec3f_, vec3f_, vec3f_, vec3f_);
  _ = mat4x3(vec3h_, vec3h_, vec3h_, vec3h_);
  _ = mat4x4(mat4x4f_);
  _ = mat4x4(mat4x4h_);
  _ = mat4x4(mat4x4f_);
  _ = mat4x4(mat4x4h_);
  _ = mat4x4(mat4x4f_);
  _ = mat4x4(mat4x4h_);
  _ = mat4x4(f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_);
  _ = mat4x4(f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_, f16_);
  _ = mat4x4(vec4f_, vec4f_, vec4f_, vec4f_);
  _ = mat4x4(vec4h_, vec4h_, vec4h_, vec4h_);

  _ = all(vec2b_);
  _ = all(vec3b_);
  _ = all(vec4b_);
  _ = all(bool_);
  _ = all(bool_);
  _ = all(bool_);
  _ = any(vec2b_);
  _ = any(vec3b_);
  _ = any(vec4b_);
  _ = any(bool_);
  _ = any(bool_);
  _ = any(bool_);
  _ = select(i32_, i32_, bool_);
  _ = select(u32_, u32_, bool_);
  _ = select(f32_, f32_, bool_);
  _ = select(f16_, f16_, bool_);
  _ = select(bool_, bool_, bool_);
  _ = select(vec2i_, vec2i_, bool_);
  _ = select(vec3i_, vec3i_, bool_);
  _ = select(vec4i_, vec4i_, bool_);
  _ = select(vec2u_, vec2u_, bool_);
  _ = select(vec3u_, vec3u_, bool_);
  _ = select(vec4u_, vec4u_, bool_);
  _ = select(vec2f_, vec2f_, bool_);
  _ = select(vec3f_, vec3f_, bool_);
  _ = select(vec4f_, vec4f_, bool_);
  _ = select(vec2h_, vec2h_, bool_);
  _ = select(vec3h_, vec3h_, bool_);
  _ = select(vec4h_, vec4h_, bool_);
  _ = select(vec2b_, vec2b_, bool_);
  _ = select(vec3b_, vec3b_, bool_);
  _ = select(vec4b_, vec4b_, bool_);
  _ = select(vec2i_, vec2i_, vec2b_);
  _ = select(vec3i_, vec3i_, vec3b_);
  _ = select(vec4i_, vec4i_, vec4b_);
  _ = select(vec2u_, vec2u_, vec2b_);
  _ = select(vec3u_, vec3u_, vec3b_);
  _ = select(vec4u_, vec4u_, vec4b_);
  _ = select(vec2f_, vec2f_, vec2b_);
  _ = select(vec3f_, vec3f_, vec3b_);
  _ = select(vec4f_, vec4f_, vec4b_);
  _ = select(vec2h_, vec2h_, vec2b_);
  _ = select(vec3h_, vec3h_, vec3b_);
  _ = select(vec4h_, vec4h_, vec4b_);
  _ = select(vec2b_, vec2b_, vec2b_);
  _ = select(vec3b_, vec3b_, vec3b_);
  _ = select(vec4b_, vec4b_, vec4b_);
  _ = acos(f32_);
  _ = acos(f16_);
  _ = acos(vec2f_);
  _ = acos(vec3f_);
  _ = acos(vec4f_);
  _ = acos(vec2h_);
  _ = acos(vec3h_);
  _ = acos(vec4h_);
  _ = asin(f32_);
  _ = asin(f16_);
  _ = asin(vec2f_);
  _ = asin(vec3f_);
  _ = asin(vec4f_);
  _ = asin(vec2h_);
  _ = asin(vec3h_);
  _ = asin(vec4h_);
  _ = atan(f32_);
  _ = atan(f16_);
  _ = atan(vec2f_);
  _ = atan(vec3f_);
  _ = atan(vec4f_);
  _ = atan(vec2h_);
  _ = atan(vec3h_);
  _ = atan(vec4h_);
  _ = cos(f32_);
  _ = cos(f16_);
  _ = cos(vec2f_);
  _ = cos(vec3f_);
  _ = cos(vec4f_);
  _ = cos(vec2h_);
  _ = cos(vec3h_);
  _ = cos(vec4h_);
  _ = sin(f32_);
  _ = sin(f16_);
  _ = sin(vec2f_);
  _ = sin(vec3f_);
  _ = sin(vec4f_);
  _ = sin(vec2h_);
  _ = sin(vec3h_);
  _ = sin(vec4h_);
  _ = tan(f32_);
  _ = tan(f16_);
  _ = tan(vec2f_);
  _ = tan(vec3f_);
  _ = tan(vec4f_);
  _ = tan(vec2h_);
  _ = tan(vec3h_);
  _ = tan(vec4h_);
  _ = acosh(1f);
  _ = acosh(1h);
  _ = acosh(vec2f(1));
  _ = acosh(vec3f(1));
  _ = acosh(vec4f(1));
  _ = acosh(vec2h(1));
  _ = acosh(vec3h(1));
  _ = acosh(vec4h(1));
  _ = asinh(f32_);
  _ = asinh(f16_);
  _ = asinh(vec2f_);
  _ = asinh(vec3f_);
  _ = asinh(vec4f_);
  _ = asinh(vec2h_);
  _ = asinh(vec3h_);
  _ = asinh(vec4h_);
  _ = atanh(f32_);
  _ = atanh(f16_);
  _ = atanh(vec2f_);
  _ = atanh(vec3f_);
  _ = atanh(vec4f_);
  _ = atanh(vec2h_);
  _ = atanh(vec3h_);
  _ = atanh(vec4h_);
  _ = cosh(f32_);
  _ = cosh(f16_);
  _ = cosh(vec2f_);
  _ = cosh(vec3f_);
  _ = cosh(vec4f_);
  _ = cosh(vec2h_);
  _ = cosh(vec3h_);
  _ = cosh(vec4h_);
  _ = sinh(f32_);
  _ = sinh(f16_);
  _ = sinh(vec2f_);
  _ = sinh(vec3f_);
  _ = sinh(vec4f_);
  _ = sinh(vec2h_);
  _ = sinh(vec3h_);
  _ = sinh(vec4h_);
  _ = tanh(f32_);
  _ = tanh(f16_);
  _ = tanh(vec2f_);
  _ = tanh(vec3f_);
  _ = tanh(vec4f_);
  _ = tanh(vec2h_);
  _ = tanh(vec3h_);
  _ = tanh(vec4h_);
  _ = abs(i32_);
  _ = abs(u32_);
  _ = abs(f32_);
  _ = abs(f16_);
  _ = abs(vec2i_);
  _ = abs(vec3i_);
  _ = abs(vec4i_);
  _ = abs(vec2u_);
  _ = abs(vec3u_);
  _ = abs(vec4u_);
  _ = abs(vec2f_);
  _ = abs(vec3f_);
  _ = abs(vec4f_);
  _ = abs(vec2h_);
  _ = abs(vec3h_);
  _ = abs(vec4h_);
  _ = atan2(f32_, f32_);
  _ = atan2(f16_, f16_);
  _ = atan2(vec2f_, vec2f_);
  _ = atan2(vec3f_, vec3f_);
  _ = atan2(vec4f_, vec4f_);
  _ = atan2(vec2h_, vec2h_);
  _ = atan2(vec3h_, vec3h_);
  _ = atan2(vec4h_, vec4h_);
  _ = ceil(f32_);
  _ = ceil(f16_);
  _ = ceil(vec2f_);
  _ = ceil(vec3f_);
  _ = ceil(vec4f_);
  _ = ceil(vec2h_);
  _ = ceil(vec3h_);
  _ = ceil(vec4h_);
  _ = clamp(i32_, i32_, i32_);
  _ = clamp(u32_, u32_, u32_);
  _ = clamp(f32_, f32_, f32_);
  _ = clamp(f16_, f16_, f16_);
  _ = clamp(vec2i_, vec2i_, vec2i_);
  _ = clamp(vec3i_, vec3i_, vec3i_);
  _ = clamp(vec4i_, vec4i_, vec4i_);
  _ = clamp(vec2u_, vec2u_, vec2u_);
  _ = clamp(vec3u_, vec3u_, vec3u_);
  _ = clamp(vec4u_, vec4u_, vec4u_);
  _ = clamp(vec2f_, vec2f_, vec2f_);
  _ = clamp(vec3f_, vec3f_, vec3f_);
  _ = clamp(vec4f_, vec4f_, vec4f_);
  _ = clamp(vec2h_, vec2h_, vec2h_);
  _ = clamp(vec3h_, vec3h_, vec3h_);
  _ = clamp(vec4h_, vec4h_, vec4h_);
  _ = countLeadingZeros(i32_);
  _ = countLeadingZeros(u32_);
  _ = countLeadingZeros(vec2i_);
  _ = countLeadingZeros(vec3i_);
  _ = countLeadingZeros(vec4i_);
  _ = countLeadingZeros(vec2u_);
  _ = countLeadingZeros(vec3u_);
  _ = countLeadingZeros(vec4u_);
  _ = countOneBits(i32_);
  _ = countOneBits(u32_);
  _ = countOneBits(vec2i_);
  _ = countOneBits(vec3i_);
  _ = countOneBits(vec4i_);
  _ = countOneBits(vec2u_);
  _ = countOneBits(vec3u_);
  _ = countOneBits(vec4u_);
  _ = countTrailingZeros(i32_);
  _ = countTrailingZeros(u32_);
  _ = countTrailingZeros(vec2i_);
  _ = countTrailingZeros(vec3i_);
  _ = countTrailingZeros(vec4i_);
  _ = countTrailingZeros(vec2u_);
  _ = countTrailingZeros(vec3u_);
  _ = countTrailingZeros(vec4u_);
  _ = cross(vec3f_, vec3f_);
  _ = cross(vec3h_, vec3h_);
  _ = degrees(f32_);
  _ = degrees(f16_);
  _ = degrees(vec2f_);
  _ = degrees(vec3f_);
  _ = degrees(vec4f_);
  _ = degrees(vec2h_);
  _ = degrees(vec3h_);
  _ = degrees(vec4h_);
  _ = determinant(mat2x2f_);
  _ = determinant(mat3x3f_);
  _ = determinant(mat4x4f_);
  _ = determinant(mat2x2h_);
  _ = determinant(mat3x3h_);
  _ = determinant(mat4x4h_);
  _ = distance(f32_, f32_);
  _ = distance(f16_, f16_);
  _ = distance(vec2f_, vec2f_);
  _ = distance(vec3f_, vec3f_);
  _ = distance(vec4f_, vec4f_);
  _ = distance(vec2h_, vec2h_);
  _ = distance(vec3h_, vec3h_);
  _ = distance(vec4h_, vec4h_);
  _ = dot(vec2i_, vec2i_);
  _ = dot(vec3i_, vec3i_);
  _ = dot(vec4i_, vec4i_);
  _ = dot(vec2u_, vec2u_);
  _ = dot(vec3u_, vec3u_);
  _ = dot(vec4u_, vec4u_);
  _ = dot(vec2f_, vec2f_);
  _ = dot(vec3f_, vec3f_);
  _ = dot(vec4f_, vec4f_);
  _ = dot(vec2h_, vec2h_);
  _ = dot(vec3h_, vec3h_);
  _ = dot(vec4h_, vec4h_);
  _ = dot4U8Packed(u32_, u32_);
  _ = dot4I8Packed(u32_, u32_);
  _ = exp(f32_);
  _ = exp(f16_);
  _ = exp(vec2f_);
  _ = exp(vec3f_);
  _ = exp(vec4f_);
  _ = exp(vec2h_);
  _ = exp(vec3h_);
  _ = exp(vec4h_);
  _ = exp2(f32_);
  _ = exp2(f16_);
  _ = exp2(vec2f_);
  _ = exp2(vec3f_);
  _ = exp2(vec4f_);
  _ = exp2(vec2h_);
  _ = exp2(vec3h_);
  _ = exp2(vec4h_);
  _ = extractBits(i32_, u32_, u32_);
  _ = extractBits(vec2i_, u32_, u32_);
  _ = extractBits(vec3i_, u32_, u32_);
  _ = extractBits(vec4i_, u32_, u32_);
  _ = extractBits(u32_, u32_, u32_);
  _ = extractBits(vec2u_, u32_, u32_);
  _ = extractBits(vec3u_, u32_, u32_);
  _ = extractBits(vec4u_, u32_, u32_);
  _ = faceForward(vec2f_, vec2f_, vec2f_);
  _ = faceForward(vec3f_, vec3f_, vec3f_);
  _ = faceForward(vec4f_, vec4f_, vec4f_);
  _ = faceForward(vec2h_, vec2h_, vec2h_);
  _ = faceForward(vec3h_, vec3h_, vec3h_);
  _ = faceForward(vec4h_, vec4h_, vec4h_);
  _ = firstLeadingBit(i32_);
  _ = firstLeadingBit(vec2i_);
  _ = firstLeadingBit(vec3i_);
  _ = firstLeadingBit(vec4i_);
  _ = firstLeadingBit(u32_);
  _ = firstLeadingBit(vec2u_);
  _ = firstLeadingBit(vec3u_);
  _ = firstLeadingBit(vec4u_);
  _ = firstTrailingBit(i32_);
  _ = firstTrailingBit(u32_);
  _ = firstTrailingBit(vec2i_);
  _ = firstTrailingBit(vec3i_);
  _ = firstTrailingBit(vec4i_);
  _ = firstTrailingBit(vec2u_);
  _ = firstTrailingBit(vec3u_);
  _ = firstTrailingBit(vec4u_);
  _ = floor(f32_);
  _ = floor(f16_);
  _ = floor(vec2f_);
  _ = floor(vec3f_);
  _ = floor(vec4f_);
  _ = floor(vec2h_);
  _ = floor(vec3h_);
  _ = floor(vec4h_);
  _ = fma(f32_, f32_, f32_);
  _ = fma(f16_, f16_, f16_);
  _ = fma(vec2f_, vec2f_, vec2f_);
  _ = fma(vec3f_, vec3f_, vec3f_);
  _ = fma(vec4f_, vec4f_, vec4f_);
  _ = fma(vec2h_, vec2h_, vec2h_);
  _ = fma(vec3h_, vec3h_, vec3h_);
  _ = fma(vec4h_, vec4h_, vec4h_);
  _ = fract(f32_);
  _ = fract(f16_);
  _ = fract(vec2f_);
  _ = fract(vec3f_);
  _ = fract(vec4f_);
  _ = fract(vec2h_);
  _ = fract(vec3h_);
  _ = fract(vec4h_);
  _ = frexp(f32_);
  _ = frexp(f16_);
  _ = frexp(0);
  _ = frexp(vec2f_);
  _ = frexp(vec2h_);
  _ = frexp(vec2());
  _ = frexp(vec3f_);
  _ = frexp(vec3h_);
  _ = frexp(vec3());
  _ = frexp(vec4f_);
  _ = frexp(vec4h_);
  _ = frexp(vec4());
  _ = insertBits(i32_, i32_, u32_, u32_);
  _ = insertBits(u32_, u32_, u32_, u32_);
  _ = insertBits(vec2i_, vec2i_, u32_, u32_);
  _ = insertBits(vec3i_, vec3i_, u32_, u32_);
  _ = insertBits(vec4i_, vec4i_, u32_, u32_);
  _ = insertBits(vec2u_, vec2u_, u32_, u32_);
  _ = insertBits(vec3u_, vec3u_, u32_, u32_);
  _ = insertBits(vec4u_, vec4u_, u32_, u32_);
  _ = inverseSqrt(f32_);
  _ = inverseSqrt(f16_);
  _ = inverseSqrt(vec2f_);
  _ = inverseSqrt(vec3f_);
  _ = inverseSqrt(vec4f_);
  _ = inverseSqrt(vec2h_);
  _ = inverseSqrt(vec3h_);
  _ = inverseSqrt(vec4h_);
  _ = ldexp(f32_, i32_);
  _ = ldexp(f16_, i32_);
  _ = ldexp(0, 0);
  _ = ldexp(vec2f_, vec2i_);
  _ = ldexp(vec3f_, vec3i_);
  _ = ldexp(vec4f_, vec4i_);
  _ = ldexp(vec2h_, vec2i_);
  _ = ldexp(vec3h_, vec3i_);
  _ = ldexp(vec4h_, vec4i_);
  _ = length(f32_);
  _ = length(f16_);
  _ = length(vec2f_);
  _ = length(vec3f_);
  _ = length(vec4f_);
  _ = length(vec2h_);
  _ = length(vec3h_);
  _ = length(vec4h_);
  _ = log(f32_);
  _ = log(f16_);
  _ = log(vec2f_);
  _ = log(vec3f_);
  _ = log(vec4f_);
  _ = log(vec2h_);
  _ = log(vec3h_);
  _ = log(vec4h_);
  _ = log2(f32_);
  _ = log2(f16_);
  _ = log2(vec2f_);
  _ = log2(vec3f_);
  _ = log2(vec4f_);
  _ = log2(vec2h_);
  _ = log2(vec3h_);
  _ = log2(vec4h_);
  _ = max(i32_, i32_);
  _ = max(u32_, u32_);
  _ = max(f32_, f32_);
  _ = max(f16_, f16_);
  _ = max(vec2i_, vec2i_);
  _ = max(vec3i_, vec3i_);
  _ = max(vec4i_, vec4i_);
  _ = max(vec2u_, vec2u_);
  _ = max(vec3u_, vec3u_);
  _ = max(vec4u_, vec4u_);
  _ = max(vec2f_, vec2f_);
  _ = max(vec3f_, vec3f_);
  _ = max(vec4f_, vec4f_);
  _ = max(vec2h_, vec2h_);
  _ = max(vec3h_, vec3h_);
  _ = max(vec4h_, vec4h_);
  _ = min(i32_, i32_);
  _ = min(u32_, u32_);
  _ = min(f32_, f32_);
  _ = min(f16_, f16_);
  _ = min(vec2i_, vec2i_);
  _ = min(vec3i_, vec3i_);
  _ = min(vec4i_, vec4i_);
  _ = min(vec2u_, vec2u_);
  _ = min(vec3u_, vec3u_);
  _ = min(vec4u_, vec4u_);
  _ = min(vec2f_, vec2f_);
  _ = min(vec3f_, vec3f_);
  _ = min(vec4f_, vec4f_);
  _ = min(vec2h_, vec2h_);
  _ = min(vec3h_, vec3h_);
  _ = min(vec4h_, vec4h_);
  _ = mix(f32_, f32_, f32_);
  _ = mix(f16_, f16_, f16_);
  _ = mix(vec2f_, vec2f_, vec2f_);
  _ = mix(vec3f_, vec3f_, vec3f_);
  _ = mix(vec4f_, vec4f_, vec4f_);
  _ = mix(vec2h_, vec2h_, vec2h_);
  _ = mix(vec3h_, vec3h_, vec3h_);
  _ = mix(vec4h_, vec4h_, vec4h_);
  _ = mix(vec2f_, vec2f_, f32_);
  _ = mix(vec3f_, vec3f_, f32_);
  _ = mix(vec4f_, vec4f_, f32_);
  _ = mix(vec2h_, vec2h_, f16_);
  _ = mix(vec3h_, vec3h_, f16_);
  _ = mix(vec4h_, vec4h_, f16_);
  _ = modf(f32_);
  _ = modf(f16_);
  _ = modf(0);
  _ = modf(vec2f_);
  _ = modf(vec2h_);
  _ = modf(vec2());
  _ = modf(vec3f_);
  _ = modf(vec3h_);
  _ = modf(vec3());
  _ = modf(vec4f_);
  _ = modf(vec4h_);
  _ = modf(vec4());
  _ = normalize(vec2f_);
  _ = normalize(vec3f_);
  _ = normalize(vec4f_);
  _ = normalize(vec2h_);
  _ = normalize(vec3h_);
  _ = normalize(vec4h_);
  _ = pow(f32_, f32_);
  _ = pow(f16_, f16_);
  _ = pow(vec2f_, vec2f_);
  _ = pow(vec3f_, vec3f_);
  _ = pow(vec4f_, vec4f_);
  _ = pow(vec2h_, vec2h_);
  _ = pow(vec3h_, vec3h_);
  _ = pow(vec4h_, vec4h_);
  _ = quantizeToF16(f32_);
  _ = quantizeToF16(vec2f_);
  _ = quantizeToF16(vec3f_);
  _ = quantizeToF16(vec4f_);
  _ = radians(f32_);
  _ = radians(f16_);
  _ = radians(vec2f_);
  _ = radians(vec3f_);
  _ = radians(vec4f_);
  _ = radians(vec2h_);
  _ = radians(vec3h_);
  _ = radians(vec4h_);
  _ = reflect(vec2f_, vec2f_);
  _ = reflect(vec3f_, vec3f_);
  _ = reflect(vec4f_, vec4f_);
  _ = reflect(vec2h_, vec2h_);
  _ = reflect(vec3h_, vec3h_);
  _ = reflect(vec4h_, vec4h_);
  _ = refract(vec2f_, vec2f_, f32_);
  _ = refract(vec3f_, vec3f_, f32_);
  _ = refract(vec4f_, vec4f_, f32_);
  _ = refract(vec2h_, vec2h_, f16_);
  _ = refract(vec3h_, vec3h_, f16_);
  _ = refract(vec4h_, vec4h_, f16_);
  _ = reverseBits(i32_);
  _ = reverseBits(u32_);
  _ = reverseBits(vec2i_);
  _ = reverseBits(vec3i_);
  _ = reverseBits(vec4i_);
  _ = reverseBits(vec2u_);
  _ = reverseBits(vec3u_);
  _ = reverseBits(vec4u_);
  _ = round(f32_);
  _ = round(f16_);
  _ = round(vec2f_);
  _ = round(vec3f_);
  _ = round(vec4f_);
  _ = round(vec2h_);
  _ = round(vec3h_);
  _ = round(vec4h_);
  _ = saturate(f32_);
  _ = saturate(f16_);
  _ = saturate(vec2f_);
  _ = saturate(vec3f_);
  _ = saturate(vec4f_);
  _ = saturate(vec2h_);
  _ = saturate(vec3h_);
  _ = saturate(vec4h_);
  _ = sign(f32_);
  _ = sign(i32_);
  _ = sign(f16_);
  _ = sign(vec2f_);
  _ = sign(vec3f_);
  _ = sign(vec4f_);
  _ = sign(vec2i_);
  _ = sign(vec3i_);
  _ = sign(vec4i_);
  _ = sign(vec2h_);
  _ = sign(vec3h_);
  _ = sign(vec4h_);
  _ = smoothstep(1,2,3);
  _ = smoothstep(1h,2h,3h);
  _ = smoothstep(vec2f(1), vec2f(2), vec2f(3));
  _ = smoothstep(vec3f(1), vec3f(2), vec3f(3));
  _ = smoothstep(vec4f(1), vec4f(2), vec4f(3));
  _ = smoothstep(vec2h(1), vec2h(2), vec2h(3));
  _ = smoothstep(vec3h(1), vec3h(2), vec3h(3));
  _ = smoothstep(vec4h(1), vec4h(2), vec4h(3));
  _ = sqrt(f32_);
  _ = sqrt(f16_);
  _ = sqrt(vec2f_);
  _ = sqrt(vec3f_);
  _ = sqrt(vec4f_);
  _ = sqrt(vec2h_);
  _ = sqrt(vec3h_);
  _ = sqrt(vec4h_);
  _ = step(f32_, f32_);
  _ = step(f16_, f16_);
  _ = step(vec2f_, vec2f_);
  _ = step(vec3f_, vec3f_);
  _ = step(vec4f_, vec4f_);
  _ = step(vec2h_, vec2h_);
  _ = step(vec3h_, vec3h_);
  _ = step(vec4h_, vec4h_);
  _ = transpose(mat2x2f_);
  _ = transpose(mat2x3f_);
  _ = transpose(mat2x4f_);
  _ = transpose(mat3x2f_);
  _ = transpose(mat3x3f_);
  _ = transpose(mat3x4f_);
  _ = transpose(mat4x2f_);
  _ = transpose(mat4x3f_);
  _ = transpose(mat4x4f_);
  _ = transpose(mat2x2h_);
  _ = transpose(mat2x3h_);
  _ = transpose(mat2x4h_);
  _ = transpose(mat3x2h_);
  _ = transpose(mat3x3h_);
  _ = transpose(mat3x4h_);
  _ = transpose(mat4x2h_);
  _ = transpose(mat4x3h_);
  _ = transpose(mat4x4h_);
  _ = trunc(f32_);
  _ = trunc(f16_);
  _ = trunc(vec2f_);
  _ = trunc(vec3f_);
  _ = trunc(vec4f_);
  _ = trunc(vec2h_);
  _ = trunc(vec3h_);
  _ = trunc(vec4h_);
  _ = pack4x8snorm(vec4f_);
  _ = pack4x8unorm(vec4f_);
  _ = pack4xI8(vec4i_);
  _ = pack4xU8(vec4u_);
  _ = pack4xI8Clamp(vec4i_);
  _ = pack4xU8Clamp(vec4u_);
  _ = pack2x16snorm(vec2f_);
  _ = pack2x16unorm(vec2f_);
  _ = pack2x16float(vec2f_);
  _ = unpack4x8snorm(u32_);
  _ = unpack4x8unorm(u32_);
  _ = unpack4xI8(u32_);
  _ = unpack4xU8(u32_);
  _ = unpack2x16snorm(u32_);
  _ = unpack2x16unorm(u32_);
  _ = unpack2x16float(u32_);
}

@compute @workgroup_size(6, 1, 1)
fn compute1(@builtin(local_invocation_id) a0: vec3u, @builtin(workgroup_id) a1: vec3u) {
  coverageHelper0();
  _ = buffer90.f0;
}`,
  hints: {},
});
try {
computePassEncoder15.setBindGroup(3, bindGroup7);
} catch {}
try {
computePassEncoder51.setBindGroup(2, bindGroup5, new Uint32Array(887), 24, 0);
} catch {}
try {
renderPassEncoder12.setViewport(3.7551788769578156, 14.375392065641488, 0.40537586174524765, 1.040747924325001, 0.7979007588518131, 0.8920776511807693);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer66);
} catch {}
await gc();
let bindGroup64 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 164, resource: textureView63},
    {binding: 261, resource: {buffer: buffer7, offset: 2048}},
    {binding: 141, resource: sampler0},
    {binding: 119, resource: {buffer: buffer37, offset: 0}},
    {binding: 78, resource: textureView72},
    {binding: 667, resource: textureView103},
    {binding: 311, resource: {buffer: buffer22, offset: 0, size: 117}},
    {binding: 54, resource: externalTexture6},
    {binding: 116, resource: sampler49},
    {binding: 270, resource: textureView108},
    {binding: 221, resource: textureView42},
    {binding: 414, resource: textureView8},
    {binding: 79, resource: textureView113},
    {binding: 26, resource: textureView121},
    {binding: 47, resource: externalTexture12},
    {binding: 337, resource: textureView10},
  ],
});
let commandEncoder102 = device0.createCommandEncoder({});
try {
computePassEncoder15.setBindGroup(2, bindGroup12, new Uint32Array(2107), 321, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer8, 'uint32', 648, 2_650);
} catch {}
try {
renderBundleEncoder8.setBindGroup(3, bindGroup44);
} catch {}
try {
renderBundleEncoder8.setBindGroup(3, bindGroup7, new Uint32Array(457), 45, 0);
} catch {}
try {
buffer73.unmap();
} catch {}
let bindGroup65 = device0.createBindGroup({
  label: '\uddc1\u873f\uec3d\ufa16\u0b65\ua9f9\u4fe1',
  layout: bindGroupLayout0,
  entries: [{binding: 65, resource: textureView7}],
});
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView130 = texture71.createView({mipLevelCount: 1});
try {
computePassEncoder79.setBindGroup(3, bindGroup42);
} catch {}
try {
computePassEncoder43.setBindGroup(3, bindGroup35, new Uint32Array(2649), 1_969, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup26, new Uint32Array(1053), 7, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(3, buffer26, 700, 1_459);
} catch {}
try {
renderBundleEncoder8.setBindGroup(3, bindGroup12, new Uint32Array(1025), 84, 0);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(5, buffer86, 0, 3_272);
} catch {}
try {
commandEncoder102.copyBufferToBuffer(buffer65, 760, buffer35, 432, 132);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer21, 944, new DataView(new ArrayBuffer(1566)), 5, 380);
} catch {}
document.body.prepend(canvas1);
try {
adapter1.label = '\u0462\ua5c4\uc28e\u79c2\ue61f\u52ee\u082f\u0290\u172c\u{1fc53}';
} catch {}
let buffer91 = device0.createBuffer({
  label: '\u0e77\u{1f773}\u0958\u1e5b\u{1fed3}\u{1fc5b}',
  size: 448,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder103 = device0.createCommandEncoder({});
let texture117 = device0.createTexture({
  label: '\u61c0\u{1fe7d}\u5421\u{1fe0a}\u03ca\uef75',
  size: {width: 420, height: 1, depthOrArrayLayers: 8},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView131 = texture102.createView({baseArrayLayer: 0});
let computePassEncoder84 = commandEncoder103.beginComputePass();
try {
computePassEncoder46.setBindGroup(0, bindGroup15, new Uint32Array(1465), 257, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer8, 1_224); };
} catch {}
try {
computePassEncoder84.setPipeline(pipeline1);
} catch {}
try {
commandEncoder102.copyBufferToTexture({
  /* bytesInLastRow: 96 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1992 */
  offset: 1992,
  buffer: buffer39,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder102.copyTextureToTexture({
  texture: texture108,
  mipLevel: 0,
  origin: {x: 65, y: 0, z: 10},
  aspect: 'all',
},
{
  texture: texture97,
  mipLevel: 0,
  origin: {x: 4, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder85 = commandEncoder102.beginComputePass({});
try {
renderPassEncoder14.setViewport(206.4339613823317, 0.959776690793641, 1.121773909417837, 0.03015323516004581, 0.006776988562172459, 0.49308896496207016);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(3, buffer59, 2_520);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup44);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(3, buffer86, 0, 1_188);
} catch {}
try {
device0.queue.writeBuffer(buffer63, 80, new Float32Array(9240), 870, 12);
} catch {}
let commandEncoder104 = device0.createCommandEncoder({});
let texture118 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture119 = device0.createTexture({
  label: '\u046f\u0ff1\u0469\u4f4b\u379a\u674d',
  size: [9],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder17 = commandEncoder104.beginRenderPass({
  label: '\u4bc5\u{1fcbf}\ud49e\u7e6e\u63d9\u{1f879}\u1176\u7676\u0da6\u441a',
  colorAttachments: [{
  view: textureView97,
  clearValue: { r: -847.2, g: -735.5, b: 211.3, a: -251.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder59.setBindGroup(2, bindGroup49);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup44, []);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup4);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(4, buffer79);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.writeBuffer(buffer14, 492, new Float32Array(9847), 2765, 184);
} catch {}
let videoFrame19 = new VideoFrame(videoFrame13, {timestamp: 0});
let buffer92 = device0.createBuffer({
  size: 1364,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder105 = device0.createCommandEncoder({label: '\u64c2\u0015\u07cf\u0266\uc607\u{1fc2f}\ufd57\u8646\u1467\u2d98'});
let texture120 = device0.createTexture({
  size: {width: 288},
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture121 = gpuCanvasContext5.getCurrentTexture();
try {
computePassEncoder68.setBindGroup(1, bindGroup18, new Uint32Array(97), 7, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder85.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder17.setStencilReference(697);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(1, buffer74, 376, 372);
} catch {}
try {
buffer16.unmap();
} catch {}
try {
commandEncoder105.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 544 */
  offset: 544,
  bytesPerRow: 512,
  buffer: buffer2,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 0, y: 10, z: 0},
  aspect: 'all',
}, {width: 2, height: 16, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder105.copyTextureToTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 22, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture69,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(1).fill(214), /* required buffer size: 1 */
{offset: 1}, {width: 208, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder106 = device0.createCommandEncoder({});
let textureView132 = texture116.createView({});
let textureView133 = texture9.createView({});
try {
computePassEncoder32.setBindGroup(2, bindGroup65);
} catch {}
try {
computePassEncoder15.setBindGroup(0, bindGroup19, new Uint32Array(1073), 43, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup18, new Uint32Array(3390), 3_364, 0);
} catch {}
let commandEncoder107 = device0.createCommandEncoder({});
let textureView134 = texture91.createView({aspect: 'all', baseArrayLayer: 0});
let sampler68 = device0.createSampler({
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 24.12,
  lodMaxClamp: 85.42,
  maxAnisotropy: 5,
});
try {
computePassEncoder9.setBindGroup(1, bindGroup20, new Uint32Array(1752), 25, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle7, renderBundle5]);
} catch {}
let bindGroup66 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView8}]});
let texture122 = device0.createTexture({size: [144, 48, 1], sampleCount: 1, format: 'rg16sint', usage: GPUTextureUsage.COPY_DST});
let renderBundle8 = renderBundleEncoder8.finish({});
try {
computePassEncoder47.setBindGroup(0, bindGroup27);
} catch {}
document.body.prepend(img1);
let commandEncoder108 = device0.createCommandEncoder({});
let texture123 = device0.createTexture({
  size: [210, 1, 1],
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder86 = commandEncoder105.beginComputePass({});
try {
renderPassEncoder4.setBindGroup(1, bindGroup57, []);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup62, new Uint32Array(94), 9, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer26, 44, new BigUint64Array(30263), 10150, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture87,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(2_675).fill(161), /* required buffer size: 2_675 */
{offset: 25, bytesPerRow: 26, rowsPerImage: 25}, {width: 6, height: 2, depthOrArrayLayers: 5});
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); };
} catch {}
let promise16 = adapter0.requestAdapterInfo();
let buffer93 = device0.createBuffer({
  size: 22615,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder109 = device0.createCommandEncoder({label: '\u102a\u1308\u095f\u9809\u0b9e'});
let querySet21 = device0.createQuerySet({
  label: '\uf6e1\u03dd\u7d73\u228a\u0055\u7a92\ufca8\u{1fcc3}\u048d\u0089',
  type: 'occlusion',
  count: 455,
});
let textureView135 = texture54.createView({aspect: 'all'});
let sampler69 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  lodMinClamp: 22.66,
  lodMaxClamp: 60.39,
  compare: 'less-equal',
});
try {
computePassEncoder86.setPipeline(pipeline0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 96, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 2, y: 69 },
  flipY: true,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 25, depthOrArrayLayers: 0});
} catch {}
let buffer94 = device0.createBuffer({
  size: 2572,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder110 = device0.createCommandEncoder({});
let texture124 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder68.setBindGroup(3, bindGroup46);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder17.setStencilReference(348);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer1, 'uint16', 2_744, 234);
} catch {}
try {
buffer33.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 34}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 147, y: 0, z: 16},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder87 = commandEncoder107.beginComputePass({});
try {
computePassEncoder36.setBindGroup(0, bindGroup66);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup55, new Uint32Array(3117), 132, 0);
} catch {}
document.body.prepend(canvas0);
let buffer95 = device0.createBuffer({size: 4714, usage: GPUBufferUsage.MAP_WRITE});
let computePassEncoder88 = commandEncoder108.beginComputePass({});
let renderPassEncoder18 = commandEncoder110.beginRenderPass({
  label: '\u9d40\u{1fa08}',
  colorAttachments: [{
  view: textureView24,
  clearValue: { r: -949.0, g: 622.3, b: 558.1, a: -211.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder46.setBindGroup(3, bindGroup23);
} catch {}
try {
computePassEncoder25.setBindGroup(1, bindGroup7, new Uint32Array(418), 1, 0);
} catch {}
try {
computePassEncoder88.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup53);
} catch {}
try {
adapter1.label = '\u5c25\u00df\u08e7\u8c56\uc78b\u007c\ubb3e\u{1f89e}';
} catch {}
let commandEncoder111 = device0.createCommandEncoder({});
let commandBuffer7 = commandEncoder106.finish({});
let computePassEncoder89 = commandEncoder109.beginComputePass({});
let sampler70 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 39.96,
  lodMaxClamp: 98.26,
});
try {
computePassEncoder41.end();
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle6, renderBundle0, renderBundle7, renderBundle0, renderBundle7, renderBundle7, renderBundle7, renderBundle5]);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer79, 'uint32', 1_528, 1_311);
} catch {}
try {
computePassEncoder72.insertDebugMarker('\u16bd');
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let pipelineLayout11 = device0.createPipelineLayout({label: '\udfa7\u4203\u3da4\u5b53\u0834\ucb32\uc5fa\u{1fdab}\u81e0\u0dd3\u1bfa', bindGroupLayouts: []});
let buffer96 = device0.createBuffer({
  label: '\u824d\u{1ffd5}\u0428\u{1f709}\u0f1b\u0706\u0b5e\u{1f8b3}',
  size: 8245,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder112 = device0.createCommandEncoder();
let textureView136 = texture94.createView({dimension: '2d-array'});
let texture125 = device0.createTexture({size: {width: 19}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.COPY_DST});
let sampler71 = device0.createSampler({
  label: '\ua510\u{1fc98}\ua7d7\ue87e\u0fc0\u{1fef5}\u0f49\u{1fc29}\u{1f610}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 19.38,
  lodMaxClamp: 86.19,
  maxAnisotropy: 7,
});
try {
renderPassEncoder18.setBindGroup(3, bindGroup60, []);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup60, new Uint32Array(47), 3, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: videoFrame17,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroupLayout14 = device0.createBindGroupLayout({
  label: '\u{1ff6c}\u{1fdc4}\u10ca\u0cf4',
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 69,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 23,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 505,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let buffer97 = device0.createBuffer({
  label: '\u2c42\u028e\ua90d\u0dfb',
  size: 60952,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let sampler72 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 49.08,
  lodMaxClamp: 71.94,
  maxAnisotropy: 15,
});
try {
buffer14.unmap();
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5052 */
  offset: 5052,
  bytesPerRow: 256,
  buffer: buffer52,
}, {
  texture: texture94,
  mipLevel: 0,
  origin: {x: 39, y: 40, z: 0},
  aspect: 'all',
}, {width: 1, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer9, 260, new Float32Array(29616), 3897, 4);
} catch {}
let imageData12 = new ImageData(20, 32);
let bindGroup67 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 311, resource: {buffer: buffer93, offset: 4608, size: 1011}},
    {binding: 164, resource: textureView33},
    {binding: 78, resource: textureView57},
    {binding: 54, resource: externalTexture13},
    {binding: 337, resource: textureView84},
    {binding: 119, resource: {buffer: buffer59, offset: 2560, size: 168}},
    {binding: 261, resource: {buffer: buffer31, offset: 256, size: 414}},
    {binding: 116, resource: sampler50},
    {binding: 79, resource: textureView113},
    {binding: 270, resource: textureView108},
    {binding: 47, resource: externalTexture0},
    {binding: 141, resource: sampler10},
    {binding: 414, resource: textureView7},
    {binding: 26, resource: textureView121},
    {binding: 667, resource: textureView136},
    {binding: 221, resource: textureView28},
  ],
});
let texture126 = device0.createTexture({
  size: [78, 132, 3],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView137 = texture117.createView({});
try {
computePassEncoder1.setBindGroup(0, bindGroup53, new Uint32Array(60), 3, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer40, 'uint32', 4_368, 982);
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 4464 widthInBlocks: 279 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 3040 */
  offset: 3040,
  buffer: buffer78,
}, {
  texture: texture69,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 279, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder111.clearBuffer(buffer72, 912, 192);
} catch {}
let buffer98 = device0.createBuffer({size: 5371, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let computePassEncoder90 = commandEncoder111.beginComputePass();
try {
renderPassEncoder4.executeBundles([renderBundle3, renderBundle6]);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer29, 'uint32', 4_612, 16_054);
} catch {}
let bindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 133,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 80,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true },
    },
  ],
});
let texture127 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder91 = commandEncoder52.beginComputePass({label: '\u381b\u3a65\uab93\u{1fb13}\u{1ff7c}\u0d24\u7ee6'});
let renderPassEncoder19 = commandEncoder112.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -553.8, g: 704.7, b: 665.2, a: 764.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder18.setVertexBuffer(0, buffer26, 3_032);
} catch {}
let commandEncoder113 = device0.createCommandEncoder({});
let texture128 = device0.createTexture({
  size: [144, 48, 1],
  sampleCount: 4,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView138 = texture21.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder92 = commandEncoder113.beginComputePass();
try {
computePassEncoder87.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup6, new Uint32Array(2232), 143, 0);
} catch {}
let bindGroup68 = device0.createBindGroup({
  label: '\u06af\u0d21\ue658\u{1f83e}\u0e11\u99ab\u15cd\u{1fe81}',
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer87, offset: 0, size: 12}}],
});
let texture129 = device0.createTexture({
  size: {width: 78, height: 132, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView139 = texture80.createView({});
try {
computePassEncoder79.end();
} catch {}
try {
commandEncoder95.copyTextureToBuffer({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 4, y: 13, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1863 */
  offset: 1863,
  buffer: buffer14,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture65,
  mipLevel: 0,
  origin: {x: 4, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(6_650).fill(153), /* required buffer size: 6_650 */
{offset: 14, bytesPerRow: 84, rowsPerImage: 23}, {width: 0, height: 11, depthOrArrayLayers: 4});
} catch {}
try {
externalTexture18.label = '\u76cf\u54cb\u7119';
} catch {}
let textureView140 = texture127.createView({});
let textureView141 = texture7.createView({dimension: '2d-array', aspect: 'stencil-only', mipLevelCount: 1});
let computePassEncoder93 = commandEncoder95.beginComputePass({});
try {
computePassEncoder62.setBindGroup(2, bindGroup44, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer8, 5_372); };
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup58);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup60, new Uint32Array(1515), 341, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(458);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer87, 'uint32', 8, 28);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer13);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
try {
  await adapter1.requestAdapterInfo();
} catch {}
try {
adapter0.label = '\u2276\u{1fc87}\uf9d7\u5554\u2f3d\u{1fa36}\u8d76\u0f53';
} catch {}
try {
computePassEncoder47.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder90.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle3, renderBundle6]);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer29);
} catch {}
let arrayBuffer11 = buffer69.getMappedRange(360, 172);
let commandEncoder114 = device0.createCommandEncoder({label: '\uad37\u698f\u{1fa3e}\u94a6\u{1fc41}\u0671\u08a7\u{1fda1}\u0d2b\u4a71'});
let textureView142 = texture97.createView({dimension: '2d-array', baseArrayLayer: 0});
let computePassEncoder94 = commandEncoder114.beginComputePass();
let sampler73 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 53.67,
  lodMaxClamp: 58.53,
  maxAnisotropy: 1,
});
try {
computePassEncoder34.setBindGroup(3, bindGroup53);
} catch {}
try {
computePassEncoder89.setPipeline(pipeline0);
} catch {}
try {
buffer97.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer16, 788, new BigUint64Array(3525), 847, 16);
} catch {}
let imageData13 = new ImageData(56, 4);
let shaderModule6 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 143 max align: 1 */
struct T0 {
  @align(1) @size(6) f0: array<f32, 1>,
  @align(1) f1: atomic<i32>,
  @align(1) @size(6) f2: atomic<u32>,
  @align(1) @size(16) f3: u32,
  @align(1) f4: array<array<vec2f, 1>, 1>,
  @align(1) @size(33) f5: mat2x3f,
  @align(1) @size(5) f6: array<atomic<i32>, 1>,
  @align(1) @size(16) f7: atomic<i32>,
  @align(1) @size(49) f8: array<atomic<u32>>,
}
@id(33655) override override29 : u32 = 419;
@group(1) @binding(18) var tex3: texture_depth_2d;
@group(0) @binding(228) var<storage, read_write> buffer99: T0;
@group(0) @binding(172) var sam3: sampler;
struct VertexOutput4 {
  @builtin(position) @invariant f13: vec4f,
  @location(10) @interpolate(linear, centroid) f14: vec2h
}

@vertex
fn vertex0(@location(5) a0: vec4u) -> VertexOutput4 {
  var out: VertexOutput4;
  return out;
}
struct FragmentOutput1 {
  @location(2) @interpolate(flat) f0: vec4i,
  @location(1) f1: vec4f,
  @location(0) @interpolate(flat, centroid) f2: vec4i
}

@fragment
fn fragment0() -> FragmentOutput1 {
  var out: FragmentOutput1;
  _ = buffer99.f4;
  _ = buffer99.f8[arrayLength(&buffer99.f8)];
  _ = buffer99.f3;
  _ = buffer99.f7;
  _ = buffer99.f8[arrayLength(&buffer99.f8) - 1];
  _ = buffer99.f5;
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder115 = device0.createCommandEncoder({});
try {
computePassEncoder80.setBindGroup(2, bindGroup20, new Uint32Array(2460), 211, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup26);
} catch {}
try {
renderPassEncoder4.setViewport(279.41211666962533, 32.655310804405204, 2.842653389261981, 28.201935762173413, 0.17826146896558615, 0.8745233305475717);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(3, buffer10);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(592).fill(54), /* required buffer size: 592 */
{offset: 592}, {width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline3 = await device0.createComputePipelineAsync({layout: pipelineLayout4, compute: {module: shaderModule4}});
let bindGroup69 = device0.createBindGroup({layout: bindGroupLayout11, entries: [{binding: 212, resource: textureView121}]});
let buffer100 = device0.createBuffer({
  size: 4260,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let texture130 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST,
});
let texture131 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder4.setBindGroup(3, bindGroup67);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
commandEncoder115.copyBufferToBuffer(buffer2, 2936, buffer37, 96, 336);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 14, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder116 = device0.createCommandEncoder({});
let texture132 = device0.createTexture({
  label: '\u0231\u5e3d\u00e1\u6aeb\ua83c\u{1f7ea}',
  size: [105],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView143 = texture75.createView({mipLevelCount: 1});
let renderPassEncoder20 = commandEncoder115.beginRenderPass({
  colorAttachments: [{
  view: textureView85,
  clearValue: { r: -389.2, g: -746.2, b: -179.3, a: -317.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let sampler74 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 90.92,
  lodMaxClamp: 94.46,
  compare: 'greater-equal',
});
try {
computePassEncoder42.setBindGroup(3, bindGroup58, new Uint32Array(31), 0, 0);
} catch {}
try {
renderPassEncoder20.setViewport(32.164849831191276, 10.042560315118315, 0.6031485274121747, 0.42168223012274203, 0.23809670755700207, 0.29806863932767047);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer1, 'uint32', 2_476, 2_930);
} catch {}
try {
  await promise16;
} catch {}
let bindGroup70 = device0.createBindGroup({
  label: '\u0886\u0171\u{1fb88}\u{1f93c}\u{1fd9c}\u{1f88b}\u{1f65c}',
  layout: bindGroupLayout13,
  entries: [{binding: 123, resource: textureView128}, {binding: 97, resource: textureView84}],
});
let buffer101 = device0.createBuffer({size: 18229, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder117 = device0.createCommandEncoder({});
let textureView144 = texture80.createView({});
let computePassEncoder95 = commandEncoder117.beginComputePass({label: '\ue1bb\u0bdb\u36ee\u90ec\ud53a'});
try {
computePassEncoder95.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer43, 'uint32', 7_024, 180);
} catch {}
let imageData14 = new ImageData(4, 116);
let commandBuffer8 = commandEncoder116.finish({});
let textureView145 = texture66.createView({dimension: '2d', baseArrayLayer: 1});
try {
computePassEncoder51.setBindGroup(2, bindGroup55);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
});
} catch {}
let bindGroup71 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [{binding: 97, resource: textureView81}, {binding: 123, resource: textureView128}],
});
let buffer102 = device0.createBuffer({size: 5560, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder118 = device0.createCommandEncoder();
let texture133 = device0.createTexture({
  size: [36, 12, 68],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let texture134 = gpuCanvasContext3.getCurrentTexture();
let computePassEncoder96 = commandEncoder118.beginComputePass({});
let sampler75 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 8.624,
  lodMaxClamp: 64.74,
  maxAnisotropy: 5,
});
try {
renderPassEncoder15.setBindGroup(0, bindGroup30, new Uint32Array(556), 231, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle5]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas2,
  origin: { x: 3, y: 16 },
  flipY: true,
}, {
  texture: texture99,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
await gc();
let textureView146 = texture97.createView({label: '\udf09\u8007\u{1f7f3}\u877f\u033e\u95d2\u8a04\u{1f6f3}\u1407\u06f8\u0bcf', mipLevelCount: 1});
let externalTexture20 = device0.importExternalTexture({source: videoFrame14, colorSpace: 'display-p3'});
try {
computePassEncoder95.setBindGroup(2, bindGroup36);
} catch {}
try {
computePassEncoder63.setBindGroup(3, bindGroup14, new Uint32Array(12), 8, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(3); };
} catch {}
try {
computePassEncoder92.setPipeline(pipeline3);
} catch {}
try {
device0.queue.submit([commandBuffer8]);
} catch {}
document.body.append(img0);
let bindGroup72 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 286, resource: sampler39},
    {binding: 313, resource: {buffer: buffer18, offset: 1024, size: 48}},
    {binding: 528, resource: sampler6},
    {binding: 159, resource: {buffer: buffer78, offset: 10240, size: 4}},
    {binding: 56, resource: textureView33},
    {binding: 309, resource: textureView101},
    {binding: 57, resource: textureView65},
    {binding: 21, resource: textureView8},
    {binding: 151, resource: {buffer: buffer93, offset: 0, size: 5307}},
    {binding: 388, resource: {buffer: buffer96, offset: 3584, size: 28}},
    {binding: 238, resource: sampler58},
    {binding: 33, resource: {buffer: buffer100, offset: 512, size: 83}},
    {binding: 103, resource: textureView108},
  ],
});
let texture135 = gpuCanvasContext1.getCurrentTexture();
try {
computePassEncoder93.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup23, new Uint32Array(1042), 61, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture110,
  mipLevel: 0,
  origin: {x: 1, y: 2, z: 6},
  aspect: 'all',
}, new Uint8Array(10_400).fill(86), /* required buffer size: 10_400 */
{offset: 104, bytesPerRow: 44, rowsPerImage: 39}, {width: 0, height: 0, depthOrArrayLayers: 7});
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'film', transfer: 'smpteSt4281'} });
let bindGroup73 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 505, resource: {buffer: buffer93, offset: 0, size: 9567}},
    {binding: 23, resource: textureView9},
    {binding: 4, resource: textureView69},
    {binding: 69, resource: textureView49},
  ],
});
let texture136 = device0.createTexture({
  size: [288, 96, 15],
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView147 = texture80.createView({baseMipLevel: 0});
try {
computePassEncoder48.setBindGroup(2, bindGroup58);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup57, new Uint32Array(1861), 1_242, 0);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 34}
*/
{
  source: videoFrame15,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 64, y: 0, z: 11},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let querySet22 = device0.createQuerySet({label: '\uaf5c\u7e22\ud22f\u4d08', type: 'occlusion', count: 269});
try {
computePassEncoder91.setPipeline(pipeline3);
} catch {}
let promise17 = shaderModule4.getCompilationInfo();
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
externalTexture1.label = '\u6345\uffc7\u{1ff05}\u{1f8f8}\u{1fb8d}\u{1fb01}';
} catch {}
let textureView148 = texture63.createView({format: 'rgba16sint', mipLevelCount: 1, baseArrayLayer: 0});
let sampler76 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 45.27,
  lodMaxClamp: 81.34,
  maxAnisotropy: 9,
});
try {
renderPassEncoder14.setVertexBuffer(4, buffer60, 364);
} catch {}
let bindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 289,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let commandEncoder119 = device0.createCommandEncoder({});
let commandBuffer9 = commandEncoder119.finish({label: '\u0819\u{1fa7d}\ud381\u{1fe34}\uc829\u064b\u{1f7eb}\u0127'});
try {
renderPassEncoder16.setBindGroup(2, bindGroup70, new Uint32Array(3516), 3_059, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer12, 'uint16', 4_186, 7_652);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(5, buffer91, 80, 136);
} catch {}
try {
externalTexture14.label = '\u00a5\u9687\u9e7b\u{1faec}\u{1fde3}\u{1f6ce}\u809b\u0acb';
} catch {}
try {
computePassEncoder25.setBindGroup(2, bindGroup25);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder94.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup23);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup4, new Uint32Array(616), 71, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer60, 0, 202);
} catch {}
let commandEncoder120 = device0.createCommandEncoder({label: '\u0cf9\u0470\u0e1a\uec2f\u01a8\u07e6\ue209\u{1ff34}\ue8ae\u{1f9e8}'});
let textureView149 = texture128.createView({dimension: '2d', baseMipLevel: 0});
let textureView150 = texture21.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder97 = commandEncoder120.beginComputePass();
try {
computePassEncoder97.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer100, 'uint32', 424, 218);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, buffer85, 968);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let imageData15 = new ImageData(48, 60);
try {
computePassEncoder96.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup33);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup63, new Uint32Array(2337), 174, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(187);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer13, 'uint32', 356, 148);
} catch {}
try {
computePassEncoder88.pushDebugGroup('\u450a');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer83, 1780, new Int16Array(3167), 241, 296);
} catch {}
try {
adapter1.label = '\u377c\u7b08\u100d\u0306\u023c';
} catch {}
let textureView151 = texture18.createView({mipLevelCount: 1});
try {
computePassEncoder93.setBindGroup(3, bindGroup43, new Uint32Array(29), 2, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup29, new Uint32Array(165), 1, 0);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer85, 'uint16', 2_998, 5_521);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(2, buffer78);
} catch {}
let promise18 = device0.queue.onSubmittedWorkDone();
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
externalTexture5.label = '\ue1cf\ub905\u{1fc67}\ueab9\u0377\u{1fc8b}\ufac2\u0519\u0b7a';
} catch {}
let buffer103 = device0.createBuffer({
  size: 824,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder121 = device0.createCommandEncoder({label: '\u{1fb95}\u8786\u036d\uc31b\u{1fe37}\u0b5b\ufe79'});
let computePassEncoder98 = commandEncoder121.beginComputePass({});
try {
computePassEncoder24.setBindGroup(2, bindGroup30, new Uint32Array(2057), 38, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture137 = device0.createTexture({size: [420, 1, 41], format: 'rg16sint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder60.setBindGroup(3, bindGroup17, new Uint32Array(2316), 289, 0);
} catch {}
try {
computePassEncoder64.dispatchWorkgroupsIndirect(buffer28, 2_264);
} catch {}
try {
computePassEncoder98.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup29, new Uint32Array(3102), 275, 0);
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING, alphaMode: 'opaque'});
} catch {}
try {
device0.queue.submit([commandBuffer9]);
} catch {}
let texture138 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 11},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup74 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 265, resource: {buffer: buffer64, offset: 2560}}]});
let texture139 = device0.createTexture({size: [288, 96, 1], mipLevelCount: 2, format: 'rg16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView152 = texture77.createView({label: '\u022f\u19dc\u17d8\uf0e2\u{1f694}\u4f64\u{1f995}\u285b\ua6eb\u{1fc23}'});
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.setViewport(31.87553759446654, 0.7188776725905262, 24.30857021191967, 0.16663012631910648, 0.9091889789050659, 0.9971391051323876);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer28, 'uint32', 1_076, 1_226);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(3, buffer64, 3_264, 1_139);
} catch {}
let arrayBuffer12 = buffer47.getMappedRange(312, 168);
try {
computePassEncoder88.popDebugGroup();
} catch {}
let bindGroup75 = device0.createBindGroup({
  layout: bindGroupLayout15,
  entries: [{binding: 80, resource: textureView140}, {binding: 133, resource: textureView42}],
});
try {
computePassEncoder93.setBindGroup(1, bindGroup53);
} catch {}
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup72);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup58, new Uint32Array(840), 18, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer78, 'uint32', 3_936, 2_516);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let commandEncoder122 = device0.createCommandEncoder({});
let computePassEncoder99 = commandEncoder122.beginComputePass();
try {
computePassEncoder73.setBindGroup(2, bindGroup70);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle7, renderBundle6, renderBundle0, renderBundle6, renderBundle7, renderBundle6, renderBundle5]);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer59, 'uint16', 4_580, 2_073);
} catch {}
try {
window.someLabel = externalTexture16.label;
} catch {}
let buffer104 = device0.createBuffer({size: 8928, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX, mappedAtCreation: true});
let textureView153 = texture33.createView({dimension: '2d-array', baseMipLevel: 0});
try {
computePassEncoder15.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture91,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(173).fill(145), /* required buffer size: 173 */
{offset: 173}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt709', transfer: 'smpteSt4281'} });
let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout12]});
let texture140 = device0.createTexture({size: [210, 1, 1], mipLevelCount: 2, format: 'rgba16sint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder99.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup53, []);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer85, 'uint32', 2_212, 236);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer10);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'log'} });
let commandEncoder123 = device0.createCommandEncoder({});
let texture141 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 328},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder100 = commandEncoder123.beginComputePass();
let sampler77 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 62.35,
  lodMaxClamp: 80.20,
  maxAnisotropy: 3,
});
try {
computePassEncoder98.setBindGroup(2, bindGroup65);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup49, []);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle7, renderBundle7]);
} catch {}
let bindGroup76 = device0.createBindGroup({layout: bindGroupLayout11, entries: [{binding: 212, resource: textureView61}]});
let texture142 = device0.createTexture({
  label: '\u7cd5\u3198\u7a84\ufd49\uffb4\u39aa\u0556\u0b9f\u0659\u{1fbc4}',
  size: {width: 105, height: 1, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView154 = texture35.createView({arrayLayerCount: 1});
try {
computePassEncoder62.setBindGroup(1, bindGroup13);
} catch {}
try {
computePassEncoder100.setPipeline(pipeline0);
} catch {}
try {
buffer48.unmap();
} catch {}
try {
  await promise17;
} catch {}
let bindGroup77 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 110, resource: sampler73},
    {binding: 145, resource: sampler28},
    {binding: 328, resource: {buffer: buffer91, offset: 0}},
  ],
});
let textureView155 = texture84.createView({baseMipLevel: 0});
try {
renderPassEncoder17.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(3, buffer79, 0);
} catch {}
let textureView156 = texture17.createView({});
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer29, 'uint16', 3_036, 3_184);
} catch {}
await gc();
let textureView157 = texture48.createView({
  label: '\u0292\u3c06\ue269\u{1f94a}\u6c47\u{1f8f2}\u0a42\u991e',
  dimension: 'cube-array',
  mipLevelCount: 1,
  arrayLayerCount: 6,
});
let texture143 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 8},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'smpte170m'} });
let externalTexture21 = device0.importExternalTexture({source: video0});
try {
renderPassEncoder12.setBindGroup(1, bindGroup26);
} catch {}
let commandEncoder124 = device0.createCommandEncoder({});
try {
computePassEncoder78.setBindGroup(3, bindGroup8);
} catch {}
try {
computePassEncoder25.setBindGroup(3, bindGroup17, new Uint32Array(1855), 145, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup44);
} catch {}
try {
computePassEncoder90.pushDebugGroup('\u{1f967}');
} catch {}
let bindGroup78 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [{binding: 191, resource: textureView119}, {binding: 100, resource: textureView7}],
});
let buffer105 = device0.createBuffer({size: 6801, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder125 = device0.createCommandEncoder({label: '\u00ff\uc9dc\u76f9\u0867\u3c04\uebe5\u{1fbe7}\u{1f926}'});
let renderPassEncoder21 = commandEncoder124.beginRenderPass({
  colorAttachments: [{
  view: textureView101,
  depthSlice: 8,
  clearValue: { r: -998.9, g: 416.9, b: -724.7, a: -10.25, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet7,
});
let sampler78 = device0.createSampler({
  label: '\u7bc2\u016f\u{1fe1d}\u8728\u85c4\u693b\u007c\u{1fbf6}',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 59.78,
  lodMaxClamp: 98.58,
});
try {
renderPassEncoder16.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer18, 0, 1_518);
} catch {}
let arrayBuffer13 = buffer100.getMappedRange();
try {
commandEncoder125.copyTextureToBuffer({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 41, z: 0},
  aspect: 'stencil-only',
}, {
  /* bytesInLastRow: 288 widthInBlocks: 288 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 728 */
  offset: 728,
  rowsPerImage: 221,
  buffer: buffer1,
}, {width: 288, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder126 = device0.createCommandEncoder({label: '\u0c17\u{1fd70}\u{1f8ae}\u8874'});
let texture144 = device0.createTexture({
  label: '\u079a\u{1f92c}\u0f4c',
  size: [72, 24, 1],
  mipLevelCount: 2,
  format: 'r8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let sampler79 = device0.createSampler({
  label: '\u00e8\u041a\ua179\uc158\ub75b\u0747\u{1ffe2}\u{1f665}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 61.97,
  lodMaxClamp: 77.85,
  compare: 'not-equal',
});
try {
computePassEncoder48.setBindGroup(0, bindGroup25, []);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(2, buffer78, 3_496);
} catch {}
try {
renderPassEncoder17.insertDebugMarker('\u019a');
} catch {}
let bindGroup79 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 172, resource: sampler58},
    {binding: 228, resource: {buffer: buffer82, offset: 0, size: 404}},
  ],
});
let buffer106 = device0.createBuffer({
  size: 3447,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView158 = texture72.createView({});
let computePassEncoder101 = commandEncoder125.beginComputePass({});
try {
computePassEncoder65.setBindGroup(3, bindGroup7, new Uint32Array(2389), 368, 0);
} catch {}
try {
computePassEncoder101.setPipeline(pipeline1);
} catch {}
try {
commandEncoder126.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1488 */
  offset: 1488,
  bytesPerRow: 768,
  rowsPerImage: 155,
  buffer: buffer2,
}, {
  texture: texture114,
  mipLevel: 0,
  origin: {x: 2, y: 8, z: 0},
  aspect: 'all',
}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 78, height: 132, depthOrArrayLayers: 1}
*/
{
  source: imageData9,
  origin: { x: 40, y: 2 },
  flipY: false,
}, {
  texture: texture115,
  mipLevel: 0,
  origin: {x: 4, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 2, depthOrArrayLayers: 0});
} catch {}
let buffer107 = device0.createBuffer({
  size: 1502,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder127 = device0.createCommandEncoder({});
let computePassEncoder102 = commandEncoder127.beginComputePass({});
let renderPassEncoder22 = commandEncoder126.beginRenderPass({
  colorAttachments: [{
  view: textureView101,
  depthSlice: 58,
  clearValue: { r: -977.9, g: -862.0, b: -655.5, a: -997.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder40.setBindGroup(0, bindGroup78, new Uint32Array(38), 9, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer98, 2_052); };
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture145 = device0.createTexture({size: [39], dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder53.setBindGroup(3, bindGroup72);
} catch {}
try {
computePassEncoder54.setBindGroup(0, bindGroup62, new Uint32Array(24), 6, 0);
} catch {}
try {
computePassEncoder102.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(3, buffer105);
} catch {}
try {
window.someLabel = commandEncoder61.label;
} catch {}
let bindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 408,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 27,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8unorm', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 50,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let bindGroup80 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer44, offset: 256, size: 12}}],
});
let buffer108 = device0.createBuffer({
  label: '\u016e\u0011\u0c8b',
  size: 590,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture146 = device0.createTexture({
  size: [9, 16, 1],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder25.setBindGroup(0, bindGroup30);
} catch {}
try {
computePassEncoder64.dispatchWorkgroups(1);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup26, new Uint32Array(175), 29, 0);
} catch {}
try {
  await promise18;
} catch {}
let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470m', transfer: 'unspecified'} });
let texture147 = device0.createTexture({
  size: [32, 32, 16],
  mipLevelCount: 1,
  dimension: '2d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder19.setIndexBuffer(buffer20, 'uint16', 32, 294);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(3, buffer42, 0, 4_425);
} catch {}
await gc();
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt709', transfer: 'bt2020_12bit'} });
let commandEncoder128 = device0.createCommandEncoder({});
let textureView159 = texture146.createView({arrayLayerCount: 1});
let texture148 = device0.createTexture({
  size: [840, 1, 38],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder103 = commandEncoder128.beginComputePass({label: '\uffdd\u03c4\u0987\u0ef6'});
try {
computePassEncoder76.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer39, 'uint32', 128, 486);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(7, buffer69);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.submit([commandBuffer7]);
} catch {}
let textureView160 = texture103.createView({label: '\u5f5b\u4f70'});
let textureView161 = texture116.createView({label: '\ue218\u00aa\u8f2e\u072f\u{1fda8}\u1852\u0871\u3774\u{1fa0a}\u3efb'});
try {
renderPassEncoder18.setIndexBuffer(buffer82, 'uint16', 1_060, 1_002);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(0, buffer44, 1_220, 136);
} catch {}
try {
if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55); };
} catch {}
let texture149 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder40.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder103.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder22.setScissorRect(25, 0, 4, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder129 = device0.createCommandEncoder({label: '\u0f1e\u{1f6cd}\ud317\u10b7\u8d66\u{1ffe2}\u03b7\u0416\u{1fa90}\u4f29'});
let computePassEncoder104 = commandEncoder129.beginComputePass({label: '\uca5c\u7bd0\u05c1\ue501\ud5fd\u6891'});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer63, 12); };
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup36, new Uint32Array(1601), 293, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, buffer78, 0, 7_571);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup81 = device0.createBindGroup({
  layout: bindGroupLayout15,
  entries: [{binding: 80, resource: textureView140}, {binding: 133, resource: textureView153}],
});
try {
renderPassEncoder20.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(1, buffer75, 0);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
canvas1.width = 708;
try {
computePassEncoder39.setBindGroup(0, bindGroup45, new Uint32Array(873), 40, 0);
} catch {}
try {
computePassEncoder104.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture18,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(180).fill(128), /* required buffer size: 180 */
{offset: 180}, {width: 28, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup82 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 27, resource: textureView159},
    {binding: 408, resource: {buffer: buffer2, offset: 512, size: 12912}},
    {binding: 50, resource: textureView10},
  ],
});
let sampler80 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 23.64,
  lodMaxClamp: 88.60,
});
try {
computePassEncoder38.setBindGroup(2, bindGroup57, []);
} catch {}
try {
computePassEncoder45.setBindGroup(1, bindGroup7, new Uint32Array(4851), 101, 0);
} catch {}
let textureView162 = texture5.createView({baseArrayLayer: 0});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup56);
} catch {}
try {
computePassEncoder90.popDebugGroup();
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
});
} catch {}
let canvas3 = document.createElement('canvas');
try {
externalTexture4.label = '\u0cda\u{1ff85}\u0c7c\u3c57\ufe2d\u71c9\u901a\u60c4\u04dd\u065a\u0923';
} catch {}
let bindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 8,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 301,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 150,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 62,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 102,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 125,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 152,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 27,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 142,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d' },
    },
    {binding: 77, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 65,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 119,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 32,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 598,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 196,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 28,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 192,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 171,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 113,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 380,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 810,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 66,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 203,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {
      binding: 209,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 277,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 91,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 7, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {binding: 386, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 114,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 99,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 839,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 225,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 698,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 566,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 245,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 296,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
    {binding: 0, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 304,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 50,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 178, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 52, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {binding: 220, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {
      binding: 58,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 249,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {binding: 90, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 132,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 82,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 308, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 55, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
  ],
});
let buffer109 = device0.createBuffer({size: 35565, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let texture150 = device0.createTexture({
  size: {width: 36},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView163 = texture95.createView({label: '\u8d37\u14c1\u{1faf1}', dimension: '2d-array', mipLevelCount: 1});
let sampler81 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 2.577,
  lodMaxClamp: 70.29,
});
try {
computePassEncoder50.setBindGroup(0, bindGroup59);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup79);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
buffer91.unmap();
} catch {}
let buffer110 = device0.createBuffer({size: 9104, usage: GPUBufferUsage.STORAGE, mappedAtCreation: true});
let texture151 = device0.createTexture({
  size: [144, 48, 1],
  mipLevelCount: 1,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture152 = device0.createTexture({
  size: [32, 32, 16],
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let sampler82 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 15.70,
  maxAnisotropy: 1,
});
try {
renderPassEncoder16.setBindGroup(1, bindGroup59, []);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer47, 'uint16', 68, 1_261);
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 6, y: 10 },
  flipY: false,
}, {
  texture: texture92,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 5, depthOrArrayLayers: 0});
} catch {}
let textureView164 = texture150.createView({});
let textureView165 = texture88.createView({format: 'rg32float', arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer78, 1_252); };
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup2, new Uint32Array(115), 0, 0);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder130 = device0.createCommandEncoder({});
let texture153 = device0.createTexture({
  size: [36, 12, 1],
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture154 = device0.createTexture({
  label: '\u038d\u0701\u859a\u1c3d\u4359',
  size: {width: 840, height: 1, depthOrArrayLayers: 35},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder105 = commandEncoder130.beginComputePass({label: '\u9fa2\u9c97\u0d4e\u{1f7bd}'});
try {
computePassEncoder35.setBindGroup(1, bindGroup75);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup4, new Uint32Array(558), 32, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle7, renderBundle6]);
} catch {}
let arrayBuffer14 = buffer27.getMappedRange(0, 14584);
try {
device0.queue.writeBuffer(buffer16, 104, new Float32Array(2682), 624, 180);
} catch {}
document.body.append(canvas2);
let buffer111 = device0.createBuffer({size: 14278, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let textureView166 = texture151.createView({dimension: '2d'});
try {
renderPassEncoder14.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle7, renderBundle7, renderBundle6]);
} catch {}
try {
device0.queue.writeBuffer(buffer93, 172, new Int16Array(2973), 528, 180);
} catch {}
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); };
} catch {}
let buffer112 = device0.createBuffer({size: 1276, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true});
let commandEncoder131 = device0.createCommandEncoder({});
let texture155 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder106 = commandEncoder131.beginComputePass({});
try {
computePassEncoder1.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder101.setBindGroup(2, bindGroup1, new Uint32Array(2124), 552, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer6, 1_892); };
} catch {}
try {
computePassEncoder105.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup16);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer11, 'uint16', 5_482, 403);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(3, buffer74, 2_268);
} catch {}
let textureView167 = texture153.createView({dimension: '2d-array', format: 'r32uint', baseArrayLayer: 0});
let sampler83 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 63.58,
  lodMaxClamp: 94.60,
  maxAnisotropy: 16,
});
try {
computePassEncoder91.setBindGroup(3, bindGroup20, new Uint32Array(1833), 812, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer60, 'uint32', 160, 1_312);
} catch {}
let arrayBuffer15 = buffer66.getMappedRange(0, 5200);
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'depth32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['stencil8'],
  colorSpace: 'display-p3',
});
} catch {}
try {
  await promise19;
} catch {}
let imageData16 = new ImageData(60, 32);
let textureView168 = texture147.createView({label: '\udbec\u001e\u0a60\u{1f60b}\u{1f749}\u90a6\u8433\uc999', dimension: '2d'});
let textureView169 = texture56.createView({mipLevelCount: 1});
try {
computePassEncoder106.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup61, new Uint32Array(3947), 215, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer7, 'uint32', 808, 2_825);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 11, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture156 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 126},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder88.setBindGroup(0, bindGroup81);
} catch {}
try {
computePassEncoder40.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup79);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(7, buffer59, 14_636);
} catch {}
try {
buffer52.unmap();
} catch {}
document.body.prepend(canvas3);
let buffer113 = device0.createBuffer({
  size: 15240,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder75.setBindGroup(2, bindGroup33);
} catch {}
try {
buffer79.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer64, 9556, new BigUint64Array(694));
} catch {}
try {
externalTexture17.label = '\u{1fb57}\uabf1\u7e5f\u{1f74b}\u{1fd45}\u0142\uba6c\u0d3a\u0b35\ub3fb';
} catch {}
try {
renderPassEncoder4.setViewport(47.14780858950225, 54.74352166171568, 220.98729886984552, 8.494962346072747, 0.9957926747652339, 0.9983517640905382);
} catch {}
try {
buffer108.unmap();
} catch {}
let bindGroup83 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 4, resource: textureView57},
    {binding: 23, resource: textureView10},
    {binding: 505, resource: {buffer: buffer94, offset: 0, size: 404}},
    {binding: 69, resource: textureView36},
  ],
});
let buffer114 = device0.createBuffer({
  label: '\u{1fe88}\u{1fe7b}\uafa1\u0cab\ua652\u0a6b\uc3dd\uc808\u0d45\u3fc7\u13b6',
  size: 1687,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let querySet23 = device0.createQuerySet({type: 'occlusion', count: 2563});
let textureView170 = texture139.createView({format: 'rg16sint', mipLevelCount: 1});
let sampler84 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 67.40});
try {
renderPassEncoder18.setBindGroup(1, bindGroup77);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle3, renderBundle3]);
} catch {}
let buffer115 = device0.createBuffer({
  size: 9562,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler85 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 18.80,
  lodMaxClamp: 67.66,
  compare: 'greater-equal',
  maxAnisotropy: 2,
});
try {
computePassEncoder102.setBindGroup(2, bindGroup36);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(1, buffer115, 676, 1_095);
} catch {}
try {
buffer21.unmap();
} catch {}
try {
computePassEncoder90.insertDebugMarker('\u{1fad4}');
} catch {}
let gpuCanvasContext6 = canvas3.getContext('webgpu');
video1.width = 22;
try {
renderPassEncoder21.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup35, new Uint32Array(2180), 164, 0);
} catch {}
let commandEncoder132 = device0.createCommandEncoder({});
let textureView171 = texture43.createView({
  label: '\u{1fa47}\u7bbc\u0e2b\u{1fc65}\u0677\ub506\u035f\u4730\u1c25\u5f37\u0fd8',
  dimension: '2d-array',
  format: 'r8unorm',
  baseMipLevel: 0,
});
let computePassEncoder107 = commandEncoder132.beginComputePass({});
try {
computePassEncoder4.setBindGroup(0, bindGroup37);
} catch {}
try {
computePassEncoder107.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup6, new Uint32Array(2038), 703, 0);
} catch {}
let bindGroup84 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 78, resource: textureView23},
    {binding: 270, resource: textureView108},
    {binding: 164, resource: textureView74},
    {binding: 414, resource: textureView7},
    {binding: 261, resource: {buffer: buffer107, offset: 256, size: 482}},
    {binding: 221, resource: textureView27},
    {binding: 337, resource: textureView84},
    {binding: 54, resource: externalTexture8},
    {binding: 311, resource: {buffer: buffer47, offset: 512, size: 1963}},
    {binding: 26, resource: textureView121},
    {binding: 119, resource: {buffer: buffer26, offset: 1280, size: 2583}},
    {binding: 667, resource: textureView136},
    {binding: 116, resource: sampler13},
    {binding: 47, resource: externalTexture1},
    {binding: 141, resource: sampler57},
    {binding: 79, resource: textureView160},
  ],
});
let buffer116 = device0.createBuffer({
  label: '\u{1fa12}\u040a',
  size: 1404,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder133 = device0.createCommandEncoder({});
let textureView172 = texture151.createView({label: '\u{1f8aa}\u2234\u{1f7c8}\u9a45\u797b\u4ed0\u0dca'});
let textureView173 = texture18.createView({
  label: '\u02d3\u{1f86c}\u00e0\uc65b\ub353\u{1f83f}',
  dimension: '3d',
  baseMipLevel: 0,
  mipLevelCount: 1,
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer98, 1_556); };
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup83);
} catch {}
try {
buffer87.unmap();
} catch {}
document.body.prepend(canvas1);
let textureView174 = texture94.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder17.setBindGroup(3, bindGroup36, new Uint32Array(1719), 594, 0);
} catch {}
try {
commandEncoder133.copyTextureToTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture25,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup85 = device0.createBindGroup({
  layout: bindGroupLayout18,
  entries: [
    {binding: 32, resource: textureView113},
    {binding: 142, resource: textureView172},
    {binding: 598, resource: {buffer: buffer9, offset: 0, size: 132}},
    {binding: 209, resource: textureView9},
    {binding: 225, resource: sampler38},
    {binding: 245, resource: textureView36},
    {binding: 113, resource: textureView69},
    {binding: 66, resource: textureView90},
    {binding: 296, resource: textureView101},
    {binding: 304, resource: externalTexture6},
    {binding: 249, resource: sampler24},
    {binding: 91, resource: {buffer: buffer47, offset: 6144}},
    {binding: 220, resource: sampler18},
    {binding: 6, resource: {buffer: buffer37, offset: 1024}},
    {binding: 839, resource: {buffer: buffer75, offset: 0, size: 533}},
    {binding: 698, resource: textureView36},
    {binding: 50, resource: {buffer: buffer22, offset: 0, size: 368}},
    {binding: 178, resource: sampler17},
    {binding: 810, resource: {buffer: buffer97, offset: 6144, size: 4916}},
    {binding: 380, resource: textureView77},
    {binding: 65, resource: textureView49},
    {binding: 7, resource: sampler2},
    {binding: 62, resource: {buffer: buffer50, offset: 13312, size: 2068}},
    {binding: 277, resource: textureView57},
    {binding: 192, resource: textureView10},
    {binding: 152, resource: {buffer: buffer106, offset: 768, size: 74}},
    {binding: 308, resource: externalTexture16},
    {binding: 82, resource: {buffer: buffer96, offset: 256, size: 1529}},
    {binding: 171, resource: textureView141},
    {binding: 99, resource: textureView119},
    {binding: 301, resource: {buffer: buffer96, offset: 2048, size: 256}},
    {binding: 566, resource: {buffer: buffer48, offset: 0, size: 29}},
    {binding: 28, resource: textureView106},
    {binding: 196, resource: {buffer: buffer101, offset: 768, size: 4796}},
    {binding: 15, resource: textureView167},
    {binding: 114, resource: textureView44},
    {binding: 203, resource: textureView161},
    {binding: 150, resource: textureView162},
    {binding: 56, resource: {buffer: buffer26, offset: 2816, size: 935}},
    {binding: 125, resource: sampler58},
    {binding: 77, resource: externalTexture10},
    {binding: 0, resource: externalTexture1},
    {binding: 52, resource: sampler80},
    {binding: 102, resource: {buffer: buffer79, offset: 0, size: 1852}},
    {binding: 8, resource: textureView164},
    {binding: 90, resource: {buffer: buffer33, offset: 256, size: 104}},
    {binding: 58, resource: sampler44},
    {binding: 27, resource: {buffer: buffer87, offset: 0, size: 76}},
    {binding: 119, resource: {buffer: buffer60, offset: 2304, size: 1724}},
    {binding: 132, resource: {buffer: buffer86, offset: 1792, size: 3573}},
    {binding: 55, resource: sampler32},
    {binding: 386, resource: sampler58},
  ],
});
let buffer117 = device0.createBuffer({
  size: 573,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let computePassEncoder108 = commandEncoder133.beginComputePass({});
let sampler86 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'clamp-to-edge', magFilter: 'linear', lodMinClamp: 7.405});
try {
computePassEncoder95.setBindGroup(1, bindGroup57);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer16, 136); };
} catch {}
try {
computePassEncoder108.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder18.setBindGroup(2, bindGroup56);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup73, new Uint32Array(902), 50, 0);
} catch {}
document.body.append(canvas3);
await gc();
let texture157 = device0.createTexture({
  size: [840, 1, 76],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder25.setBindGroup(0, bindGroup62, new Uint32Array(341), 41, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer12, 'uint32', 9_268, 1_460);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(3, buffer64, 6_988);
} catch {}
try {
buffer111.unmap();
} catch {}
let commandEncoder134 = device0.createCommandEncoder({});
let texture158 = device0.createTexture({
  size: [840, 1, 4],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView175 = texture151.createView({label: '\ub6f6\u479e\u021e\u07d7\u03e9\u0d7e\u0d1c\u04cd', dimension: '2d-array'});
let computePassEncoder109 = commandEncoder134.beginComputePass({});
try {
renderPassEncoder12.setBindGroup(0, bindGroup62);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup8, new Uint32Array(4693), 157, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(1061);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer69, 0, 42);
} catch {}
let commandEncoder135 = device0.createCommandEncoder({});
let texture159 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder15.setBindGroup(1, bindGroup8);
} catch {}
try {
computePassEncoder109.setBindGroup(2, bindGroup29, new Uint32Array(168), 62, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder109.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup80, new Uint32Array(409), 58, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle0, renderBundle6]);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer33, 'uint16', 64, 1_234);
} catch {}
try {
buffer116.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer9, 0, new DataView(new ArrayBuffer(9984)), 2470, 256);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let commandEncoder136 = device0.createCommandEncoder({});
let texture160 = device0.createTexture({size: [32, 32, 16], format: 'r8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView176 = texture33.createView({});
let computePassEncoder110 = commandEncoder136.beginComputePass({});
let externalTexture22 = device0.importExternalTexture({source: videoFrame18, colorSpace: 'display-p3'});
try {
computePassEncoder82.setBindGroup(2, bindGroup32);
} catch {}
try {
computePassEncoder110.setBindGroup(3, bindGroup6, new Uint32Array(957), 139, 0);
} catch {}
try {
computePassEncoder110.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup68, []);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup33, new Uint32Array(1203), 28, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer37, 'uint32', 84, 974);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(5, buffer103);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder137 = device0.createCommandEncoder({});
let textureView177 = texture151.createView({label: '\uf292\u83ff\u{1fbd9}\u039d\u509c\ufac6\u{1f609}\u3bb2\ub207\u2297', dimension: '2d-array'});
let computePassEncoder111 = commandEncoder135.beginComputePass();
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer37, 'uint16', 552, 231);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer86);
} catch {}
document.body.prepend(video0);
let computePassEncoder112 = commandEncoder137.beginComputePass({});
let externalTexture23 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
computePassEncoder17.setBindGroup(1, bindGroup15);
} catch {}
try {
computePassEncoder26.setBindGroup(3, bindGroup17, new Uint32Array(56), 6, 0);
} catch {}
try {
computePassEncoder112.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder68.insertDebugMarker('\ud4f7');
} catch {}
try {
window.someLabel = externalTexture14.label;
} catch {}
let textureView178 = texture157.createView({dimension: '2d-array', baseArrayLayer: 3, arrayLayerCount: 14});
let texture161 = device0.createTexture({size: [36], dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
try {
computePassEncoder111.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(5, buffer58, 0, 806);
} catch {}
try {
buffer113.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); };
} catch {}
document.body.append(img0);
let textureView179 = texture16.createView({label: '\u{1fe85}\u{1fdde}\u{1f67b}\u6fdc', dimension: '1d'});
try {
renderPassEncoder15.executeBundles([renderBundle0, renderBundle0]);
} catch {}
let commandEncoder138 = device0.createCommandEncoder({});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer118 = device0.createBuffer({
  size: 7100,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let computePassEncoder113 = commandEncoder138.beginComputePass();
try {
computePassEncoder113.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(3);
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 7 max align: 1 */
struct T0 {
  @align(1) @size(7) f0: array<i32, 1>,
}
/* target size: 143 max align: 1 */
struct T1 {
  @align(1) @size(143) f0: array<atomic<u32>>,
}
@id(36790) override override34 : i32 = 193;
@id(52751) override override33 : u32 = 231;
@id(62488) override override35 : u32;
override override40 : u32;
@id(47762) override override31 : bool = false;
@id(36561) override override38 : f32 = -0.7565;
@id(34108) override override36 : bool = override31;
@id(25384) override override41 : f32 = -0.8479;
@id(9301) override override32 : f16;
override override39 : i32 = 64;
@id(39210) override override30 : u32 = 116;
@id(29277) override override42 : i32 = 9;
override override37 : f16 = -51659.4;
@group(0) @binding(172) var sam4: sampler;
@group(0) @binding(228) var<storage, read_write> buffer119: T1;
@group(1) @binding(18) var tex4: texture_2d_array<f32>;
struct VertexOutput5 {
  @location(7) f15: vec3h,
  @location(1) f16: f32,
  @builtin(position) f17: vec4f
}

@vertex
fn vertex0(@location(15) @interpolate(flat, sample) a0: vec4f, @location(10) @interpolate(flat) a1: u32, @location(2) a2: vec4h) -> VertexOutput5 {
  var out: VertexOutput5;
  _ = override42;
  _ = override30;
  _ = override40;
  return out;
}
struct FragmentOutput2 {
  @location(5) @interpolate(flat) f0: vec2i,
  @location(4) f1: vec3i,
  @location(0) f2: vec4f
}

@fragment
fn fragment0() -> FragmentOutput2 {
  var out: FragmentOutput2;
  _ = textureSampleLevel(tex4, sam4, vec2f(), 0, 0.0);
  _ = arrayLength(&buffer119.f0);
  _ = override31;
  _ = buffer119.f0[arrayLength(&buffer119.f0)];
  if bool(textureSampleGrad(tex4, sam4, vec2f(), 0i, vec2f(), vec2f(), vec2i())[0]) {
    atomicMax(&buffer119.f0[12345], 54);
  }
  return out;
}
struct FragmentOutput3 {
  @location(5) @interpolate(flat) f0: vec4u,
  @location(1) f1: vec2i,
  @location(0) @interpolate(perspective) f2: vec2f,
  @location(2) f3: vec4i
}

@fragment
fn fragment1() -> FragmentOutput3 {
  var out: FragmentOutput3;
  _ = override38;
  _ = override42;
  _ = textureSampleBias(tex4, sam4, vec2f(), 0i, 0.0, vec2i());
  _ = override36;
  _ = textureLoad(tex4, vec2i(), 0, 0);
  _ = textureSampleBias(tex4, sam4, vec2f(), 0i, 0.0);
  if bool(override41) {
    discard;
  }
  if bool(textureSampleBias(tex4, sam4, vec2f(), 0i, 0.0)[3]) {
    out.f3 = vec4i(i32(override36));
  }
  if override31 {
    out.f2 += vec2f(bitcast<f32>(override30));
  }
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder139 = device0.createCommandEncoder({});
let texture162 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 48},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView180 = texture103.createView({label: '\u934f\u0c7f\u{1fee7}\u0427\u40a9\uac70\u{1fec5}\u1349\u0143\u9dd6', baseArrayLayer: 0});
try {
computePassEncoder97.setBindGroup(0, bindGroup23, new Uint32Array(2230), 844, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer115, 5_636); };
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup22, new Uint32Array(397), 99, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
commandEncoder139.copyTextureToBuffer({
  texture: texture63,
  mipLevel: 1,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 216 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 264 */
  offset: 264,
  buffer: buffer113,
}, {width: 27, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder56.insertDebugMarker('\u2022');
} catch {}
let texture163 = device0.createTexture({
  label: '\u0621\u1b06\u854e\u086c\u4cfd\u{1fe25}',
  size: [9, 16, 1],
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder23 = commandEncoder139.beginRenderPass({
  label: '\ud43c\u08b0\u25e8\u1809\u0770\u0764\u{1fe29}\u0727\u3714\u86ef\u9914',
  colorAttachments: [{
  view: textureView97,
  clearValue: { r: 114.6, g: -737.0, b: 71.66, a: -461.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler87 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 96.57,
  lodMaxClamp: 98.98,
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer16, 296); };
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup69, new Uint32Array(1369), 69, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(7, buffer85, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(2); };
} catch {}
try {
buffer28.unmap();
} catch {}
try {
computePassEncoder112.setBindGroup(2, bindGroup65);
} catch {}
try {
renderPassEncoder19.setStencilReference(521);
} catch {}
let bindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {binding: 25, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let buffer120 = device0.createBuffer({
  size: 9328,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture164 = gpuCanvasContext3.getCurrentTexture();
let textureView181 = texture74.createView({dimension: '2d-array', mipLevelCount: 1});
let sampler88 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 51.88,
  lodMaxClamp: 87.89,
  maxAnisotropy: 7,
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(3, 1); };
} catch {}
try {
renderPassEncoder18.end();
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle7, renderBundle0]);
} catch {}
try {
renderPassEncoder17.setViewport(49.318697071371496, 80.74649435301288, 9.427378582876408, 0.037741139375855964, 0.5161463560625463, 0.5795996499362315);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 24, new DataView(new ArrayBuffer(29434)), 249, 13400);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: canvas1,
  origin: { x: 92, y: 23 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 27, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 9, height: 10, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let videoFrame26 = new VideoFrame(canvas1, {timestamp: 0});
let textureView182 = texture150.createView({dimension: '1d', arrayLayerCount: 1});
let texture165 = device0.createTexture({
  size: [420, 1, 105],
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView183 = texture41.createView({
  label: '\u9fc5\u{1fa71}\ua83e\u563c\u03d7\udfe7\u9e31\u0f39\u940e\u1dda',
  baseMipLevel: 0,
  mipLevelCount: 1,
});
let sampler89 = device0.createSampler({
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.98,
  lodMaxClamp: 97.55,
  maxAnisotropy: 14,
});
let bindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 188,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 61,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle9 = renderBundleEncoder9.finish({label: '\u{1fb0b}\ubd6d\u7b69\ue014\uec99\u06c9\u2a78\u79ee\u0123'});
let sampler90 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 22.03,
  maxAnisotropy: 1,
});
try {
computePassEncoder109.setBindGroup(0, bindGroup12);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer105, 980); };
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(3, buffer41, 0);
} catch {}
try {
computePassEncoder83.pushDebugGroup('\u0808');
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(79).fill(22), /* required buffer size: 79 */
{offset: 79, bytesPerRow: 178}, {width: 2, height: 34, depthOrArrayLayers: 0});
} catch {}
video1.width = 20;
let buffer121 = device0.createBuffer({size: 9187, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let commandEncoder140 = device0.createCommandEncoder();
let computePassEncoder114 = commandEncoder140.beginComputePass();
try {
computePassEncoder1.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup73);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer12, 'uint32', 3_504, 247);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer26, 0);
} catch {}
try {
  await shaderModule4.getCompilationInfo();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
computePassEncoder114.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer117, 'uint16', 36, 161);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(1, buffer17, 2_972);
} catch {}
try {
device0.queue.writeBuffer(buffer76, 288, new Float32Array(8054), 2692, 500);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(177).fill(181), /* required buffer size: 177 */
{offset: 177}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 34}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 148, y: 0, z: 7},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer15.detached) { new Uint8Array(arrayBuffer15).fill(0x55); };
} catch {}
let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout20]});
let buffer122 = device0.createBuffer({size: 10446, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
try {
computePassEncoder77.setBindGroup(1, bindGroup11, new Uint32Array(610), 35, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1, 2); };
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup84, new Uint32Array(1318), 468, 0);
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); };
} catch {}
let shaderModule8 = device0.createShaderModule({
  label: '\u4514\ucb8e\u{1f97c}\u76d1\u05b1\u3474\u01d2\u{1f70d}\u05a1\ud408',
  code: `
enable f16;
/* target size: 23 max align: 1 */
struct T0 {
  @align(1) f0: array<atomic<u32>, 4>,
  @align(1) @size(7) f1: i32,
}
@group(0) @binding(265) var<storage, read_write> buffer123: array<T0>;

@vertex @must_use
fn vertex0() -> @builtin(position) vec4f {
  var out: vec4f;
  return out;
}
struct FragmentOutput4 {
  @location(1) @interpolate(flat) f0: vec4i,
  @location(6) f1: i32,
  @location(0) f2: vec3f
}

@fragment
fn fragment0() -> FragmentOutput4 {
  var out: FragmentOutput4;
  _ = buffer123[arrayLength(&buffer123)].f0[3];
  out.f1 &= buffer123[arrayLength(&buffer123)].f1;
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
  _ = buffer123[arrayLength(&buffer123)].f0;
}`,
  sourceMap: {},
  hints: {},
});
try {
computePassEncoder15.setBindGroup(3, bindGroup9, new Uint32Array(1395), 130, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer75, 'uint16', 574, 468);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 3, y: 20 },
  flipY: false,
}, {
  texture: texture123,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 243,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let commandEncoder141 = device0.createCommandEncoder({label: '\u{1f7fd}\u02f5\u04fc\u4452\u8162\u049d\ud453\u0fad\ua80e\u0d63\u8786'});
let sampler91 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 49.82,
  compare: 'equal',
  maxAnisotropy: 1,
});
try {
renderPassEncoder12.setBindGroup(2, bindGroup51);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer82, 'uint32', 344, 783);
} catch {}
try {
device0.queue.writeBuffer(buffer87, 36, new Float32Array(17849), 4928, 0);
} catch {}
let img2 = await imageWithData(41, 4, '#10101010', '#20202020');
let texture166 = device0.createTexture({
  size: [32, 32, 692],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder115 = commandEncoder141.beginComputePass({});
try {
computePassEncoder115.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup79, new Uint32Array(4135), 2_247, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer87, 12, 76);
} catch {}
try {
computePassEncoder83.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer75, 2264, new Float32Array(20319), 6271, 84);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture84,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(64).fill(161), /* required buffer size: 64 */
{offset: 64}, {width: 33, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let offscreenCanvas4 = new OffscreenCanvas(54, 238);
let bindGroup86 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 56, resource: textureView33},
    {binding: 286, resource: sampler58},
    {binding: 57, resource: textureView65},
    {binding: 238, resource: sampler38},
    {binding: 151, resource: {buffer: buffer47, offset: 512}},
    {binding: 388, resource: {buffer: buffer91, offset: 0}},
    {binding: 33, resource: {buffer: buffer97, offset: 14336, size: 27365}},
    {binding: 309, resource: textureView14},
    {binding: 21, resource: textureView8},
    {binding: 103, resource: textureView63},
    {binding: 159, resource: {buffer: buffer24, offset: 0, size: 1860}},
    {binding: 313, resource: {buffer: buffer96, offset: 2560, size: 608}},
    {binding: 528, resource: sampler77},
  ],
});
let commandEncoder142 = device0.createCommandEncoder({});
try {
computePassEncoder53.setBindGroup(1, bindGroup7, new Uint32Array(1850), 72, 0);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup8, new Uint32Array(6589), 23, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer71, 'uint16', 1_446, 937);
} catch {}
try {
commandEncoder142.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 4264 */
  offset: 4264,
  bytesPerRow: 512,
  buffer: buffer97,
}, {
  texture: texture112,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let buffer124 = device0.createBuffer({size: 16841, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture167 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder116 = commandEncoder142.beginComputePass({});
try {
computePassEncoder59.setBindGroup(1, bindGroup72);
} catch {}
try {
computePassEncoder84.setBindGroup(0, bindGroup80, new Uint32Array(578), 4, 0);
} catch {}
try {
computePassEncoder116.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer28, 'uint16', 9_708, 2_447);
} catch {}
try {
computePassEncoder23.pushDebugGroup('\u9d7d');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
textureView164.label = '\u0dd0\u8d16\u{1f66c}\u15fb\u{1fd79}\u{1fd39}\u{1f6e8}';
} catch {}
let bindGroup87 = device0.createBindGroup({
  label: '\u3e7c\u0c15\u0384\ud823\u{1f994}\u2fd4\u{1fb80}\u{1fc1e}\u0bdc\uc4ca\u835f',
  layout: bindGroupLayout19,
  entries: [{binding: 25, resource: {buffer: buffer86, offset: 1024, size: 276}}],
});
let texture168 = device0.createTexture({
  size: {width: 210},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder99.setBindGroup(0, bindGroup53);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer106, 12); };
} catch {}
try {
device0.queue.writeBuffer(buffer73, 984, new Int16Array(798), 169, 28);
} catch {}
try {
pipelineLayout4.label = '\u0c29\ua2b1\u03a9\u0e9a\u07cb';
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer48, 12); };
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.queue.writeBuffer(buffer9, 64, new BigUint64Array(3732), 834, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 34}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView184 = texture81.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer7, 780); };
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup4);
} catch {}
try {
  await shaderModule2.getCompilationInfo();
} catch {}
let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpte240m', transfer: 'iec6196624'} });
let bindGroup88 = device0.createBindGroup({
  label: '\u3289\u00ed\uf018',
  layout: bindGroupLayout16,
  entries: [{binding: 289, resource: textureView162}, {binding: 116, resource: textureView93}],
});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder91.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer64, 'uint16', 4_856, 585);
} catch {}
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm']});
try {
computePassEncoder46.setBindGroup(2, bindGroup53, new Uint32Array(883), 28, 0);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle7, renderBundle6, renderBundle7, renderBundle3]);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer107, 'uint32', 104, 317);
} catch {}
try {
renderBundleEncoder11.setBindGroup(3, bindGroup37, new Uint32Array(911), 20, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 20, y: 0 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 6, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 9, height: 5, depthOrArrayLayers: 0});
} catch {}
let bindGroup89 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 145, resource: sampler21},
    {binding: 328, resource: {buffer: buffer22, offset: 0, size: 95}},
    {binding: 110, resource: sampler45},
  ],
});
let textureView185 = texture21.createView({label: '\u2440\u0097', format: 'r16sint', mipLevelCount: 1});
try {
renderPassEncoder17.setBindGroup(0, bindGroup81);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer24, 'uint16', 510, 1_078);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer109, 3_532, 704);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup52);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer100, 'uint32', 288, 505);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte432', transfer: 'bt2020_10bit'} });
let texture169 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 20},
  sampleCount: 1,
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder22.setStencilReference(852);
} catch {}
let gpuCanvasContext7 = offscreenCanvas4.getContext('webgpu');
let buffer125 = device0.createBuffer({size: 11820, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder143 = device0.createCommandEncoder({});
try {
computePassEncoder113.setBindGroup(3, bindGroup36, new Uint32Array(369), 61, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup38);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(116);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer115, 'uint32', 512, 642);
} catch {}
try {
if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55); };
} catch {}
try {
window.someLabel = device0.queue.label;
} catch {}
let bindGroup90 = device0.createBindGroup({
  layout: bindGroupLayout12,
  entries: [
    {binding: 106, resource: {buffer: buffer87, offset: 0}},
    {binding: 74, resource: sampler11},
    {binding: 20, resource: textureView124},
  ],
});
let buffer126 = device0.createBuffer({size: 1673, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
computePassEncoder17.setBindGroup(0, bindGroup54);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup71);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder20.setScissorRect(0, 0, 4, 0);
} catch {}
try {
renderBundleEncoder10.setBindGroup(3, bindGroup57, new Uint32Array(188), 4, 0);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer20, 'uint32', 8, 23);
} catch {}
let buffer127 = device0.createBuffer({size: 471, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let renderBundle10 = renderBundleEncoder11.finish();
try {
computePassEncoder108.setBindGroup(1, bindGroup55);
} catch {}
try {
computePassEncoder109.setBindGroup(2, bindGroup44, new Uint32Array(857), 219, 0);
} catch {}
try {
renderPassEncoder22.setStencilReference(381);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer75, 'uint16', 1_108, 2_391);
} catch {}
try {
device0.queue.writeBuffer(buffer39, 4, new BigUint64Array(20368), 1658, 28);
} catch {}
let imageData17 = new ImageData(84, 116);
let textureView186 = texture163.createView({dimension: '2d-array'});
let textureView187 = texture30.createView({label: '\u083f\u0209\u04ec\u7b7f'});
let computePassEncoder117 = commandEncoder143.beginComputePass();
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true});
try {
computePassEncoder31.setBindGroup(0, bindGroup28);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer97, 12_132); };
} catch {}
try {
computePassEncoder117.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer117, 'uint16', 8, 148);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup42, new Uint32Array(1119), 284, 0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer97, 'uint32', 22_004, 11_419);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(4, undefined, 909_235_774);
} catch {}
try {
buffer95.unmap();
} catch {}
let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'unspecified', transfer: 'bt2020_12bit'} });
let bindGroup91 = device0.createBindGroup({
  label: '\uf3f5\u{1f6a8}\u41c4\u63c8\u{1fe86}\u0147\u5df8\u0124',
  layout: bindGroupLayout9,
  entries: [
    {binding: 159, resource: {buffer: buffer5, offset: 768, size: 2212}},
    {binding: 309, resource: textureView14},
    {binding: 57, resource: textureView65},
    {binding: 151, resource: {buffer: buffer94, offset: 512, size: 651}},
    {binding: 388, resource: {buffer: buffer51, offset: 512, size: 377}},
    {binding: 238, resource: sampler48},
    {binding: 103, resource: textureView181},
    {binding: 21, resource: textureView7},
    {binding: 56, resource: textureView59},
    {binding: 528, resource: sampler41},
    {binding: 33, resource: {buffer: buffer96, offset: 0, size: 2844}},
    {binding: 313, resource: {buffer: buffer33, offset: 0, size: 3008}},
    {binding: 286, resource: sampler2},
  ],
});
let buffer128 = device0.createBuffer({
  label: '\u025e\ufc9c\u646e\u0c70',
  size: 2995,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder64.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(2, buffer105, 0, 36);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); };
} catch {}
document.body.prepend(canvas1);
let imageData18 = new ImageData(84, 4);
let buffer129 = device0.createBuffer({size: 4012, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true});
try {
computePassEncoder104.setBindGroup(2, bindGroup44, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer94, 216); };
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup13);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup71, new Uint32Array(20), 0, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer75, 'uint16', 2_930, 1_134);
} catch {}
let buffer130 = device0.createBuffer({size: 7830, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let renderBundle11 = renderBundleEncoder10.finish({label: '\u{1fa61}\u{1fae1}\u{1f903}\uc56a\u4887\u0285\ud129'});
let sampler92 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  lodMinClamp: 68.24,
  lodMaxClamp: 82.29,
  maxAnisotropy: 1,
});
try {
renderPassEncoder20.setBindGroup(2, bindGroup23);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(4, buffer2);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55); };
} catch {}
try {
computePassEncoder74.setBindGroup(0, bindGroup79, new Uint32Array(259), 39, 0);
} catch {}
try {
computePassEncoder67.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle10]);
} catch {}
try {
renderPassEncoder22.setScissorRect(226, 0, 318, 0);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup84);
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); };
} catch {}
let commandEncoder144 = device0.createCommandEncoder();
try {
computePassEncoder94.setBindGroup(3, bindGroup45, new Uint32Array(1106), 79, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup27);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(3, buffer107, 32, 148);
} catch {}
try {
commandEncoder144.copyTextureToTexture({
  texture: texture106,
  mipLevel: 0,
  origin: {x: 5, y: 9, z: 7},
  aspect: 'all',
},
{
  texture: texture34,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 5});
} catch {}
let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpteRp431', transfer: 'hlg'} });
let commandEncoder145 = device0.createCommandEncoder({});
let renderPassEncoder24 = commandEncoder145.beginRenderPass({
  colorAttachments: [{
  view: textureView85,
  clearValue: { r: 536.4, g: 655.5, b: 522.3, a: -640.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, buffer46, 0, 1_303);
} catch {}
try {
buffer25.unmap();
} catch {}
try {
commandEncoder144.copyTextureToTexture({
  texture: texture150,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture42,
  mipLevel: 0,
  origin: {x: 9, y: 2, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let texture170 = device0.createTexture({
  label: '\u{1f6aa}\u{1f705}\udcfc\u{1fb3d}\u0f0d\u{1fa1c}\ue327\u9751\u635e\u0fea\ud67c',
  size: {width: 210, height: 1, depthOrArrayLayers: 138},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder118 = commandEncoder144.beginComputePass({});
let sampler93 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 57.58,
  lodMaxClamp: 66.97,
  compare: 'always',
});
try {
computePassEncoder118.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer100, 'uint32', 368, 543);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup15);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup63, new Uint32Array(304), 110, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer78, 'uint32', 4_396, 8_854);
} catch {}
try {
renderBundleEncoder12.insertDebugMarker('\u0042');
} catch {}
let bindGroup92 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 221, resource: textureView27},
    {binding: 414, resource: textureView7},
    {binding: 119, resource: {buffer: buffer43, offset: 2816, size: 1136}},
    {binding: 78, resource: textureView57},
    {binding: 116, resource: sampler53},
    {binding: 26, resource: textureView111},
    {binding: 54, resource: externalTexture4},
    {binding: 337, resource: textureView10},
    {binding: 270, resource: textureView142},
    {binding: 667, resource: textureView103},
    {binding: 79, resource: textureView180},
    {binding: 47, resource: externalTexture12},
    {binding: 311, resource: {buffer: buffer40, offset: 4864, size: 697}},
    {binding: 261, resource: {buffer: buffer2, offset: 256}},
    {binding: 141, resource: sampler89},
    {binding: 164, resource: textureView73},
  ],
});
let texture171 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 51},
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView188 = texture101.createView({});
let renderBundle12 = renderBundleEncoder12.finish({});
try {
renderPassEncoder14.setBindGroup(2, bindGroup87, []);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer42, 0, 3_862);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 2, y: 18, z: 0},
  aspect: 'all',
}, new Uint8Array(48).fill(148), /* required buffer size: 48 */
{offset: 48, bytesPerRow: 185}, {width: 2, height: 70, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap2,
  origin: { x: 1, y: 15 },
  flipY: false,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder110.setBindGroup(1, bindGroup78);
} catch {}
try {
computePassEncoder68.setBindGroup(2, bindGroup77, new Uint32Array(1248), 582, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(1, bindGroup42, new Uint32Array(844), 10, 0);
} catch {}
let texture172 = device0.createTexture({
  size: {width: 420},
  dimension: '1d',
  format: 'r8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder4.setBlendConstant({ r: 944.5, g: -64.38, b: -75.75, a: 98.94, });
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer114, 224, 15);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer131 = device0.createBuffer({
  size: 6697,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder146 = device0.createCommandEncoder({label: '\u685a\u512e\u{1fbb7}\u{1f959}\uce94\u1b64\uad3c\u1e74\u{1fc2b}\u0c90\u018c'});
try {
computePassEncoder19.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder19.setStencilReference(355);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(6, buffer115);
} catch {}
try {
buffer65.unmap();
} catch {}
try {
commandEncoder146.copyTextureToBuffer({
  texture: texture109,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 624 widthInBlocks: 39 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 352 */
  offset: 352,
  bytesPerRow: 1024,
  buffer: buffer76,
}, {width: 39, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder147 = device0.createCommandEncoder({});
try {
computePassEncoder17.setBindGroup(1, bindGroup46, new Uint32Array(486), 0, 0);
} catch {}
try {
renderPassEncoder17.setViewport(195.31796245090186, 23.64294723683249, 19.896320803195575, 0.3168435341392639, 0.7639776338840527, 0.8052875851275906);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer43, 'uint32', 7_184, 132);
} catch {}
let promise20 = device0.queue.onSubmittedWorkDone();
let bindGroupLayout22 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let buffer132 = device0.createBuffer({
  label: '\u8fd2\u1263\u0ced\ue129\u27d7\u0875\u{1f813}\u0f52\u{1fa27}',
  size: 1900,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder148 = device0.createCommandEncoder();
let texture173 = device0.createTexture({
  size: [420, 1, 3],
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder16.setBindGroup(3, bindGroup59);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer43, 'uint16', 7_226, 1_333);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder146.copyBufferToTexture({
  /* bytesInLastRow: 96 widthInBlocks: 24 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1128 */
  offset: 1128,
  bytesPerRow: 256,
  buffer: buffer65,
}, {
  texture: texture94,
  mipLevel: 0,
  origin: {x: 4, y: 13, z: 0},
  aspect: 'all',
}, {width: 24, height: 40, depthOrArrayLayers: 0});
} catch {}
let bindGroup93 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView57}]});
let buffer133 = device0.createBuffer({size: 29293, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let computePassEncoder119 = commandEncoder147.beginComputePass({});
try {
device0.queue.writeTexture({
  texture: texture78,
  mipLevel: 0,
  origin: {x: 168, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(153).fill(42), /* required buffer size: 153 */
{offset: 153}, {width: 220, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let bindGroup94 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 453, resource: textureView1},
    {binding: 9, resource: textureView91},
    {binding: 102, resource: textureView87},
  ],
});
let pipelineLayout15 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder149 = device0.createCommandEncoder({label: '\u{1f9f0}\u3d19\u5bc5\u7380\uc049\ue477\ubd39\uc0ef\u023c\u5dc7\uc8f6'});
let texture174 = device0.createTexture({
  label: '\u5522\u1fa6\uc435\ua276\u9430\ua0cd',
  size: {width: 288, height: 96, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView189 = texture23.createView({});
let computePassEncoder120 = commandEncoder148.beginComputePass({});
try {
computePassEncoder44.setBindGroup(2, bindGroup61);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer53, 0, 1_669);
} catch {}
try {
device0.queue.writeBuffer(buffer44, 2280, new Float32Array(23037), 5747, 100);
} catch {}
let commandEncoder150 = device0.createCommandEncoder({});
let renderPassEncoder25 = commandEncoder150.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -465.6, g: 236.5, b: -671.8, a: -486.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder7.setBindGroup(0, bindGroup30);
} catch {}
try {
computePassEncoder119.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle10]);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer96, 'uint32', 620, 740);
} catch {}
document.body.append(img1);
let videoFrame31 = new VideoFrame(offscreenCanvas4, {timestamp: 0});
let texture175 = device0.createTexture({
  size: [9, 16, 1],
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler94 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 42.11,
  lodMaxClamp: 57.06,
  maxAnisotropy: 3,
});
try {
computePassEncoder81.setBindGroup(3, bindGroup83);
} catch {}
try {
computePassEncoder100.setBindGroup(2, bindGroup90, new Uint32Array(3220), 365, 0);
} catch {}
try {
computePassEncoder120.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder17.end();
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer22, 'uint32', 472, 128);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(1, buffer80);
} catch {}
try {
commandEncoder146.copyBufferToBuffer(buffer10, 224, buffer124, 2928, 2980);
} catch {}
try {
device0.queue.writeBuffer(buffer23, 1620, new BigUint64Array(4174), 61, 16);
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
document.body.append(video0);
let canvas4 = document.createElement('canvas');
let commandEncoder151 = device0.createCommandEncoder({});
let querySet24 = device0.createQuerySet({label: '\u{1fc20}\u0004\u{1fe2e}', type: 'occlusion', count: 4096});
let texture176 = device0.createTexture({size: [210, 1, 1], format: 'r16float', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder121 = commandEncoder149.beginComputePass();
let sampler95 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 28.31,
  lodMaxClamp: 86.84,
  compare: 'not-equal',
  maxAnisotropy: 12,
});
let externalTexture24 = device0.importExternalTexture({label: '\u4643\u{1f649}\u90fa\u5a83\u0c12\u{1fb5b}\u7bb0', source: video1});
try {
renderPassEncoder19.setBindGroup(1, bindGroup3, new Uint32Array(249), 45, 0);
} catch {}
try {
commandEncoder151.copyTextureToTexture({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture123,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView190 = texture78.createView({arrayLayerCount: 1});
let computePassEncoder122 = commandEncoder146.beginComputePass({});
try {
renderPassEncoder19.setBindGroup(2, bindGroup34);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup70, new Uint32Array(635), 26, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer42, 'uint32', 5_484, 1_787);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer116, 0, 464);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
commandEncoder151.clearBuffer(buffer13, 144, 0);
} catch {}
let gpuCanvasContext8 = canvas4.getContext('webgpu');
try {
texture33.label = '\uc243\u6909\u0dc9\u1b7a';
} catch {}
let bindGroup95 = device0.createBindGroup({
  layout: bindGroupLayout12,
  entries: [
    {binding: 106, resource: {buffer: buffer14, offset: 768, size: 432}},
    {binding: 74, resource: sampler79},
    {binding: 20, resource: textureView118},
  ],
});
let sampler96 = device0.createSampler({
  label: '\u9dc9\u0ce1\u0127\u461f\u3dcc\u{1face}\u077d\ufa9a\u546e\u{1fb4f}\u56a6',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 99.60,
  lodMaxClamp: 99.88,
});
try {
computePassEncoder21.setBindGroup(2, bindGroup25, new Uint32Array(45), 11, 0);
} catch {}
try {
computePassEncoder122.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup79);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer97, 'uint16', 988, 6_999);
} catch {}
try {
buffer51.unmap();
} catch {}
let bindGroup96 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer64, offset: 7936, size: 1392}}],
});
let buffer134 = device0.createBuffer({
  size: 14004,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder152 = device0.createCommandEncoder();
let computePassEncoder123 = commandEncoder152.beginComputePass({});
let renderPassEncoder26 = commandEncoder151.beginRenderPass({
  colorAttachments: [{
  view: textureView105,
  clearValue: { r: -631.3, g: 952.8, b: -500.3, a: 721.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let externalTexture25 = device0.importExternalTexture({source: videoFrame26});
try {
computePassEncoder66.setBindGroup(0, bindGroup57, new Uint32Array(216), 8, 0);
} catch {}
try {
computePassEncoder99.dispatchWorkgroupsIndirect(buffer26, 460);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle6, renderBundle3]);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer131, 'uint32', 1_856, 587);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(2, buffer46, 0);
} catch {}
try {
gpuCanvasContext8.unconfigure();
} catch {}
try {
  await promise20;
} catch {}
let sampler97 = device0.createSampler({
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 41.56,
  maxAnisotropy: 6,
});
try {
computePassEncoder107.setBindGroup(0, bindGroup88);
} catch {}
try {
computePassEncoder8.setBindGroup(2, bindGroup63, new Uint32Array(1083), 765, 0);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(2, buffer12, 0, 1_906);
} catch {}
let bindGroup97 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 25, resource: {buffer: buffer94, offset: 256, size: 416}}],
});
let textureView191 = texture1.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
renderPassEncoder20.setBindGroup(2, bindGroup71, new Uint32Array(901), 857, 0);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(0, buffer10, 208, 5_704);
} catch {}
try {
buffer37.unmap();
} catch {}
let commandEncoder153 = device0.createCommandEncoder({});
try {
renderPassEncoder22.setIndexBuffer(buffer85, 'uint32', 12_100, 726);
} catch {}
try {
texture67.destroy();
} catch {}
try {
commandEncoder153.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2932 */
  offset: 2932,
  buffer: buffer44,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup98 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [{binding: 116, resource: textureView162}, {binding: 289, resource: textureView71}],
});
let sampler98 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 7.335,
  lodMaxClamp: 29.03,
  compare: 'less-equal',
});
try {
renderPassEncoder26.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder25.end();
} catch {}
try {
renderPassEncoder4.setViewport(47.06050050244736, 80.90712744357477, 127.73354659164896, 12.533838572940057, 0.8841204571024986, 0.941436746530429);
} catch {}
let arrayBuffer16 = buffer53.getMappedRange();
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
let promise22 = device0.queue.onSubmittedWorkDone();
try {
window.someLabel = externalTexture0.label;
} catch {}
let commandEncoder154 = device0.createCommandEncoder({});
let renderPassEncoder27 = commandEncoder153.beginRenderPass({
  colorAttachments: [{
  view: textureView105,
  clearValue: { r: -924.2, g: -679.2, b: -251.8, a: 145.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 35447681,
});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint']});
let renderBundle13 = renderBundleEncoder13.finish();
try {
computePassEncoder61.setBindGroup(2, bindGroup71);
} catch {}
try {
computePassEncoder84.setBindGroup(0, bindGroup33, new Uint32Array(1327), 83, 0);
} catch {}
try {
renderPassEncoder15.pushDebugGroup('\u{1fd7c}');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'astc-5x5-unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['stencil8'],
});
} catch {}
try {
  await promise22;
} catch {}
document.body.prepend(video1);
try {
window.someLabel = pipeline0.label;
} catch {}
let computePassEncoder124 = commandEncoder154.beginComputePass({label: '\u04ae\u{1f953}\u6713\u02ba\u0729\u06a7\u3c9b\ub59c\u0d3c\u718b\u3c02'});
try {
computePassEncoder85.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle7]);
} catch {}
try {
device0.queue.writeBuffer(buffer48, 32, new DataView(new ArrayBuffer(35880)), 2262, 16);
} catch {}
let videoFrame32 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpteRp431', transfer: 'iec6196624'} });
let commandEncoder155 = device0.createCommandEncoder({});
let commandBuffer10 = commandEncoder155.finish({});
try {
computePassEncoder21.setBindGroup(0, bindGroup38, new Uint32Array(953), 87, 0);
} catch {}
try {
computePassEncoder124.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer47, 'uint16', 416, 674);
} catch {}
try {
buffer77.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer13, 212, new DataView(new ArrayBuffer(16243)), 135, 72);
} catch {}
let buffer135 = device0.createBuffer({size: 2923, usage: GPUBufferUsage.STORAGE});
try {
computePassEncoder100.setBindGroup(2, bindGroup42);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer36, 'uint32', 4_488, 174);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(2, buffer75, 324, 1_125);
} catch {}
try {
computePassEncoder82.pushDebugGroup('\ufa23');
} catch {}
await gc();
let texture177 = device0.createTexture({
  size: [840],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder121.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(246);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(7, buffer66, 4_320);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb'],
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer51, 432, new DataView(new ArrayBuffer(36195)), 3068, 2916);
} catch {}
try {
  await adapter1.requestAdapterInfo();
} catch {}
let buffer136 = device0.createBuffer({
  size: 19736,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: true,
});
let textureView192 = texture128.createView({});
try {
computePassEncoder123.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder26.setBindGroup(1, bindGroup29, new Uint32Array(4981), 1_051, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle10, renderBundle10]);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer29, 'uint32', 2_908, 7_749);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.submit([commandBuffer10]);
} catch {}
let promise23 = device0.queue.onSubmittedWorkDone();
try {
  await promise21;
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup90, new Uint32Array(479), 107, 0);
} catch {}
try {
renderPassEncoder27.setScissorRect(0, 0, 0, 1);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer113, 5020, new DataView(new ArrayBuffer(6657)), 465);
} catch {}
document.body.prepend(canvas2);
await gc();
let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt2020', transfer: 'gamma22curve'} });
let commandEncoder156 = device0.createCommandEncoder({});
let textureView193 = texture111.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 15, arrayLayerCount: 1});
let sampler99 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 35.76,
  lodMaxClamp: 53.31,
});
try {
computePassEncoder114.setBindGroup(1, bindGroup49, new Uint32Array(4953), 371, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer35, 84); };
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
let arrayBuffer17 = buffer0.getMappedRange(3128, 456);
try {
buffer36.unmap();
} catch {}
try {
commandEncoder156.copyTextureToBuffer({
  texture: texture149,
  mipLevel: 0,
  origin: {x: 1, y: 6, z: 3},
  aspect: 'all',
}, {
  /* bytesInLastRow: 160 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 50112 */
  offset: 3008,
  bytesPerRow: 256,
  rowsPerImage: 92,
  buffer: buffer97,
}, {width: 10, height: 0, depthOrArrayLayers: 3});
} catch {}
try {
  await promise23;
} catch {}
let canvas5 = document.createElement('canvas');
let bindGroupLayout23 = device0.createBindGroupLayout({
  label: '\u63be\u1d7f\u2fa7\ud0bc\u8f8e\u0ab5',
  entries: [
    {
      binding: 41,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 228,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let bindGroup99 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 25, resource: {buffer: buffer94, offset: 256, size: 148}}],
});
let texture178 = device0.createTexture({
  size: [420, 1, 86],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture179 = device0.createTexture({
  size: {width: 144, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder28 = commandEncoder156.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 955.5, g: 34.11, b: -744.5, a: -487.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder64.setBindGroup(3, bindGroup35);
} catch {}
try {
computePassEncoder97.setBindGroup(0, bindGroup88, new Uint32Array(14), 2, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup35);
} catch {}
let arrayBuffer18 = buffer69.getMappedRange(0, 40);
let textureView194 = texture178.createView({label: '\u{1ff14}\u1775'});
let texture180 = device0.createTexture({
  size: [210, 1, 4],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder121.setBindGroup(1, bindGroup90);
} catch {}
try {
computePassEncoder29.setBindGroup(2, bindGroup99, new Uint32Array(1889), 193, 0);
} catch {}
try {
computePassEncoder72.setPipeline(pipeline0);
} catch {}
let arrayBuffer19 = buffer69.getMappedRange(64, 4);
try {
device0.queue.writeBuffer(buffer117, 112, new DataView(new ArrayBuffer(6416)), 1336, 80);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder157 = device0.createCommandEncoder({label: '\u{1fa39}\u14c8\u{1fc2f}\u0bf1\u025f\u1e3f\u9801\u0772\u6966\u0f59'});
let texture181 = device0.createTexture({size: [32], dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
let renderPassEncoder29 = commandEncoder157.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: 865.5, g: 893.1, b: 72.96, a: 248.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], depthReadOnly: true, stencilReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder29.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder26.executeBundles([renderBundle10, renderBundle3, renderBundle0]);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup46);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup46, new Uint32Array(2187), 136, 0);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer79, 'uint16', 172, 2_229);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture118,
  mipLevel: 0,
  origin: {x: 27, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(104).fill(22), /* required buffer size: 104 */
{offset: 104, bytesPerRow: 82, rowsPerImage: 28}, {width: 6, height: 3, depthOrArrayLayers: 0});
} catch {}
let bindGroup100 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 78, resource: textureView119},
    {binding: 116, resource: sampler22},
    {binding: 141, resource: sampler45},
    {binding: 47, resource: externalTexture22},
    {binding: 261, resource: {buffer: buffer85, offset: 256, size: 1919}},
    {binding: 311, resource: {buffer: buffer106, offset: 0, size: 716}},
    {binding: 119, resource: {buffer: buffer37, offset: 512, size: 405}},
    {binding: 79, resource: textureView180},
    {binding: 414, resource: textureView7},
    {binding: 164, resource: textureView27},
    {binding: 26, resource: textureView121},
    {binding: 221, resource: textureView171},
    {binding: 667, resource: textureView174},
    {binding: 270, resource: textureView108},
    {binding: 54, resource: externalTexture17},
    {binding: 337, resource: textureView162},
  ],
});
try {
renderPassEncoder19.setBindGroup(2, bindGroup28, new Uint32Array(2355), 266, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer92, 'uint16', 832, 65);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(7, buffer29);
} catch {}
let promise24 = device0.queue.onSubmittedWorkDone();
document.body.append(video1);
let shaderModule9 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  @size(16) f0: atomic<u32>,
}
/* target size: 16 max align: 16 */
struct T1 {
  f0: array<T0>,
}
/* target size: 16 max align: 16 */
struct T2 {
  @align(1) @size(16) f0: vec3h,
}
@id(50087) override override46 : u32;
@id(33278) override override44 : f32 = -0.07993;
@id(12436) override override45 : f32 = -0.9724;
override override43 : bool = false;
@id(44939) override override47 : i32 = -79;
@group(0) @binding(20) var st0: texture_storage_3d<rg32uint, read>;
@group(0) @binding(74) var sam5: sampler_comparison;
@group(0) @binding(106) var<storage, read_write> buffer137: array<array<f16, 8>>;

@vertex
fn vertex0(@location(7) @interpolate(flat) a0: i32) -> @builtin(position) vec4f {
  var out: vec4f;
  _ = override46;
  return out;
}
struct FragmentOutput5 {
  @location(0) f0: vec4i,
  @location(3) @interpolate(perspective, centroid) f1: f32,
  @location(2) @interpolate(flat, center) f2: vec4i,
  @location(1) @interpolate(perspective, sample) f3: vec2f
}

@fragment
fn fragment0() -> FragmentOutput5 {
  var out: FragmentOutput5;
  _ = buffer137[arrayLength(&buffer137)];
  _ = buffer137[arrayLength(&buffer137)][0];
  _ = buffer137[arrayLength(&buffer137)][7];
  out.f0 -= vec4i(324, 60, 38, 136);
  return out;
}

@compute @workgroup_size(2, 1, 1)
fn compute0() {
  _ = textureLoad(st0, vec3i());
  _ = override44;
}`,
  sourceMap: {},
  hints: {},
});
let pipelineLayout16 = device0.createPipelineLayout({label: '\u55f1\uc962\u99d5\uecc7\u{1fb38}\u{1fd8a}\u08ef\u{1fff4}\u049a', bindGroupLayouts: []});
let commandEncoder158 = device0.createCommandEncoder({});
let querySet25 = device0.createQuerySet({type: 'occlusion', count: 235});
let texture182 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 13},
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
});
let renderPassEncoder30 = commandEncoder158.beginRenderPass({
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: 584.9, g: -358.4, b: -610.1, a: -868.7, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet12,
});
try {
computePassEncoder56.setBindGroup(1, bindGroup3);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup52, []);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup33);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(7, buffer26, 0);
} catch {}
document.body.append(canvas1);
let texture183 = device0.createTexture({
  label: '\u0aea\u0a74\u{1fd6e}\u7dd4\u92f6\u9ae0\u5edc',
  size: {width: 19, height: 33, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder113.setBindGroup(3, bindGroup99, new Uint32Array(824), 25, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup94, new Uint32Array(254), 19, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(4, buffer40);
} catch {}
try {
  await shaderModule6.getCompilationInfo();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 2, y: 5 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 3, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout24 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 425,
      visibility: 0,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let bindGroup101 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 328, resource: {buffer: buffer60, offset: 1024, size: 4}},
    {binding: 110, resource: sampler86},
    {binding: 145, resource: sampler80},
  ],
});
let texture184 = device0.createTexture({
  label: '\u8cdf\u7e4a\u0380\u9f6b\ud2e5\ue808\u3001\uf442\u64a4\u015d',
  size: {width: 420, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder19.setBindGroup(3, bindGroup78);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer131, 'uint32', 2_320, 665);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer80, 0, 144);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(6, undefined, 0, 49_281_390);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData18,
  origin: { x: 10, y: 1 },
  flipY: false,
}, {
  texture: texture92,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder159 = device0.createCommandEncoder({});
let textureView195 = texture178.createView({arrayLayerCount: 1});
let sampler100 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 73.93,
  lodMaxClamp: 91.85,
  maxAnisotropy: 20,
});
try {
computePassEncoder60.setBindGroup(1, bindGroup20, new Uint32Array(1165), 44, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer11, 'uint32', 140, 1_134);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer1, 'uint32', 11_584, 457);
} catch {}
try {
commandEncoder159.copyBufferToBuffer(buffer79, 520, buffer44, 1768, 336);
} catch {}
try {
commandEncoder159.clearBuffer(buffer47);
} catch {}
document.body.append(video1);
let buffer138 = device0.createBuffer({
  size: 3254,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder160 = device0.createCommandEncoder({});
let textureView196 = texture184.createView({label: '\ue230\u00b3\u25d1\u{1f7d2}', baseMipLevel: 0});
let texture185 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 2},
  dimension: '2d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let texture186 = gpuCanvasContext6.getCurrentTexture();
let renderBundle14 = renderBundleEncoder14.finish({});
try {
computePassEncoder4.setBindGroup(0, bindGroup39, new Uint32Array(627), 243, 0);
} catch {}
try {
renderPassEncoder30.setBindGroup(3, bindGroup101, new Uint32Array(4926), 0, 0);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(1, buffer30);
} catch {}
try {
commandEncoder159.copyBufferToBuffer(buffer40, 4360, buffer109, 5980, 5712);
} catch {}
try {
commandEncoder160.copyTextureToTexture({
  texture: texture184,
  mipLevel: 0,
  origin: {x: 77, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture184,
  mipLevel: 0,
  origin: {x: 68, y: 0, z: 0},
  aspect: 'all',
},
{width: 113, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let gpuCanvasContext9 = canvas5.getContext('webgpu');
let commandEncoder161 = device0.createCommandEncoder({label: '\u0c00\ufa2c\u5959\u01f9\u{1fd0c}\u9a36\u924e\u0f0d\ued4d\uc8f6\u{1f9d7}'});
let texture187 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder125 = commandEncoder160.beginComputePass({});
let sampler101 = device0.createSampler({
  label: '\uce57\u9412\u096a\u07cb\uc170\u{1fc85}\u37df\u9fd4\u062a\ubaef',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 17.20,
  lodMaxClamp: 59.01,
  compare: 'equal',
});
try {
renderPassEncoder14.setBindGroup(3, bindGroup40, new Uint32Array(3042), 299, 0);
} catch {}
try {
renderPassEncoder16.setScissorRect(8, 0, 29, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer107, 'uint16', 82, 9);
} catch {}
try {
commandEncoder159.copyTextureToTexture({
  texture: texture126,
  mipLevel: 0,
  origin: {x: 11, y: 5, z: 1},
  aspect: 'all',
},
{
  texture: texture141,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 71},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise24;
} catch {}
let commandEncoder162 = device0.createCommandEncoder({});
let computePassEncoder126 = commandEncoder162.beginComputePass();
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], stencilReadOnly: false});
let sampler102 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 96.85,
  lodMaxClamp: 97.68,
  maxAnisotropy: 14,
});
try {
computePassEncoder37.setBindGroup(0, bindGroup62, new Uint32Array(3341), 99, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer25, 'uint16', 304, 88);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup84, new Uint32Array(4283), 313, 0);
} catch {}
let textureView197 = texture184.createView({aspect: 'all', format: 'rgba16uint'});
let textureView198 = texture183.createView({});
try {
renderPassEncoder20.setBindGroup(2, bindGroup78);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer87, 'uint16', 14, 36);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer58, 0, 213);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup3);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView199 = texture87.createView({label: '\udb67\u0e2b\u07b8', baseArrayLayer: 0, arrayLayerCount: 2});
let renderPassEncoder31 = commandEncoder159.beginRenderPass({
  label: '\udb91\u5653\u{1fddd}\uce04\u0f3e\ueb14\uab6b\u{1fea9}\u1f56\ud1e2\u{1fb24}',
  colorAttachments: [{view: textureView105, loadOp: 'clear', storeOp: 'discard'}],
  maxDrawCount: 43973807,
});
let sampler103 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 24.09,
  lodMaxClamp: 47.00,
  maxAnisotropy: 20,
});
try {
computePassEncoder125.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup32, new Uint32Array(3229), 117, 0);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer42, 'uint16', 5_046, 6_936);
} catch {}
let commandEncoder163 = device0.createCommandEncoder();
let renderPassEncoder32 = commandEncoder163.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 595.5, g: -143.2, b: -34.94, a: -64.01, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler104 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 98.18,
  lodMaxClamp: 99.82,
  maxAnisotropy: 3,
});
try {
computePassEncoder125.setBindGroup(2, bindGroup88);
} catch {}
try {
computePassEncoder108.setBindGroup(1, bindGroup84, new Uint32Array(996), 17, 0);
} catch {}
try {
computePassEncoder126.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle0, renderBundle10, renderBundle0, renderBundle10]);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(1, buffer105);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup78, new Uint32Array(2773), 224, 0);
} catch {}
try {
buffer39.unmap();
} catch {}
let commandEncoder164 = device0.createCommandEncoder();
let renderPassEncoder33 = commandEncoder164.beginRenderPass({
  colorAttachments: [{
  view: textureView17,
  clearValue: { r: 897.9, g: -40.55, b: -40.39, a: -807.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 32799858,
});
let sampler105 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 67.99,
  lodMaxClamp: 72.76,
  maxAnisotropy: 11,
});
let externalTexture26 = device0.importExternalTexture({source: video1});
try {
renderPassEncoder26.setIndexBuffer(buffer60, 'uint32', 780, 3_027);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup24);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup37, new Uint32Array(291), 35, 0);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer71, 'uint16', 154, 745);
} catch {}
let textureView200 = texture120.createView({});
let sampler106 = device0.createSampler({
  label: '\u{1ff5c}\u02b5',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 3.205,
  maxAnisotropy: 13,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup79);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer58, 240); };
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup26, []);
} catch {}
try {
renderPassEncoder32.setViewport(28.395063783221712, 5.517277703627549, 0.8887703635322591, 5.184867805672467, 0.18213853822757708, 0.8402802146688493);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(3, buffer26, 0, 234);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline2);
} catch {}
try {
buffer70.unmap();
} catch {}
try {
commandEncoder161.resolveQuerySet(querySet2, 229, 60, buffer86, 1024);
} catch {}
document.body.prepend(img1);
let bindGroup102 = device0.createBindGroup({
  label: '\u0576\u01b7\u{1f825}',
  layout: bindGroupLayout14,
  entries: [
    {binding: 23, resource: textureView57},
    {binding: 505, resource: {buffer: buffer78, offset: 2560, size: 6119}},
    {binding: 4, resource: textureView9},
    {binding: 69, resource: textureView198},
  ],
});
let texture188 = device0.createTexture({
  label: '\u{1fed4}\u{1f8dd}',
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder50.setBindGroup(0, bindGroup9, new Uint32Array(540), 20, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer58, 96, 1);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup37, new Uint32Array(231), 3, 0);
} catch {}
let arrayBuffer20 = buffer15.getMappedRange(0, 4);
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer21, 4552, new BigUint64Array(6974), 2403, 16);
} catch {}
let commandEncoder165 = device0.createCommandEncoder({label: '\u{1f963}\u7824\u4dee\u08a7\u{1faee}\u92a3\u{1fbf7}'});
let querySet26 = device0.createQuerySet({type: 'occlusion', count: 118});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer14, 420); };
} catch {}
try {
computePassEncoder102.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder27.setBindGroup(1, bindGroup26);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(5, buffer74, 0, 2_378);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture166,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 10},
  aspect: 'all',
}, new Uint8Array(354).fill(240), /* required buffer size: 354 */
{offset: 354, bytesPerRow: 0, rowsPerImage: 18}, {width: 0, height: 0, depthOrArrayLayers: 12});
} catch {}
let commandBuffer11 = commandEncoder165.finish();
let texture189 = device0.createTexture({
  size: [32, 32, 16],
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView201 = texture188.createView({label: '\uea10\u0ece\u{1fb4e}\ufc2b\u2c88\u{1fa99}\u8272\u9042'});
let computePassEncoder127 = commandEncoder161.beginComputePass({label: '\u0899\u09e7\u{1f86d}\u0279\uad6d\u9c6a'});
let renderBundle15 = renderBundleEncoder15.finish({});
let sampler107 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 27.56,
  lodMaxClamp: 81.19,
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer57, 192); };
} catch {}
try {
computePassEncoder127.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder32.setBindGroup(1, bindGroup90);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer24, 'uint32', 156, 291);
} catch {}
let pipeline4 = device0.createComputePipeline({layout: pipelineLayout4, compute: {module: shaderModule8, entryPoint: 'compute0'}});
let commandEncoder166 = device0.createCommandEncoder();
let sampler108 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 21.06,
  lodMaxClamp: 83.60,
  compare: 'less',
  maxAnisotropy: 1,
});
try {
computePassEncoder108.setBindGroup(0, bindGroup95);
} catch {}
try {
computePassEncoder105.setBindGroup(3, bindGroup45, new Uint32Array(2796), 347, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup70, new Uint32Array(3256), 303, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer69, 212, 558);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 306, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(75).fill(134), /* required buffer size: 75 */
{offset: 75}, {width: 31, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); };
} catch {}
let bindGroup103 = device0.createBindGroup({
  label: '\u02f5\u01a0\u5120\u90a0\u{1fbda}\u9397\u{1fc11}\u0723',
  layout: bindGroupLayout14,
  entries: [
    {binding: 4, resource: textureView162},
    {binding: 505, resource: {buffer: buffer12, offset: 5888}},
    {binding: 69, resource: textureView20},
    {binding: 23, resource: textureView197},
  ],
});
let texture190 = device0.createTexture({
  size: [105, 1, 91],
  mipLevelCount: 4,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView202 = texture43.createView({dimension: '2d-array', format: 'r8unorm', arrayLayerCount: 1});
try {
computePassEncoder43.setBindGroup(0, bindGroup36, new Uint32Array(721), 140, 0);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer26, 'uint16', 1_976, 745);
} catch {}
try {
gpuCanvasContext5.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
let imageData19 = new ImageData(4, 64);
let computePassEncoder128 = commandEncoder166.beginComputePass({});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], depthReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder30.setBindGroup(0, bindGroup73);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup1);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer104, 'uint16', 2_874, 415);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(2, buffer26, 1_172);
} catch {}
let arrayBuffer21 = buffer45.getMappedRange(0, 32);
let texture191 = device0.createTexture({size: [288, 96, 175], dimension: '3d', format: 'r8snorm', usage: GPUTextureUsage.TEXTURE_BINDING});
let sampler109 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 13.89,
  lodMaxClamp: 71.14,
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup52);
} catch {}
try {
renderPassEncoder29.setBindGroup(3, bindGroup47, new Uint32Array(4995), 1_469, 0);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(13);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer120, 'uint32', 252, 5_743);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer20, 'uint16', 56, 100);
} catch {}
try {
renderPassEncoder15.popDebugGroup();
} catch {}
try {
renderBundleEncoder16.insertDebugMarker('\u0b8c');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let bindGroup104 = device0.createBindGroup({
  label: '\uf9ad\u{1ffda}\u56f4\u{1f79d}\u07f3\u8d27\uc18d\u1c28\u{1f6f2}\uf161',
  layout: bindGroupLayout15,
  entries: [{binding: 80, resource: textureView149}, {binding: 133, resource: textureView59}],
});
let buffer139 = device0.createBuffer({
  size: 17791,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let textureView203 = texture36.createView({dimension: '2d-array', aspect: 'depth-only'});
try {
computePassEncoder98.setBindGroup(0, bindGroup98);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle10, renderBundle10, renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer2, 0, 4_031);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup34, new Uint32Array(2733), 362, 0);
} catch {}
try {
computePassEncoder23.popDebugGroup();
} catch {}
try {
device0.queue.submit([commandBuffer11]);
} catch {}
let imageBitmap5 = await createImageBitmap(imageData3);
let textureView204 = texture21.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 0});
let renderBundle16 = renderBundleEncoder16.finish({});
try {
computePassEncoder68.setBindGroup(3, bindGroup97);
} catch {}
try {
computePassEncoder128.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup55);
} catch {}
let shaderModule10 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  @align(2) @size(16) f0: vec2f,
}
/* target size: 16 max align: 16 */
struct T1 {
  @size(16) f0: array<atomic<i32>>,
}
override override50 : bool;
override override48 : i32 = 477;
override override49 : bool = false;
@id(26683) override override51 : bool;
@id(43440) override override52 : bool;
@id(11956) override override53 : i32 = 329;
@group(0) @binding(106) var<storage, read_write> buffer140: array<vec4u, 1>;
@group(0) @binding(74) var sam6: sampler_comparison;
@group(0) @binding(20) var st1: texture_storage_2d_array<r32sint, read>;
struct S2 {
  @location(8) @interpolate(flat, center) f0: vec2u,
  @builtin(vertex_index) f1: u32,
  @location(12) @interpolate(perspective) f2: vec3f
}
struct S3 {
  @location(13) @interpolate(linear) f0: f32,
  @location(6) f1: f32,
  @builtin(instance_index) f2: u32,
  @location(14) @interpolate(perspective) f3: vec3h
}
struct S4 {
  @location(4) f0: u32,
  @location(11) f1: vec2f
}
struct VertexOutput6 {
  @builtin(position) f18: vec4f
}

@vertex
fn vertex0(@location(5) @interpolate(flat, centroid) a0: vec3i, @location(15) @interpolate(perspective, centroid) a1: vec3h, @location(2) a2: vec4u, a3: S2, a4: S3, a5: S4) -> VertexOutput6 {
  var out: VertexOutput6;
  _ = a4.f0;
  _ = a5.f0;
  _ = override52;
  return out;
}
struct FragmentOutput6 {
  @location(6) f0: vec2i,
  @location(0) f1: f32
}

@fragment
fn fragment0() -> FragmentOutput6 {
  var out: FragmentOutput6;
  _ = override52;
  return out;
}

@compute @workgroup_size(2, 2, 1)
fn compute0() {
}`,
  sourceMap: {},
  hints: {},
});
let pipelineLayout17 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder167 = device0.createCommandEncoder({});
let textureView205 = texture37.createView({baseMipLevel: 0});
let sampler110 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 37.78,
  lodMaxClamp: 76.52,
  maxAnisotropy: 1,
});
try {
computePassEncoder30.setBindGroup(2, bindGroup45);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup93, new Uint32Array(246), 179, 0);
} catch {}
try {
renderPassEncoder26.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder21.setScissorRect(199, 0, 35, 0);
} catch {}
try {
commandEncoder167.resolveQuerySet(querySet9, 5, 42, buffer120, 256);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 34}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 87, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder168 = device0.createCommandEncoder();
let textureView206 = texture138.createView({baseMipLevel: 0});
let computePassEncoder129 = commandEncoder167.beginComputePass({});
let renderPassEncoder34 = commandEncoder168.beginRenderPass({
  colorAttachments: [{
  view: textureView101,
  depthSlice: 67,
  clearValue: { r: 791.5, g: -660.9, b: -811.0, a: 777.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet4,
});
let sampler111 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 97.26,
  lodMaxClamp: 98.47,
  maxAnisotropy: 12,
});
let externalTexture27 = device0.importExternalTexture({label: '\u{1f650}\ucb6e\u{1ff9f}\u01f0\u5c43\u{1fe5e}\u0cfa', source: videoFrame15});
try {
computePassEncoder112.setBindGroup(0, bindGroup72, new Uint32Array(2504), 53, 0);
} catch {}
try {
computePassEncoder129.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(199);
} catch {}
document.body.append(canvas0);
let imageBitmap6 = await createImageBitmap(imageData8);
let texture192 = gpuCanvasContext7.getCurrentTexture();
try {
computePassEncoder120.setBindGroup(1, bindGroup44);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder33.executeBundles([renderBundle7, renderBundle0, renderBundle0, renderBundle7]);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(6, buffer80, 0, 601);
} catch {}
try {
computePassEncoder82.popDebugGroup();
} catch {}
try {
computePassEncoder88.insertDebugMarker('\u{1fc1d}');
} catch {}
try {
device0.queue.writeBuffer(buffer18, 1960, new DataView(new ArrayBuffer(21221)), 1384, 160);
} catch {}
document.body.prepend(img2);
let bindGroupLayout25 = device0.createBindGroupLayout({
  label: '\u008f\u0a19\u{1f61d}\u64c3\uba93\u1b3b\u93b5\u06ea\u0613\u4ee0',
  entries: [
    {
      binding: 171,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 129,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 252,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let texture193 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture28 = device0.importExternalTexture({source: video1, colorSpace: 'display-p3'});
try {
renderPassEncoder26.executeBundles([renderBundle10]);
} catch {}
try {
renderPassEncoder26.setStencilReference(601);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer37, 'uint16', 94, 8);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer64, 5_996, 4_049);
} catch {}
let promise25 = device0.queue.onSubmittedWorkDone();
let buffer141 = device0.createBuffer({
  size: 12604,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
try {
renderPassEncoder16.setBindGroup(3, bindGroup44);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder24.setScissorRect(2, 0, 1, 2);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer78, 'uint16', 8_194, 5_071);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(6, buffer74, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
renderPassEncoder21.insertDebugMarker('\udd03');
} catch {}
let videoFrame34 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte170m', transfer: 'bt2020_12bit'} });
let sampler112 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', minFilter: 'nearest', lodMinClamp: 2.525});
try {
computePassEncoder21.setBindGroup(3, bindGroup35);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let commandEncoder169 = device0.createCommandEncoder({});
let computePassEncoder130 = commandEncoder169.beginComputePass({label: '\u0859\u1d8b\ue708\u{1fde9}\u877e\u0255\u{1f9ca}\u09ab\u{1fcf4}\u5009\u{1ff9e}'});
let sampler113 = device0.createSampler({
  label: '\u{1f76a}\ud8ec',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 13.85,
  lodMaxClamp: 57.48,
});
try {
renderPassEncoder22.setBindGroup(1, bindGroup36, new Uint32Array(4941), 2_366, 0);
} catch {}
try {
renderPassEncoder28.setScissorRect(2, 0, 0, 0);
} catch {}
let buffer142 = device0.createBuffer({
  size: 4005,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let textureView207 = texture174.createView({label: '\uc6c5\u2b65\u052c\ud38a\u63a0\u0c79\u7749\ubbe9', dimension: '2d-array'});
let sampler114 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 79.83,
  lodMaxClamp: 97.01,
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder130.setPipeline(pipeline4);
} catch {}
let arrayBuffer22 = buffer67.getMappedRange(4056, 480);
try {
device0.queue.writeBuffer(buffer26, 600, new Int16Array(4492), 91, 516);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.append(canvas1);
let buffer143 = device0.createBuffer({size: 7287, usage: GPUBufferUsage.COPY_DST});
let commandEncoder170 = device0.createCommandEncoder({label: '\u{1f9a0}\u2f10\u018f\u0529'});
let texture194 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder24.setBindGroup(3, bindGroup43, new Uint32Array(592), 120, 0);
} catch {}
try {
renderPassEncoder31.setBindGroup(0, bindGroup58, []);
} catch {}
try {
renderPassEncoder26.setBindGroup(3, bindGroup46, new Uint32Array(4422), 822, 0);
} catch {}
try {
  await promise25;
} catch {}
document.body.append(video1);
let buffer144 = device0.createBuffer({
  label: '\ue41f\u16a7\u{1f60b}\u8dc5\u05b9\u{1ff7a}',
  size: 10768,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: true,
});
let computePassEncoder131 = commandEncoder170.beginComputePass();
let sampler115 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.04,
  compare: 'less-equal',
  maxAnisotropy: 11,
});
try {
computePassEncoder131.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture142,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(73).fill(101), /* required buffer size: 73 */
{offset: 73, rowsPerImage: 1}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let videoFrame35 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte432', transfer: 'logSqrt'} });
let textureView208 = texture18.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer28, 268); };
} catch {}
try {
renderPassEncoder28.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer118);
} catch {}
let arrayBuffer23 = buffer0.getMappedRange(3720, 84);
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let querySet27 = device0.createQuerySet({type: 'occlusion', count: 300});
let textureView209 = texture38.createView({});
try {
renderPassEncoder20.setBindGroup(0, bindGroup72);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer97, 'uint16', 40_886, 945);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder171 = device0.createCommandEncoder({label: '\u{1feb3}\u88fc\u0274\ue63c\u{1f6fb}\u8289'});
let texture195 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder132 = commandEncoder171.beginComputePass();
try {
computePassEncoder53.setBindGroup(3, bindGroup42, new Uint32Array(1813), 146, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer115);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer106, 904, new DataView(new ArrayBuffer(1340)), 173, 220);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); };
} catch {}
let buffer145 = device0.createBuffer({
  size: 24641,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder172 = device0.createCommandEncoder();
let computePassEncoder133 = commandEncoder172.beginComputePass({});
try {
computePassEncoder95.setBindGroup(1, bindGroup10);
} catch {}
try {
computePassEncoder22.setBindGroup(0, bindGroup2, new Uint32Array(1629), 198, 0);
} catch {}
try {
computePassEncoder132.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer144, 'uint16', 2_778, 1_019);
} catch {}
try {
renderPassEncoder29.setBindGroup(0, bindGroup18, new Uint32Array(3152), 1, 0);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(3, buffer113, 0, 1_798);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame15,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
video0.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], sampleCount: 1, depthReadOnly: true});
let renderBundle17 = renderBundleEncoder17.finish({label: '\u6e95\u{1fa12}\u{1fe76}\u25d5\ud4c7\u3c71'});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder133.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder19.setViewport(126.65771002894598, 35.56056488560273, 110.87879263763162, 40.38019828719665, 0.7316473569707227, 0.9417533799349925);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer2, 0);
} catch {}
let commandEncoder173 = device0.createCommandEncoder({});
let textureView210 = texture156.createView({dimension: '3d', baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder23.executeBundles([renderBundle17]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer122, 'uint32', 1_228, 1_344);
} catch {}
try {
commandEncoder173.clearBuffer(buffer53);
} catch {}
let bindGroupLayout26 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 42,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let texture196 = device0.createTexture({
  size: [19],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder98.setBindGroup(0, bindGroup80);
} catch {}
try {
computePassEncoder46.setBindGroup(1, bindGroup2, new Uint32Array(93), 2, 0);
} catch {}
try {
renderPassEncoder30.insertDebugMarker('\u095c');
} catch {}
try {
device0.queue.writeBuffer(buffer46, 12, new DataView(new ArrayBuffer(4088)), 1280, 392);
} catch {}
let bindGroup105 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [{binding: 277, resource: textureView135}, {binding: 86, resource: sampler63}],
});
try {
computePassEncoder64.setBindGroup(3, bindGroup75);
} catch {}
try {
computePassEncoder131.setBindGroup(1, bindGroup102, new Uint32Array(6700), 2_916, 0);
} catch {}
try {
computePassEncoder64.dispatchWorkgroupsIndirect(buffer141, 892);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup80);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer79, 'uint16', 486, 368);
} catch {}
try {
commandEncoder173.clearBuffer(buffer9);
} catch {}
let bindGroup106 = device0.createBindGroup({
  label: '\u0c71\u2a61\ua0d1\u{1f7b4}',
  layout: bindGroupLayout15,
  entries: [{binding: 80, resource: textureView192}, {binding: 133, resource: textureView73}],
});
let buffer146 = device0.createBuffer({size: 6534, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
try {
renderPassEncoder15.setBindGroup(2, bindGroup84, new Uint32Array(3303), 787, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer47, 'uint32', 2_812, 161);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(2, buffer141, 12_604, 0);
} catch {}
let textureView211 = texture188.createView({label: '\u4c87\u2350\ub7af\u71a2\uad43\uda60\udc29\udb6d\u{1fb94}\u7d82', aspect: 'all'});
let texture197 = device0.createTexture({
  size: [840, 1, 37],
  mipLevelCount: 3,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder90.setBindGroup(3, bindGroup22, new Uint32Array(1825), 1_256, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(6, buffer11, 0, 2_891);
} catch {}
let buffer147 = device0.createBuffer({
  size: 18334,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let sampler116 = device0.createSampler({
  label: '\ua591\ufa83\u{1fd91}\u{1f73b}\u9044\u7d15\ubb93\u{1fb44}\u2c17\u0c78',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 59.23,
  lodMaxClamp: 63.48,
});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer35, 620); };
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup5, new Uint32Array(710), 19, 0);
} catch {}
try {
renderPassEncoder20.setViewport(13.633808481061115, 0.40916056898844966, 5.280620952705514, 3.1715281873378864, 0.22942011166625753, 0.4202738525304257);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer42, 1_500, 3_785);
} catch {}
let promise26 = adapter1.requestAdapterInfo();
let bindGroup107 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 4, resource: textureView196},
    {binding: 505, resource: {buffer: buffer51, offset: 0}},
    {binding: 69, resource: textureView115},
    {binding: 23, resource: textureView162},
  ],
});
let texture198 = device0.createTexture({
  size: [105, 1, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let imageBitmap7 = await createImageBitmap(videoFrame31);
let commandEncoder174 = device0.createCommandEncoder({});
let textureView212 = texture34.createView({mipLevelCount: 1});
let computePassEncoder134 = commandEncoder174.beginComputePass({});
try {
renderPassEncoder16.setBindGroup(3, bindGroup94, new Uint32Array(73), 0, 0);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(2, buffer131);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture166,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(107).fill(143), /* required buffer size: 107 */
{offset: 107, bytesPerRow: 0, rowsPerImage: 101}, {width: 0, height: 0, depthOrArrayLayers: 18});
} catch {}
let texture199 = device0.createTexture({
  label: '\u69b0\u0166\u0aaa\u07e0\u565a\u0684\u0a66\u{1fba3}\u{1fad1}',
  size: {width: 36},
  sampleCount: 1,
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder135 = commandEncoder173.beginComputePass({});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true});
let renderBundle18 = renderBundleEncoder18.finish({});
let sampler117 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 71.49,
  lodMaxClamp: 76.40,
  maxAnisotropy: 3,
});
try {
computePassEncoder119.setBindGroup(3, bindGroup45);
} catch {}
let commandEncoder175 = device0.createCommandEncoder({});
let textureView213 = texture120.createView({});
let sampler118 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 8.441,
  lodMaxClamp: 77.27,
  compare: 'never',
});
try {
renderPassEncoder31.setViewport(5.488811135637981, 12.252656496694803, 1.993843873249116, 2.2203646488600524, 0.6051729686907882, 0.7790139819523901);
} catch {}
try {
buffer76.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer80, 672, new DataView(new ArrayBuffer(65536)), 34410, 532);
} catch {}
let bindGroup108 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 408, resource: {buffer: buffer93, offset: 0, size: 3530}},
    {binding: 27, resource: textureView168},
    {binding: 50, resource: textureView68},
  ],
});
let commandEncoder176 = device0.createCommandEncoder({label: '\u5ab5\ue92f\ue8ed\u{1fe83}\u0de9\u1184\u0fc6'});
let texture200 = device0.createTexture({
  label: '\u027c\u6701\u0cc1\u1008\u6c56\u{1ff5c}',
  size: {width: 78, height: 132, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder136 = commandEncoder175.beginComputePass({});
let renderPassEncoder35 = commandEncoder176.beginRenderPass({
  colorAttachments: [{
  view: textureView105,
  clearValue: { r: 972.6, g: -45.10, b: -701.0, a: 484.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder35.setBindGroup(0, bindGroup82);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
let commandEncoder177 = device0.createCommandEncoder();
let texture201 = device0.createTexture({
  label: '\u08b9\u{1fe9a}\uc98f',
  size: [210, 1, 46],
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder62.setBindGroup(0, bindGroup79);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageData16,
  origin: { x: 4, y: 0 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 3, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup109 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer145, offset: 1280, size: 3344}}],
});
let buffer148 = device0.createBuffer({size: 20285, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture202 = device0.createTexture({
  size: {width: 420},
  sampleCount: 1,
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder48.setBindGroup(2, bindGroup10, new Uint32Array(63), 11, 0);
} catch {}
try {
renderPassEncoder24.setBindGroup(1, bindGroup70);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 1, depthOrArrayLayers: 1}
*/
{
  source: video0,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture99,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder178 = device0.createCommandEncoder({});
let texture203 = device0.createTexture({
  size: [72],
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture204 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder93.setBindGroup(3, bindGroup58);
} catch {}
try {
computePassEncoder46.setBindGroup(1, bindGroup2, new Uint32Array(22), 12, 0);
} catch {}
try {
computePassEncoder135.setPipeline(pipeline1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: video1,
  origin: { x: 1, y: 1 },
  flipY: false,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 5, depthOrArrayLayers: 0});
} catch {}
let buffer149 = device0.createBuffer({
  size: 8495,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let texture205 = device0.createTexture({
  size: {width: 19, height: 33, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder35.setBindGroup(3, bindGroup43, new Uint32Array(2439), 220, 0);
} catch {}
try {
computePassEncoder134.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup1, new Uint32Array(87), 44, 0);
} catch {}
let bindGroupLayout27 = device0.createBindGroupLayout({
  label: '\u0386\uf0e5\u0eb7\u{1fa7b}\u02a9\ufa1e\u{1fd59}\u7eea\u286a',
  entries: [
    {
      binding: 313,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer150 = device0.createBuffer({
  label: '\u0960\uaf66\ue34e\u04e7\uf7e1\ub121\u9323',
  size: 10637,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder179 = device0.createCommandEncoder({label: '\uf58e\ud57c\u769d\u0e6f\uab57\u0845\u{1fa5b}'});
let textureView214 = texture126.createView({label: '\u3c52\u349a\uf36e\u5772\uce71\u{1fb25}\u06b4', mipLevelCount: 1});
let computePassEncoder137 = commandEncoder179.beginComputePass({});
let renderPassEncoder36 = commandEncoder178.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -904.3, g: 592.0, b: -28.04, a: -353.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 57863527,
});
try {
computePassEncoder110.setBindGroup(2, bindGroup65, new Uint32Array(290), 223, 0);
} catch {}
try {
computePassEncoder137.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder33.setViewport(43.6733825342419, 2.405975429741595, 68.94925438940425, 86.1452250341313, 0.8307452149076376, 0.8611262995454085);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(6, buffer60, 124, 115);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 10196, new Float32Array(19309), 6543, 436);
} catch {}
let commandEncoder180 = device0.createCommandEncoder({});
let texture206 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture29 = device0.importExternalTexture({source: video1});
try {
computePassEncoder111.setBindGroup(2, bindGroup9, new Uint32Array(2366), 82, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder136.setPipeline(pipeline0);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture95,
  mipLevel: 1,
  origin: {x: 0, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(264).fill(216), /* required buffer size: 264 */
{offset: 264, bytesPerRow: 79}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture207 = device0.createTexture({
  size: {width: 288},
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder75.setBindGroup(2, bindGroup88, new Uint32Array(2424), 134, 0);
} catch {}
try {
buffer55.unmap();
} catch {}
try {
commandEncoder177.clearBuffer(buffer138, 116, 1188);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let texture208 = device0.createTexture({
  size: [210, 1, 234],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView215 = texture116.createView({baseMipLevel: 0});
let computePassEncoder138 = commandEncoder180.beginComputePass();
try {
computePassEncoder120.setBindGroup(2, bindGroup104);
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup98, new Uint32Array(1505), 17, 0);
} catch {}
try {
commandEncoder177.copyBufferToBuffer(buffer44, 860, buffer41, 4380, 1156);
} catch {}
let computePassEncoder139 = commandEncoder177.beginComputePass({});
try {
computePassEncoder9.setBindGroup(3, bindGroup57);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder114.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder138.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder20.setBindGroup(1, bindGroup78);
} catch {}
try {
renderPassEncoder35.setBindGroup(2, bindGroup18, new Uint32Array(5368), 457, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer96, 'uint32', 916, 442);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(2, buffer107, 0, 156);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 34}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 205, y: 0, z: 13},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView216 = texture161.createView({mipLevelCount: 1});
try {
renderPassEncoder4.executeBundles([renderBundle6]);
} catch {}
try {
buffer94.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer105, 24, new Int16Array(6426), 218, 312);
} catch {}
let commandEncoder181 = device0.createCommandEncoder({});
let textureView217 = texture128.createView({aspect: 'depth-only', baseArrayLayer: 0});
let computePassEncoder140 = commandEncoder181.beginComputePass({});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], sampleCount: 1, stencilReadOnly: true});
let sampler119 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 47.05,
  lodMaxClamp: 61.04,
  compare: 'never',
});
try {
computePassEncoder24.setBindGroup(1, bindGroup84);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer94, 16); };
} catch {}
try {
computePassEncoder139.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup73);
} catch {}
try {
renderPassEncoder32.executeBundles([renderBundle0, renderBundle7, renderBundle7, renderBundle0, renderBundle0]);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup42);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let commandEncoder182 = device0.createCommandEncoder();
let texture209 = device0.createTexture({
  size: [144, 48, 1],
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder37 = commandEncoder182.beginRenderPass({
  colorAttachments: [{
  view: textureView24,
  clearValue: { r: 192.0, g: 275.3, b: -762.1, a: -956.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 143698949,
});
let renderBundle19 = renderBundleEncoder19.finish({});
let sampler120 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 64.31,
  lodMaxClamp: 99.77,
  compare: 'less-equal',
});
try {
computePassEncoder91.setBindGroup(0, bindGroup73, new Uint32Array(2047), 488, 0);
} catch {}
try {
computePassEncoder140.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder30.setBindGroup(1, bindGroup42);
} catch {}
try {
renderPassEncoder31.executeBundles([renderBundle5]);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let videoFrame36 = new VideoFrame(videoFrame10, {timestamp: 0});
let commandEncoder183 = device0.createCommandEncoder({label: '\u13fe\u0800\u{1fa23}\uada5\uca1f\ue7e9\u91d3\u09ae\ud1db'});
try {
computePassEncoder15.setBindGroup(3, bindGroup80);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup0);
} catch {}
let canvas6 = document.createElement('canvas');
let imageData20 = new ImageData(32, 28);
let commandEncoder184 = device0.createCommandEncoder({});
let textureView218 = texture42.createView({label: '\u038b\u0521'});
let computePassEncoder141 = commandEncoder184.beginComputePass();
try {
commandEncoder183.copyTextureToTexture({
  texture: texture206,
  mipLevel: 0,
  origin: {x: 4, y: 7, z: 0},
  aspect: 'all',
},
{
  texture: texture201,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 4, height: 8, depthOrArrayLayers: 1}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture175,
  mipLevel: 1,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer151 = device0.createBuffer({
  size: 870,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder142 = commandEncoder183.beginComputePass({});
try {
computePassEncoder12.setBindGroup(1, bindGroup96, new Uint32Array(578), 263, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer35, 680); };
} catch {}
try {
computePassEncoder141.setPipeline(pipeline1);
} catch {}
try {
buffer51.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture99,
  mipLevel: 1,
  origin: {x: 78, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(231).fill(99), /* required buffer size: 231 */
{offset: 231}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 78, height: 132, depthOrArrayLayers: 31}
*/
{
  source: videoFrame29,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture93,
  mipLevel: 0,
  origin: {x: 13, y: 2, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise26;
} catch {}
let commandEncoder185 = device0.createCommandEncoder();
let textureView219 = texture122.createView({mipLevelCount: 1});
let computePassEncoder143 = commandEncoder185.beginComputePass({});
try {
computePassEncoder31.setBindGroup(3, bindGroup43, []);
} catch {}
try {
computePassEncoder142.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder31.setBindGroup(0, bindGroup18, new Uint32Array(399), 52, 0);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle17]);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer1, 'uint16', 1_932, 61);
} catch {}
let arrayBuffer24 = buffer15.getMappedRange(8, 4);
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame37 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'film', transfer: 'bt1361ExtendedColourGamut'} });
let bindGroupLayout28 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 55,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'float', multisampled: false },
    },
  ],
});
let textureView220 = texture175.createView({
  label: '\u8c68\u3058\u{1f653}\u2e6b\u3cd2\ubb60\u{1f8c8}\uc4fa\u{1f712}\u44a3\u{1f983}',
  dimension: '2d-array',
  mipLevelCount: 1,
});
try {
renderPassEncoder19.setViewport(107.22153040915413, 64.89496993810603, 73.59245531208488, 14.61937084325243, 0.6570186759998555, 0.7619500962457058);
} catch {}
try {
computePassEncoder96.setBindGroup(1, bindGroup102, new Uint32Array(371), 43, 0);
} catch {}
try {
computePassEncoder143.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(3, buffer107);
} catch {}
let textureView221 = texture21.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder94.setBindGroup(1, bindGroup93);
} catch {}
try {
computePassEncoder100.setBindGroup(3, bindGroup13, new Uint32Array(1250), 200, 0);
} catch {}
try {
computePassEncoder64.dispatchWorkgroups(1);
} catch {}
let buffer152 = device0.createBuffer({size: 13041, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder186 = device0.createCommandEncoder({});
let textureView222 = texture64.createView({dimension: 'cube', baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder144 = commandEncoder186.beginComputePass({});
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer149, 548, new BigUint64Array(11712), 1161, 952);
} catch {}
document.body.prepend(canvas2);
try {
computePassEncoder144.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder20.setBindGroup(0, bindGroup108);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer85, 'uint16', 1_492, 3_434);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture94,
  mipLevel: 0,
  origin: {x: 44, y: 27, z: 0},
  aspect: 'all',
}, new Uint8Array(407).fill(25), /* required buffer size: 407 */
{offset: 407, bytesPerRow: 171, rowsPerImage: 48}, {width: 27, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let img3 = await imageWithData(44, 47, '#10101010', '#20202020');
try {
  await adapter0.requestAdapterInfo();
} catch {}
let buffer153 = device0.createBuffer({
  label: '\u8e8b\u0e79\ud316\u0fec\u{1fe6b}',
  size: 1693,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let texture210 = device0.createTexture({
  size: {width: 19, height: 33, depthOrArrayLayers: 1},
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST,
});
let sampler121 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 35.35,
  lodMaxClamp: 81.63,
});
try {
renderPassEncoder34.setBindGroup(1, bindGroup107);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer59, 'uint16', 3_478, 6_887);
} catch {}
try {
renderBundleEncoder20.setBindGroup(0, bindGroup81);
} catch {}
let texture211 = device0.createTexture({
  size: [9],
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView223 = texture141.createView({});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], stencilReadOnly: true});
try {
computePassEncoder64.dispatchWorkgroupsIndirect(buffer83, 4_736);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(5, buffer84, 0, 143);
} catch {}
document.body.prepend(canvas0);
let buffer154 = device0.createBuffer({
  label: '\u56c5\ue44e',
  size: 2430,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder187 = device0.createCommandEncoder({});
let computePassEncoder145 = commandEncoder187.beginComputePass({label: '\ubcf3\u085c'});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], stencilReadOnly: false});
try {
computePassEncoder114.setBindGroup(3, bindGroup38);
} catch {}
try {
computePassEncoder145.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup25, []);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer20, 'uint32', 168, 15);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup35);
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup91, new Uint32Array(1206), 440, 0);
} catch {}
let renderBundleEncoder23 = device0.createRenderBundleEncoder({label: '\u{1fd89}\u0908\ub930\u0d29\u0b1e\u8d2d\u0133', colorFormats: ['r16float', 'rg16sint']});
try {
computePassEncoder77.setBindGroup(0, bindGroup105);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 78, height: 132, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 15, y: 8 },
  flipY: false,
}, {
  texture: texture115,
  mipLevel: 0,
  origin: {x: 12, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 10, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas5);
let canvas7 = document.createElement('canvas');
let buffer155 = device0.createBuffer({size: 13789, usage: GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let texture212 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView224 = texture78.createView({label: '\uabfc\u{1fc77}\u3873\udc42', dimension: '1d'});
let sampler122 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 15.26,
  lodMaxClamp: 25.31,
});
try {
renderBundleEncoder22.setBindGroup(0, bindGroup81);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
renderBundleEncoder22.insertDebugMarker('\u0e8e');
} catch {}
let buffer156 = device0.createBuffer({
  size: 29268,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture213 = device0.createTexture({
  size: {width: 144},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle20 = renderBundleEncoder21.finish({});
try {
computePassEncoder128.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(76);
} catch {}
try {
renderPassEncoder30.setBlendConstant({ r: 582.6, g: -415.0, b: 578.0, a: 445.2, });
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer122, 'uint16', 388, 114);
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup76, new Uint32Array(3900), 2_525, 0);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer142, 'uint16', 532, 462);
} catch {}
try {
buffer33.unmap();
} catch {}
let buffer157 = device0.createBuffer({
  size: 4660,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder188 = device0.createCommandEncoder({});
let textureView225 = texture64.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 1});
let textureView226 = texture188.createView({mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder146 = commandEncoder188.beginComputePass({});
try {
computePassEncoder146.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder20.setBindGroup(3, bindGroup90, new Uint32Array(383), 140, 0);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(7, buffer78, 4_400, 7_225);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let commandEncoder189 = device0.createCommandEncoder();
let sampler123 = device0.createSampler({
  label: '\u{1f8cb}\u000e\u4178',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 37.97,
  compare: 'never',
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(2, 3); };
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup22, new Uint32Array(4815), 1_673, 0);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(6, buffer134);
} catch {}
let commandEncoder190 = device0.createCommandEncoder({});
let sampler124 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  lodMinClamp: 22.38,
  lodMaxClamp: 35.52,
});
try {
computePassEncoder133.setBindGroup(3, bindGroup78, new Uint32Array(5823), 115, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer136, 3_504); };
} catch {}
try {
renderPassEncoder29.beginOcclusionQuery(15);
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup102, new Uint32Array(6525), 69, 0);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(5, buffer80, 40, 1_557);
} catch {}
let arrayBuffer25 = buffer112.getMappedRange(96, 12);
try {
commandEncoder189.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1104 */
  offset: 1104,
  bytesPerRow: 256,
  rowsPerImage: 92,
  buffer: buffer33,
}, {
  texture: texture18,
  mipLevel: 1,
  origin: {x: 3, y: 18, z: 0},
  aspect: 'all',
}, {width: 15, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder189.resolveQuerySet(querySet4, 55, 5, buffer87, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup110 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 50, resource: textureView84},
    {binding: 408, resource: {buffer: buffer120, offset: 1024}},
    {binding: 27, resource: textureView168},
  ],
});
let buffer158 = device0.createBuffer({size: 630, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture214 = device0.createTexture({
  size: [144],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder147 = commandEncoder190.beginComputePass({});
try {
computePassEncoder19.setBindGroup(3, bindGroup8, new Uint32Array(1016), 186, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(0, buffer2);
} catch {}
try {
commandEncoder189.copyBufferToBuffer(buffer94, 660, buffer35, 224, 44);
} catch {}
let renderBundle21 = renderBundleEncoder22.finish({});
try {
computePassEncoder147.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder26.setBindGroup(1, bindGroup57);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup82, new Uint32Array(3252), 224, 0);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(5, buffer115, 0, 3_347);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(0, buffer48, 0);
} catch {}
let texture215 = device0.createTexture({
  label: '\ud6b0\u857b\u962f',
  size: {width: 19},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let renderPassEncoder38 = commandEncoder189.beginRenderPass({
  colorAttachments: [{
  view: textureView202,
  clearValue: { r: -61.35, g: 312.9, b: -70.41, a: 682.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let renderBundle22 = renderBundleEncoder23.finish({});
try {
renderBundleEncoder20.setIndexBuffer(buffer104, 'uint32', 1_404, 4_288);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture84,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(240).fill(251), /* required buffer size: 240 */
{offset: 240, bytesPerRow: 16}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
textureView43.label = '\u5f40\uacab\udb58\u{1f762}\uaef0\u{1fc6c}\u0c32\uf4b9';
} catch {}
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], depthReadOnly: false, stencilReadOnly: true});
let renderBundle23 = renderBundleEncoder20.finish({});
let sampler125 = device0.createSampler({
  label: '\u{1fe5e}\u059d\u427d\u{1f849}\uefbb\u{1f885}',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 7.974,
  lodMaxClamp: 84.11,
});
let externalTexture30 = device0.importExternalTexture({source: video1});
try {
computePassEncoder129.setBindGroup(3, bindGroup100, new Uint32Array(3943), 508, 0);
} catch {}
try {
renderPassEncoder33.setBindGroup(2, bindGroup24);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer109, 'uint32', 1_156, 1_939);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer96, 'uint16', 900, 526);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(7, buffer132, 0, 28);
} catch {}
let texture216 = device0.createTexture({size: [105, 1, 52], format: 'rg8snorm', usage: GPUTextureUsage.COPY_DST});
try {
renderBundleEncoder24.setBindGroup(1, bindGroup19, new Uint32Array(758), 197, 0);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(1, buffer78, 0);
} catch {}
document.body.prepend(canvas4);
let renderBundle24 = renderBundleEncoder24.finish({label: '\u8fb0\uefd6\u17b7\u0959\u41f5\u060f\ud943'});
let commandEncoder191 = device0.createCommandEncoder({label: '\u9980\uad05\u3a15\uc77e\u0b1d\u6888'});
let texture217 = device0.createTexture({
  size: [78],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler126 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 48.60,
  lodMaxClamp: 92.74,
  maxAnisotropy: 12,
});
try {
computePassEncoder116.setBindGroup(1, bindGroup104, new Uint32Array(310), 15, 0);
} catch {}
try {
computePassEncoder71.end();
} catch {}
try {
computePassEncoder99.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder29.endOcclusionQuery();
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 10080 */
  offset: 4704,
  bytesPerRow: 1792,
  buffer: buffer21,
}, {
  texture: texture65,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 4},
  aspect: 'all',
}, {width: 0, height: 4, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeBuffer(buffer103, 192, new DataView(new ArrayBuffer(5376)), 384, 48);
} catch {}
let buffer159 = device0.createBuffer({
  label: '\u{1f8c2}\ub3a6\u30f3\u{1fad3}\ua4fc\u8847\uee68\u{1ff06}\ud1a0\ufbbd',
  size: 1307,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder192 = device0.createCommandEncoder({label: '\u0927\u{1fa04}\u{1fd8c}\ufc51\u0fd5'});
let texture218 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 144},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder16.setVertexBuffer(4, buffer75, 536, 1_934);
} catch {}
try {
buffer42.unmap();
} catch {}
let shaderModule11 = device0.createShaderModule({
  label: '\u276d\u9526\u{1fd50}\u0464\u{1f98a}\u7b4b\u1fed\ued68\u{1fe05}\u94d2',
  code: `
enable f16;
/* target size: 8 max align: 8 */
struct T0 {
  @align(2) @size(8) f0: atomic<i32>,
}
@group(0) @binding(100) var tex6: texture_3d<f32>;
@group(0) @binding(191) var tex5: texture_2d<f32>;
struct S5 {
  @builtin(vertex_index) f0: u32,
  @location(6) f1: vec4h,
  @location(3) @interpolate(perspective, centroid) f2: vec2f,
  @location(12) f3: vec4u
}
struct VertexOutput7 {
  @builtin(position) f19: vec4f,
  @location(1) @interpolate(flat, sample) f20: i32
}

@vertex
fn vertex0(@location(5) @interpolate(flat, centroid) a0: f32, @location(15) @interpolate(flat, sample) a1: vec3i, @location(14) @interpolate(flat) a2: vec4u, a3: S5, @location(8) a4: u32, @location(11) @interpolate(perspective) a5: vec4f, @location(2) a6: vec3h, @location(1) @interpolate(linear, center) a7: vec4h, @location(4) a8: vec3f) -> VertexOutput7 {
  var out: VertexOutput7;
  _ = a3.f0;
  return out;
}
struct S6 {
  @location(13) f0: vec3u,
  @location(2) f1: vec2f
}
struct VertexOutput8 {
  @builtin(position) f21: vec4f
}

@vertex
fn vertex1(a0: S6) -> VertexOutput8 {
  var out: VertexOutput8;
  return out;
}

@compute @workgroup_size(1, 2, 1)
fn compute0() {
}`,
  sourceMap: {},
});
let textureView227 = texture150.createView({baseMipLevel: 0});
let texture219 = device0.createTexture({size: [36, 12, 5], dimension: '3d', format: 'r8unorm', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder148 = commandEncoder192.beginComputePass();
try {
computePassEncoder142.setBindGroup(0, bindGroup73, new Uint32Array(2850), 359, 0);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
let bindGroup111 = device0.createBindGroup({
  label: '\uac76\uabf1\u6f0d\u0938\udf52\ufed1',
  layout: bindGroupLayout23,
  entries: [{binding: 41, resource: textureView194}, {binding: 228, resource: textureView85}],
});
let buffer160 = device0.createBuffer({
  size: 11800,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: true,
});
let commandEncoder193 = device0.createCommandEncoder({});
try {
computePassEncoder103.setBindGroup(2, bindGroup17);
} catch {}
try {
computePassEncoder37.setBindGroup(1, bindGroup18, new Uint32Array(641), 40, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup96, []);
} catch {}
try {
device0.queue.writeBuffer(buffer149, 900, new Int16Array(1822), 240, 260);
} catch {}
document.body.append(video1);
let imageData21 = new ImageData(20, 56);
let textureView228 = texture159.createView({baseArrayLayer: 0});
try {
computePassEncoder148.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup67);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer116);
} catch {}
let arrayBuffer26 = buffer81.getMappedRange(0, 280);
try {
commandEncoder191.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3352 */
  offset: 3352,
  buffer: buffer65,
}, {
  texture: texture92,
  mipLevel: 0,
  origin: {x: 19, y: 1, z: 0},
  aspect: 'all',
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer147, 9768, new DataView(new ArrayBuffer(24150)), 1053, 2264);
} catch {}
let buffer161 = device0.createBuffer({
  size: 41200,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let computePassEncoder149 = commandEncoder193.beginComputePass({});
try {
computePassEncoder59.end();
} catch {}
try {
commandEncoder73.clearBuffer(buffer157);
} catch {}
document.body.append(img3);
try {
textureView90.label = '\u6f91\u{1f635}\ub75b\u0623\u797c\u{1fd71}\u0166\u{1fb76}\ua514\u8ebf';
} catch {}
let buffer162 = device0.createBuffer({
  size: 11512,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder194 = device0.createCommandEncoder({});
try {
computePassEncoder149.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer79, 'uint32', 836, 3_172);
} catch {}
let commandBuffer12 = commandEncoder194.finish({label: '\u{1ff64}\u2186\u0ef9\u{1ff87}\u8d40\u0a43\ue4d6'});
let textureView229 = texture32.createView({});
let computePassEncoder150 = commandEncoder73.beginComputePass();
try {
computePassEncoder150.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup46);
} catch {}
try {
commandEncoder34.copyBufferToBuffer(buffer52, 8800, buffer25, 304, 720);
} catch {}
try {
device0.queue.submit([commandBuffer12]);
} catch {}
let shaderModule12 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 143 max align: 1 */
struct T0 {
  @align(1) @size(29) f0: array<vec3f, 1>,
  @align(1) f1: array<f32, 1>,
  @align(1) @size(110) f2: array<mat2x2h>,
}
/* target size: 143 max align: 1 */
struct T1 {
  @align(1) @size(29) f0: mat2x4h,
  @align(1) @size(114) f1: array<i32>,
}
/* target size: 50 max align: 2 */
struct T2 {
  @size(50) f0: array<f16>,
}
/* target size: 143 max align: 1 */
struct T3 {
  @align(1) f0: atomic<u32>,
  @align(1) @size(8) f1: array<array<array<array<f32, 1>, 1>, 1>, 1>,
  @align(1) @size(131) f2: array<vec2f>,
}
@id(9339) override override55 : bool;
override override54 : bool;
override override56 : f16;
override override57 : u32;
@group(0) @binding(172) var sam7: sampler;
@group(0) @binding(228) var<storage, read_write> buffer163: T0;
@group(1) @binding(18) var tex7: texture_cube_array<u32>;
struct FragmentOutput7 {
  @location(3) f0: u32,
  @location(0) f1: vec2f
}

@fragment
fn fragment0() -> FragmentOutput7 {
  var out: FragmentOutput7;
  _ = override54;
  _ = buffer163.f1[0];
  _ = buffer163.f0[0];
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(local_invocation_id) a0: vec3u) {
  if override55 {
    return;
  }
}`,
  sourceMap: {},
  hints: {},
});
let computePassEncoder151 = commandEncoder34.beginComputePass();
let renderPassEncoder39 = commandEncoder191.beginRenderPass({
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: 788.1, g: -665.7, b: -632.1, a: -209.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder151.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer60, 'uint32', 1_132, 1_608);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let imageData22 = new ImageData(8, 116);
let bindGroup112 = device0.createBindGroup({
  label: '\u{1f6ef}\u33af\u7989\ue754\u{1fb45}',
  layout: bindGroupLayout10,
  entries: [
    {binding: 270, resource: textureView108},
    {binding: 261, resource: {buffer: buffer39, offset: 512, size: 505}},
    {binding: 26, resource: textureView121},
    {binding: 414, resource: textureView7},
    {binding: 337, resource: textureView10},
    {binding: 221, resource: textureView181},
    {binding: 164, resource: textureView142},
    {binding: 54, resource: externalTexture25},
    {binding: 141, resource: sampler20},
    {binding: 667, resource: textureView103},
    {binding: 116, resource: sampler4},
    {binding: 311, resource: {buffer: buffer153, offset: 0, size: 433}},
    {binding: 47, resource: externalTexture7},
    {binding: 79, resource: textureView180},
    {binding: 119, resource: {buffer: buffer25, offset: 256, size: 166}},
    {binding: 78, resource: textureView146},
  ],
});
let commandEncoder195 = device0.createCommandEncoder();
let textureView230 = texture16.createView({dimension: '1d'});
try {
computePassEncoder85.setBindGroup(1, bindGroup107);
} catch {}
try {
renderPassEncoder20.setStencilReference(240);
} catch {}
try {
renderPassEncoder39.setViewport(89.3930175858228, 0.1591850396810851, 70.41628089262768, 0.3380721896752406, 0.156912667950457, 0.22270229395678387);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(6, buffer138, 0, 1_719);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
document.body.append(canvas5);
let bindGroup113 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 23, resource: textureView10},
    {binding: 4, resource: textureView196},
    {binding: 69, resource: textureView138},
    {binding: 505, resource: {buffer: buffer79, offset: 256, size: 168}},
  ],
});
let computePassEncoder152 = commandEncoder195.beginComputePass({});
try {
computePassEncoder142.setBindGroup(1, bindGroup80);
} catch {}
try {
computePassEncoder107.setBindGroup(0, bindGroup36, new Uint32Array(1446), 111, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer106, 16); };
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup78, new Uint32Array(509), 53, 0);
} catch {}
try {
renderPassEncoder22.setViewport(467.49683090944376, 0.20162089058224053, 294.70254762351726, 0.25490165254851144, 0.019653781416737903, 0.9061846291313254);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(6, buffer34);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture204,
  mipLevel: 0,
  origin: {x: 27, y: 8, z: 0},
  aspect: 'all',
}, new Uint8Array(32).fill(11), /* required buffer size: 32 */
{offset: 32, bytesPerRow: 15}, {width: 2, height: 24, depthOrArrayLayers: 0});
} catch {}
let promise27 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas1,
  origin: { x: 27, y: 6 },
  flipY: true,
}, {
  texture: texture175,
  mipLevel: 0,
  origin: {x: 3, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder196 = device0.createCommandEncoder({});
let texture220 = device0.createTexture({
  size: [32, 32, 48],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView231 = texture219.createView({arrayLayerCount: 1});
let computePassEncoder153 = commandEncoder196.beginComputePass({label: '\u{1fc72}\u{1fc50}'});
try {
computePassEncoder43.setBindGroup(1, bindGroup37);
} catch {}
try {
computePassEncoder67.setBindGroup(2, bindGroup15, new Uint32Array(368), 137, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer157, 248); };
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer107, 'uint32', 968, 43);
} catch {}
try {
buffer27.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 4, height: 8, depthOrArrayLayers: 1}
*/
{
  source: canvas3,
  origin: { x: 129, y: 58 },
  flipY: false,
}, {
  texture: texture175,
  mipLevel: 1,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup114 = device0.createBindGroup({
  layout: bindGroupLayout12,
  entries: [
    {binding: 20, resource: textureView118},
    {binding: 106, resource: {buffer: buffer114, offset: 256, size: 100}},
    {binding: 74, resource: sampler52},
  ],
});
let commandEncoder197 = device0.createCommandEncoder({});
let texture221 = device0.createTexture({
  size: {width: 36, height: 12, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture222 = device0.createTexture({size: {width: 420}, dimension: '1d', format: 'rgba32sint', usage: GPUTextureUsage.STORAGE_BINDING});
try {
computePassEncoder152.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle7, renderBundle23, renderBundle21, renderBundle5]);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer43, 'uint16', 4_530, 1_476);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 6, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(161).fill(167), /* required buffer size: 161 */
{offset: 161, bytesPerRow: 4}, {width: 2, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageData9,
  origin: { x: 14, y: 3 },
  flipY: true,
}, {
  texture: texture175,
  mipLevel: 0,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 4, depthOrArrayLayers: 0});
} catch {}
let bindGroup115 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 79, resource: textureView113},
    {binding: 116, resource: sampler100},
    {binding: 78, resource: textureView57},
    {binding: 164, resource: textureView181},
    {binding: 414, resource: textureView7},
    {binding: 26, resource: textureView121},
    {binding: 54, resource: externalTexture27},
    {binding: 667, resource: textureView136},
    {binding: 261, resource: {buffer: buffer53, offset: 4096}},
    {binding: 270, resource: textureView108},
    {binding: 337, resource: textureView69},
    {binding: 47, resource: externalTexture30},
    {binding: 221, resource: textureView181},
    {binding: 141, resource: sampler43},
    {binding: 311, resource: {buffer: buffer12, offset: 4096, size: 840}},
    {binding: 119, resource: {buffer: buffer156, offset: 9472, size: 172}},
  ],
});
let textureView232 = texture63.createView({mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder154 = commandEncoder197.beginComputePass({label: '\uc21e\u4028\u0ec3\u{1fadc}\u{1fd85}\u049a\u3e07\u05a8'});
try {
computePassEncoder153.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder28.setBindGroup(1, bindGroup38, new Uint32Array(551), 89, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer64, 'uint32', 6_656, 611);
} catch {}
try {
buffer17.unmap();
} catch {}
video1.width = 11;
let bindGroup116 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [{binding: 191, resource: textureView218}, {binding: 100, resource: textureView8}],
});
let textureView233 = texture216.createView({label: '\udef4\u551d\uf4f5\u0c7b\ue16a\u00f6\u084f\u{1ff96}', dimension: '2d', baseArrayLayer: 17});
try {
computePassEncoder9.setBindGroup(1, bindGroup15, new Uint32Array(328), 36, 0);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle6, renderBundle21, renderBundle20, renderBundle20, renderBundle3, renderBundle6]);
} catch {}
let pipeline5 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule3, constants: {8_882: 1}}});
try {
  await promise27;
} catch {}
let commandEncoder198 = device0.createCommandEncoder({label: '\u{1f845}\u4b5e\ub547\uce49\u39c4\u72c0'});
let textureView234 = texture219.createView({});
let computePassEncoder155 = commandEncoder198.beginComputePass({});
try {
buffer81.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 73, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(1).fill(153), /* required buffer size: 1 */
{offset: 1, rowsPerImage: 97}, {width: 65, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout18 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture223 = device0.createTexture({
  size: [72],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView235 = texture37.createView({dimension: '2d-array', aspect: 'all'});
try {
computePassEncoder155.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder33.setScissorRect(54, 16, 10, 4);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let promise28 = device0.queue.onSubmittedWorkDone();
let texture224 = gpuCanvasContext3.getCurrentTexture();
let textureView236 = texture80.createView({baseArrayLayer: 0});
let sampler127 = device0.createSampler({
  label: '\u{1fabc}\u{1fc0a}\uadfb\u{1fb23}\u4d30',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 35.88,
  lodMaxClamp: 48.34,
  maxAnisotropy: 7,
});
try {
computePassEncoder154.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup42, new Uint32Array(402), 133, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext10 = canvas7.getContext('webgpu');
try {
window.someLabel = externalTexture30.label;
} catch {}
let commandEncoder199 = device0.createCommandEncoder({});
let externalTexture31 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'srgb'});
try {
computePassEncoder39.setBindGroup(0, bindGroup25);
} catch {}
try {
computePassEncoder118.setBindGroup(2, bindGroup102, new Uint32Array(5525), 2_133, 0);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(6, buffer60, 536, 1_041);
} catch {}
try {
  await adapter1.requestAdapterInfo();
} catch {}
let bindGroupLayout29 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 263,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 77, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 197,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 216,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 530,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 19,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 522,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 528,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 202,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 24,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 41,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
  ],
});
let buffer164 = device0.createBuffer({
  size: 1593,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture225 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture226 = device0.createTexture({
  label: '\uf01a\u559d',
  size: [288, 96, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32sint'],
});
let textureView237 = texture4.createView({baseMipLevel: 0});
try {
renderPassEncoder29.setBindGroup(3, bindGroup47);
} catch {}
try {
renderPassEncoder35.end();
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer5, 'uint32', 2_392, 50);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(4, buffer44);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let texture227 = device0.createTexture({
  label: '\u4585\u{1ff66}\ub482\ud6b6\ua50e\ue5ea\u08a1\ubd29\u{1f663}\uae94',
  size: {width: 78, height: 132, depthOrArrayLayers: 57},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView238 = texture88.createView({});
let computePassEncoder156 = commandEncoder199.beginComputePass({});
let sampler128 = device0.createSampler({
  label: '\u{1f9b2}\uce3f\ud80e',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 67.34,
  lodMaxClamp: 94.92,
});
try {
computePassEncoder63.setBindGroup(3, bindGroup80, new Uint32Array(1526), 106, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let buffer165 = device0.createBuffer({
  size: 118,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView239 = texture227.createView({label: '\u0d13\ue934\uc24c'});
let texture228 = device0.createTexture({
  size: [32],
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder104.setBindGroup(3, bindGroup46, new Uint32Array(926), 61, 0);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder38.setBindGroup(3, bindGroup55, new Uint32Array(2457), 521, 0);
} catch {}
let buffer166 = device0.createBuffer({
  size: 7132,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder200 = device0.createCommandEncoder();
let textureView240 = texture225.createView({});
let computePassEncoder157 = commandEncoder200.beginComputePass({});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true});
let sampler129 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 81.89,
  compare: 'equal',
});
try {
computePassEncoder12.setBindGroup(0, bindGroup112);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(1, buffer74, 0, 1_525);
} catch {}
try {
renderBundleEncoder25.setBindGroup(2, bindGroup107);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer118, 'uint32', 304, 911);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(4, buffer150, 0, 1_306);
} catch {}
try {
buffer156.unmap();
} catch {}
let gpuCanvasContext11 = canvas6.getContext('webgpu');
try {
  await promise28;
} catch {}
let canvas8 = document.createElement('canvas');
let texture229 = device0.createTexture({
  label: '\u1ddf\u{1feb0}\u1fd5\uc59e\u{1f638}\ud996\u8241\u302b\u242b\u84fe\u{1fe37}',
  size: [420, 1, 104],
  mipLevelCount: 2,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView241 = texture148.createView({mipLevelCount: 2});
let renderBundle25 = renderBundleEncoder25.finish({});
try {
computePassEncoder156.setPipeline(pipeline0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder201 = device0.createCommandEncoder({});
try {
computePassEncoder145.setBindGroup(3, bindGroup43, new Uint32Array(4125), 315, 0);
} catch {}
try {
renderPassEncoder39.setBindGroup(2, bindGroup28);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer42, 'uint16', 1_382, 2_265);
} catch {}
let videoFrame38 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpteSt4281', transfer: 'hlg'} });
try {
window.someLabel = externalTexture27.label;
} catch {}
let sampler130 = device0.createSampler({
  label: '\u{1f99c}\u{1f93c}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.81,
  maxAnisotropy: 9,
});
try {
computePassEncoder25.setBindGroup(2, bindGroup9, []);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(2, buffer55, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let computePassEncoder158 = commandEncoder201.beginComputePass({});
try {
renderPassEncoder14.setVertexBuffer(4, buffer165, 0, 36);
} catch {}
let bindGroupLayout30 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 176,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let sampler131 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 37.96,
  lodMaxClamp: 61.82,
  maxAnisotropy: 2,
});
try {
computePassEncoder142.setBindGroup(1, bindGroup89, new Uint32Array(698), 345, 0);
} catch {}
try {
computePassEncoder158.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup18, new Uint32Array(2137), 639, 0);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(4, buffer103);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 96, depthOrArrayLayers: 1}
*/
{
  source: canvas5,
  origin: { x: 10, y: 5 },
  flipY: true,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 11, y: 13, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 214, height: 17, depthOrArrayLayers: 0});
} catch {}
let img4 = await imageWithData(105, 48, '#10101010', '#20202020');
let bindGroup117 = device0.createBindGroup({layout: bindGroupLayout19, entries: [{binding: 25, resource: {buffer: buffer125, offset: 6144}}]});
let buffer167 = device0.createBuffer({
  label: '\u0434\u000f\u8992\ueed3',
  size: 9520,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder202 = device0.createCommandEncoder({});
let computePassEncoder159 = commandEncoder202.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer26, 1_744); };
} catch {}
let promise29 = device0.queue.onSubmittedWorkDone();
let commandEncoder203 = device0.createCommandEncoder({});
let computePassEncoder160 = commandEncoder203.beginComputePass({});
try {
computePassEncoder159.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup29);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer87, 'uint16', 86, 13);
} catch {}
try {
externalTexture24.label = '\u{1f888}\u{1f869}\u{1fb54}\ucc6d\u07e7';
} catch {}
let commandEncoder204 = device0.createCommandEncoder();
try {
computePassEncoder160.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(3, buffer44, 0);
} catch {}
try {
commandEncoder204.copyTextureToBuffer({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 304 */
  offset: 304,
  bytesPerRow: 512,
  buffer: buffer35,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true});
try {
computePassEncoder157.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder21.setBlendConstant({ r: -222.4, g: 732.5, b: -80.61, a: -930.2, });
} catch {}
try {
renderBundleEncoder26.setBindGroup(2, bindGroup111);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer97, 'uint32', 24_784, 2_671);
} catch {}
try {
commandEncoder204.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2342 */
  offset: 2342,
  bytesPerRow: 256,
  buffer: buffer4,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 8, y: 3, z: 0},
  aspect: 'all',
}, {width: 2, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 1,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(263).fill(161), /* required buffer size: 263 */
{offset: 263, rowsPerImage: 30}, {width: 37, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap1,
  origin: { x: 0, y: 3 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let commandEncoder205 = device0.createCommandEncoder({});
try {
computePassEncoder13.setBindGroup(2, bindGroup28);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup39);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(6, buffer116, 0, 321);
} catch {}
let shaderModule13 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  @align(1) @size(16) f0: array<atomic<u32>>,
}
/* target size: 16 max align: 16 */
struct T1 {
  f0: T0,
}
/* target size: 16 max align: 16 */
struct T2 {
  @size(16) f0: array<atomic<i32>>,
}
@id(35903) override override59 : u32;
@id(41542) override override62 : f16 = -994.1;
override override60 : f32 = -0.9100;
@id(54280) override override63 : f16;
override override58 : f32;
override override64 : f16;
@id(34357) override override61 : f16;
@group(0) @binding(74) var sam8: sampler_comparison;
@group(0) @binding(106) var<storage, read_write> buffer168: array<array<atomic<u32>, 2>, 2>;
@group(0) @binding(20) var st2: texture_storage_3d<rg32uint, read>;
struct VertexOutput9 {
  @builtin(position) f22: vec4f,
  @location(14) f23: vec2f,
  @location(13) f24: u32
}

@vertex
fn vertex0(@location(5) @interpolate(flat, sample) a0: vec2u, @location(1) @interpolate(flat, centroid) a1: vec3f, @location(3) a2: vec2f, @location(12) @interpolate(flat) a3: i32) -> VertexOutput9 {
  var out: VertexOutput9;
  _ = textureLoad(st2, vec3i());
  if bool(a3) {
    out.f24 += u32(a0[1]);
  }
  return out;
}
struct FragmentOutput8 {
  @location(1) @interpolate(flat) f0: vec4i,
  @location(4) f1: vec3i,
  @location(0) f2: vec3f
}

@fragment
fn fragment0() -> FragmentOutput8 {
  var out: FragmentOutput8;
  _ = buffer168[0];
  _ = buffer168;
  out.f2 *= vec3f(0.00889, 0.02742, 0.07282);
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(local_invocation_index) a0: u32) {
  _ = override63;
  _ = a0;
  _ = override58;
}`,
  sourceMap: {},
});
let commandEncoder206 = device0.createCommandEncoder();
let computePassEncoder161 = commandEncoder206.beginComputePass({});
let renderBundle26 = renderBundleEncoder26.finish({});
let externalTexture32 = device0.importExternalTexture({source: videoFrame30});
try {
computePassEncoder45.setBindGroup(0, bindGroup75);
} catch {}
try {
computePassEncoder161.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup68, new Uint32Array(729), 42, 0);
} catch {}
try {
renderPassEncoder30.setViewport(7.1960401356553225, 0.8904427122634261, 4.1016761475564385, 0.036027197841559694, 0.5680454027253866, 0.807417700649781);
} catch {}
let buffer169 = device0.createBuffer({
  size: 7390,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder162 = commandEncoder205.beginComputePass({});
try {
computePassEncoder20.setBindGroup(3, bindGroup54);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup58, new Uint32Array(5334), 137, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(486);
} catch {}
try {
device0.queue.writeBuffer(buffer117, 0, new BigUint64Array(2515), 112, 8);
} catch {}
document.body.prepend(img0);
let computePassEncoder163 = commandEncoder204.beginComputePass({});
try {
computePassEncoder45.setBindGroup(0, bindGroup55, []);
} catch {}
try {
computePassEncoder10.setBindGroup(1, bindGroup93, new Uint32Array(4379), 305, 0);
} catch {}
try {
computePassEncoder162.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer117, 'uint32', 96, 50);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(6, buffer13, 108, 98);
} catch {}
try {
window.someLabel = device0.label;
} catch {}
let bindGroup118 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 145, resource: sampler50},
    {binding: 110, resource: sampler84},
    {binding: 328, resource: {buffer: buffer75, offset: 512, size: 1410}},
  ],
});
let buffer170 = device0.createBuffer({
  size: 2387,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder207 = device0.createCommandEncoder({});
let computePassEncoder164 = commandEncoder207.beginComputePass({});
try {
computePassEncoder42.setBindGroup(1, bindGroup36, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer149, 208); };
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup108);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let texture230 = device0.createTexture({
  label: '\u0224\u0c5e\u85ae\u555a\u{1fcc8}',
  size: [78, 132, 176],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder164.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup78);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer13, 'uint32', 196, 112);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(3, buffer47, 0, 183);
} catch {}
try {
device0.queue.writeBuffer(buffer152, 696, new Float32Array(19722), 1904, 16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 3, y: 21, z: 0},
  aspect: 'all',
}, new Uint8Array(74).fill(57), /* required buffer size: 74 */
{offset: 74, bytesPerRow: 162}, {width: 8, height: 18, depthOrArrayLayers: 0});
} catch {}
let videoFrame39 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'linear'} });
let buffer171 = device0.createBuffer({size: 11065, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture231 = device0.createTexture({
  size: [39, 66, 609],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder37.dispatchWorkgroups(1);
} catch {}
try {
device0.queue.writeBuffer(buffer124, 2032, new Int16Array(1891), 941, 16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture112,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(59).fill(19), /* required buffer size: 59 */
{offset: 59, bytesPerRow: 3}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let externalTexture33 = device0.importExternalTexture({
  label: '\u3477\u{1fd04}\u{1f7d0}\u9b7c\uaf23\u5da5\u{1f823}\u414c\u5185\u3a8c',
  source: video0,
  colorSpace: 'display-p3',
});
try {
computePassEncoder12.setBindGroup(3, bindGroup6, new Uint32Array(115), 1, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(1, bindGroup114);
} catch {}
try {
renderPassEncoder32.setBindGroup(3, bindGroup73, new Uint32Array(1119), 483, 0);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle21, renderBundle20]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext12 = canvas8.getContext('webgpu');
try {
  await promise29;
} catch {}
let bindGroup119 = device0.createBindGroup({
  layout: bindGroupLayout30,
  entries: [{binding: 176, resource: {buffer: buffer5, offset: 0, size: 256}}],
});
let sampler132 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMaxClamp: 60.35,
});
try {
computePassEncoder163.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder39.setBindGroup(1, bindGroup76);
} catch {}
try {
device0.queue.writeBuffer(buffer39, 84, new BigUint64Array(5382), 258, 44);
} catch {}
try {
adapter0.label = '\ufe0f\u0377\u0f2b\ud6b1\u01b0\u{1fa96}\u8a03\u{1fb02}';
} catch {}
let sampler133 = device0.createSampler({
  label: '\uf539\u{1ff9c}\u{1fa67}\u84bb\u{1f676}\u0306',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 17.38,
  lodMaxClamp: 28.42,
  maxAnisotropy: 1,
});
try {
renderPassEncoder33.setBindGroup(0, bindGroup102);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder31.setVertexBuffer(7, buffer145, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer131, 260, new Float32Array(22183), 1046, 152);
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); };
} catch {}
let img5 = await imageWithData(9, 27, '#10101010', '#20202020');
let videoFrame40 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'logSqrt'} });
let bindGroupLayout31 = device0.createBindGroupLayout({
  label: '\u93ef\u{1f9fa}\u197d\u063c\u0aa6\u06d0\u2090\u76b9',
  entries: [
    {
      binding: 9,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 80,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '1d' },
    },
  ],
});
let textureView242 = texture143.createView({aspect: 'all'});
try {
renderPassEncoder28.insertDebugMarker('\u54a0');
} catch {}
let texture232 = device0.createTexture({
  size: [105, 1, 1],
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder16.setBindGroup(3, bindGroup14);
} catch {}
try {
renderPassEncoder29.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder21.setViewport(653.0066104208192, 0.8953196690558822, 80.08667784799164, 0.06619770096919897, 0.7191634329976737, 0.9555179495667723);
} catch {}
let textureView243 = texture225.createView({});
let sampler134 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 35.94,
  lodMaxClamp: 85.16,
});
try {
computePassEncoder72.setBindGroup(1, bindGroup43, new Uint32Array(2088), 177, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer30, 16, new BigUint64Array(1893), 137, 4);
} catch {}
try {
computePassEncoder68.setPipeline(pipeline4);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer44, 5044, new Float32Array(27684), 2185, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture216,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(292).fill(173), /* required buffer size: 292 */
{offset: 292, bytesPerRow: 45}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer172 = device0.createBuffer({
  size: 7454,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder208 = device0.createCommandEncoder({});
let textureView244 = texture66.createView({dimension: '2d', aspect: 'all', format: 'rg32float'});
let sampler135 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 20.24,
  lodMaxClamp: 85.76,
  maxAnisotropy: 1,
});
try {
renderPassEncoder33.setBindGroup(3, bindGroup32);
} catch {}
try {
renderPassEncoder38.setBindGroup(0, bindGroup58, new Uint32Array(298), 6, 0);
} catch {}
try {
renderPassEncoder29.executeBundles([renderBundle3, renderBundle6, renderBundle17, renderBundle20, renderBundle21]);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer83, 'uint32', 6_888, 60);
} catch {}
let shaderModule14 = device0.createShaderModule({
  label: '\u06e1\ue212\u{1f8c7}\uf3b4',
  code: `
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  f0: array<array<mat2x2f, 1>, 1>,
}
override override69 : i32;
override override65 : f32;
@id(28761) override override68 : u32 = 88;
override override66 : bool = false;
override override67 : f16;
@group(0) @binding(188) var<storage, read> buffer173: array<array<array<array<f16, 1>, 1>, 1>, 8>;
@group(0) @binding(61) var tex8: texture_2d<i32>;
struct S7 {
  @location(5) @interpolate(flat, centroid) f0: vec4i,
  @location(6) f1: f32,
  @location(4) f2: i32,
  @location(9) @interpolate(flat, center) f3: f32,
  @location(3) f4: vec2u
}

@vertex
fn vertex0(a0: S7) -> @builtin(position) vec4f {
  var out: vec4f;
  _ = buffer173[7][0];
  _ = buffer173[7];
  if bool(a0.f1) {
    var v: vec4f;
  }
  return out;
}

@compute @workgroup_size(1, 2, 1)
fn compute0() {
}`,
  sourceMap: {},
  hints: {},
});
let commandBuffer13 = commandEncoder208.finish({label: '\u0646\u066d\u0e24\ud3ca\u07c0\ucf14\u47c0\u7e03\u0007'});
let texture233 = gpuCanvasContext6.getCurrentTexture();
try {
computePassEncoder80.setBindGroup(1, bindGroup97, new Uint32Array(7223), 1_209, 0);
} catch {}
try {
renderPassEncoder39.setBindGroup(1, bindGroup71, new Uint32Array(797), 122, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroup120 = device0.createBindGroup({
  label: '\ucdac\u05d1\u{1f89f}\u07fc\u{1fe6e}\u{1fab4}\u0a75',
  layout: bindGroupLayout18,
  entries: [
    {binding: 132, resource: {buffer: buffer153, offset: 0, size: 529}},
    {binding: 301, resource: {buffer: buffer59, offset: 25600, size: 8}},
    {binding: 7, resource: sampler36},
    {binding: 99, resource: textureView43},
    {binding: 308, resource: externalTexture4},
    {binding: 82, resource: {buffer: buffer107, offset: 0, size: 42}},
    {binding: 65, resource: textureView115},
    {binding: 125, resource: sampler4},
    {binding: 27, resource: {buffer: buffer165, offset: 0, size: 4}},
    {binding: 50, resource: {buffer: buffer170, offset: 0, size: 218}},
    {binding: 209, resource: textureView69},
    {binding: 171, resource: textureView46},
    {binding: 380, resource: textureView77},
    {binding: 114, resource: textureView98},
    {binding: 56, resource: {buffer: buffer169, offset: 7168, size: 12}},
    {binding: 277, resource: textureView162},
    {binding: 55, resource: sampler0},
    {binding: 296, resource: textureView14},
    {binding: 77, resource: externalTexture26},
    {binding: 245, resource: textureView198},
    {binding: 698, resource: textureView49},
    {binding: 6, resource: {buffer: buffer14, offset: 768, size: 868}},
    {binding: 119, resource: {buffer: buffer87, offset: 0}},
    {binding: 32, resource: textureView160},
    {binding: 178, resource: sampler21},
    {binding: 598, resource: {buffer: buffer169, offset: 512, size: 972}},
    {binding: 142, resource: textureView172},
    {binding: 8, resource: textureView227},
    {binding: 220, resource: sampler123},
    {binding: 196, resource: {buffer: buffer60, offset: 2816, size: 256}},
    {binding: 810, resource: {buffer: buffer120, offset: 2048, size: 426}},
    {binding: 15, resource: textureView186},
    {binding: 386, resource: sampler107},
    {binding: 249, resource: sampler43},
    {binding: 62, resource: {buffer: buffer26, offset: 256, size: 696}},
    {binding: 90, resource: {buffer: buffer60, offset: 3328, size: 1595}},
    {binding: 566, resource: {buffer: buffer166, offset: 0}},
    {binding: 152, resource: {buffer: buffer48, offset: 0, size: 66}},
    {binding: 102, resource: {buffer: buffer30, offset: 512, size: 32}},
    {binding: 28, resource: textureView99},
    {binding: 203, resource: textureView215},
    {binding: 839, resource: {buffer: buffer74, offset: 7424, size: 952}},
    {binding: 0, resource: externalTexture2},
    {binding: 192, resource: textureView10},
    {binding: 113, resource: textureView84},
    {binding: 66, resource: textureView222},
    {binding: 91, resource: {buffer: buffer31, offset: 0, size: 2681}},
    {binding: 52, resource: sampler96},
    {binding: 150, resource: textureView10},
    {binding: 304, resource: externalTexture16},
    {binding: 225, resource: sampler70},
    {binding: 58, resource: sampler125},
  ],
});
try {
renderPassEncoder36.setBindGroup(3, bindGroup32);
} catch {}
let buffer174 = device0.createBuffer({
  label: '\u{1feb0}\u0142\uadf6\u0582',
  size: 15220,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let sampler136 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 75.52,
  lodMaxClamp: 87.49,
});
try {
renderPassEncoder31.executeBundles([renderBundle23]);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer74, 'uint16', 1_348, 403);
} catch {}
let buffer175 = device0.createBuffer({size: 18596, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture234 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 217},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture235 = device0.createTexture({
  size: [105, 1, 63],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder33.executeBundles([renderBundle5]);
} catch {}
let buffer176 = device0.createBuffer({
  size: 3773,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let texture236 = device0.createTexture({
  size: {width: 39, height: 66, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView245 = texture203.createView({mipLevelCount: 1});
let sampler137 = device0.createSampler({
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 32.61,
  lodMaxClamp: 55.34,
  compare: 'less',
});
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.writeBuffer(buffer18, 1288, new BigUint64Array(23380), 522, 332);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture237 = device0.createTexture({
  size: [78],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView246 = texture118.createView({format: 'rgba16sint'});
document.body.append(img1);
try {
computePassEncoder52.setBindGroup(0, bindGroup56);
} catch {}
try {
renderPassEncoder30.setBindGroup(1, bindGroup79);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup45, new Uint32Array(3743), 885, 0);
} catch {}
try {
renderPassEncoder34.beginOcclusionQuery(428);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(6, buffer128);
} catch {}
try {
window.someLabel = externalTexture16.label;
} catch {}
let bindGroupLayout32 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 51,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let commandEncoder209 = device0.createCommandEncoder({});
let textureView247 = texture112.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder165 = commandEncoder209.beginComputePass();
let sampler138 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 53.01,
  lodMaxClamp: 79.14,
  maxAnisotropy: 1,
});
let externalTexture34 = device0.importExternalTexture({source: videoFrame26});
try {
computePassEncoder39.setBindGroup(0, bindGroup49);
} catch {}
try {
computePassEncoder12.setBindGroup(2, bindGroup35, new Uint32Array(356), 137, 0);
} catch {}
try {
computePassEncoder165.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(7, buffer138, 0, 647);
} catch {}
let arrayBuffer27 = buffer129.getMappedRange(296);
try {
device0.queue.submit([]);
} catch {}
let commandEncoder210 = device0.createCommandEncoder({});
let textureView248 = texture227.createView({baseMipLevel: 0});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true, stencilReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder34.endOcclusionQuery();
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle0, renderBundle3]);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer28, 'uint16', 2_334, 831);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(3, buffer34, 108, 1);
} catch {}
try {
renderBundleEncoder27.setBindGroup(3, bindGroup0, new Uint32Array(2788), 1_102, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 16}
*/
{
  source: videoFrame28,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture31,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup121 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView7}]});
let buffer177 = device0.createBuffer({
  size: 7008,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder15.setBindGroup(2, bindGroup58);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup78, new Uint32Array(855), 61, 0);
} catch {}
try {
renderBundleEncoder27.setBindGroup(3, bindGroup33);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer28, 'uint32', 708, 1_393);
} catch {}
try {
commandEncoder210.copyTextureToBuffer({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1856 */
  offset: 1856,
  buffer: buffer150,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder210.copyTextureToTexture({
  texture: texture133,
  mipLevel: 0,
  origin: {x: 4, y: 4, z: 60},
  aspect: 'all',
},
{
  texture: texture29,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 1},
  aspect: 'all',
},
{width: 7, height: 0, depthOrArrayLayers: 8});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer98, 1_160); };
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer162, 'uint16', 38, 3_061);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(4, buffer114, 44, 95);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
buffer146.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: imageData20,
  origin: { x: 10, y: 1 },
  flipY: true,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 11, y: 3, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 8, depthOrArrayLayers: 0});
} catch {}
document.body.append(video1);
let commandEncoder211 = device0.createCommandEncoder({});
let texture238 = device0.createTexture({
  size: {width: 39, height: 66, depthOrArrayLayers: 581},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundle27 = renderBundleEncoder27.finish({});
let sampler139 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 32.65,
  lodMaxClamp: 39.60,
  maxAnisotropy: 17,
});
try {
computePassEncoder25.setBindGroup(1, bindGroup58, new Uint32Array(328), 19, 0);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup28, new Uint32Array(2838), 1_559, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(82);
} catch {}
let buffer178 = device0.createBuffer({
  size: 1310,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView249 = texture149.createView({dimension: 'cube', baseArrayLayer: 1});
try {
buffer3.unmap();
} catch {}
try {
commandEncoder210.copyTextureToTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 1,
  origin: {x: 71, y: 0, z: 0},
  aspect: 'all',
},
{width: 40, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await adapter0.requestAdapterInfo();
} catch {}
let sampler140 = device0.createSampler({
  label: '\u{1f7d4}\u9a24\u0d3f\ueb8f\u{1fa62}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 53.11,
  lodMaxClamp: 98.25,
  compare: 'greater',
});
try {
computePassEncoder64.setBindGroup(3, bindGroup47);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder39.executeBundles([renderBundle20, renderBundle23, renderBundle6]);
} catch {}
try {
renderPassEncoder15.setViewport(204.9640346661625, 0.9761844744538806, 3.086337512550854, 0.011216783523279726, 0.11930025363540464, 0.138022105536079);
} catch {}
try {
computePassEncoder13.setBindGroup(0, bindGroup82);
} catch {}
try {
renderPassEncoder37.setBindGroup(3, bindGroup83);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup3, new Uint32Array(4942), 707, 0);
} catch {}
try {
commandEncoder210.copyTextureToTexture({
  texture: texture201,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 12},
  aspect: 'all',
},
{
  texture: texture51,
  mipLevel: 3,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer13]);
} catch {}
try {
if (!arrayBuffer25.detached) { new Uint8Array(arrayBuffer25).fill(0x55); };
} catch {}
let pipelineLayout19 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture239 = device0.createTexture({
  size: {width: 39, height: 66, depthOrArrayLayers: 95},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder40 = commandEncoder211.beginRenderPass({
  colorAttachments: [{
  view: textureView24,
  clearValue: { r: -25.84, g: -145.3, b: -510.7, a: 503.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler141 = device0.createSampler({addressModeV: 'mirror-repeat', lodMinClamp: 86.92, lodMaxClamp: 90.89});
try {
renderPassEncoder12.setVertexBuffer(3, buffer75);
} catch {}
try {
device0.queue.writeBuffer(buffer113, 108, new DataView(new ArrayBuffer(4898)), 1151, 240);
} catch {}
let commandEncoder212 = device0.createCommandEncoder({});
let texture240 = device0.createTexture({
  label: '\u{1ff41}\u2502\u8b29\u6332\u0e03\u{1f9cf}',
  size: [39, 66, 1],
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder166 = commandEncoder210.beginComputePass({});
try {
computePassEncoder127.setBindGroup(0, bindGroup5, new Uint32Array(561), 142, 0);
} catch {}
try {
computePassEncoder82.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder38.setBindGroup(2, bindGroup39, new Uint32Array(3379), 218, 0);
} catch {}
try {
renderPassEncoder33.executeBundles([renderBundle6]);
} catch {}
let bindGroup122 = device0.createBindGroup({
  label: '\uadf5\u68b8\u34e1\ua50f\u04c2\u{1fec8}\u076d\ue6cd\u53f4\u258c\u{1ffc1}',
  layout: bindGroupLayout21,
  entries: [{binding: 243, resource: {buffer: buffer156, offset: 1024}}],
});
let commandEncoder213 = device0.createCommandEncoder({});
let sampler142 = device0.createSampler({
  label: '\ud335\u38c9',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 81.29,
});
try {
gpuCanvasContext7.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING, alphaMode: 'opaque'});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture152,
  mipLevel: 0,
  origin: {x: 11, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(1_070).fill(92), /* required buffer size: 1_070 */
{offset: 126, bytesPerRow: 106}, {width: 6, height: 9, depthOrArrayLayers: 1});
} catch {}
let imageData23 = new ImageData(12, 140);
let commandEncoder214 = device0.createCommandEncoder({});
let computePassEncoder167 = commandEncoder214.beginComputePass({});
try {
computePassEncoder167.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder40.setBindGroup(3, bindGroup113);
} catch {}
let buffer179 = device0.createBuffer({
  label: '\udc1a\u002b\uf0ff\u0e5f\u0f49\u{1f74c}\u60d5\ubc42\u4d05\u7513\ue024',
  size: 26206,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
let textureView250 = texture162.createView({dimension: '2d', baseArrayLayer: 6, arrayLayerCount: 1});
try {
computePassEncoder28.setBindGroup(1, bindGroup72, new Uint32Array(446), 26, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer162, 632); };
} catch {}
try {
renderPassEncoder31.end();
} catch {}
let bindGroup123 = device0.createBindGroup({
  layout: bindGroupLayout30,
  entries: [{binding: 176, resource: {buffer: buffer63, offset: 0, size: 12}}],
});
try {
computePassEncoder17.setBindGroup(0, bindGroup19, []);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder19.executeBundles([]);
} catch {}
let commandEncoder215 = device0.createCommandEncoder({});
let computePassEncoder168 = commandEncoder215.beginComputePass({});
let renderPassEncoder41 = commandEncoder212.beginRenderPass({
  colorAttachments: [{
  view: textureView17,
  clearValue: { r: -173.8, g: 398.4, b: 237.9, a: 66.65, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 135649275,
});
try {
device0.queue.writeBuffer(buffer121, 636, new BigUint64Array(1349), 248, 288);
} catch {}
let promise30 = device0.queue.onSubmittedWorkDone();
let texture241 = device0.createTexture({
  size: [288, 96, 1],
  mipLevelCount: 3,
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder123.setBindGroup(2, bindGroup73, new Uint32Array(309), 44, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(1, bindGroup96, []);
} catch {}
try {
commandEncoder213.copyTextureToTexture({
  texture: texture96,
  mipLevel: 1,
  origin: {x: 10, y: 32, z: 0},
  aspect: 'all',
},
{
  texture: texture84,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView251 = texture113.createView({});
let computePassEncoder169 = commandEncoder213.beginComputePass({});
try {
computePassEncoder12.setBindGroup(1, bindGroup63, new Uint32Array(646), 119, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup62, new Uint32Array(127), 7, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData11,
  origin: { x: 5, y: 3 },
  flipY: true,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 95, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(video0);
let videoFrame41 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpteSt4281', transfer: 'bt2020_10bit'} });
let bindGroup124 = device0.createBindGroup({
  layout: bindGroupLayout12,
  entries: [
    {binding: 106, resource: {buffer: buffer131, offset: 1536, size: 452}},
    {binding: 20, resource: textureView124},
    {binding: 74, resource: sampler140},
  ],
});
let commandEncoder216 = device0.createCommandEncoder({});
let texture242 = device0.createTexture({
  label: '\u5c36\u0b33\u{1fb3c}\u3fd8\u{1f684}\u012f',
  size: {width: 105, height: 1, depthOrArrayLayers: 160},
  mipLevelCount: 3,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder166.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup93, new Uint32Array(602), 25, 0);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(4_294_967_295, undefined, 123_136_724, 414_665_485);
} catch {}
try {
computePassEncoder73.insertDebugMarker('\u6547');
} catch {}
try {
device0.queue.writeBuffer(buffer83, 1896, new Int16Array(2021), 249);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: canvas4,
  origin: { x: 2, y: 49 },
  flipY: true,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 9, y: 2, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 14, depthOrArrayLayers: 0});
} catch {}
let bindGroup125 = device0.createBindGroup({
  label: '\ud469\u0da3\uff45\ua584\u0383\u840a\uaac1\u2244',
  layout: bindGroupLayout30,
  entries: [{binding: 176, resource: {buffer: buffer28, offset: 5376, size: 1348}}],
});
let buffer180 = device0.createBuffer({size: 17337, usage: GPUBufferUsage.MAP_READ});
let commandEncoder217 = device0.createCommandEncoder();
let texture243 = device0.createTexture({
  size: {width: 420, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder99.dispatchWorkgroups(1);
} catch {}
try {
computePassEncoder168.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder27.setBindGroup(1, bindGroup90);
} catch {}
try {
renderPassEncoder32.executeBundles([]);
} catch {}
try {
renderPassEncoder27.setViewport(4.349942413254928, 11.518183745297922, 0.16213176630296014, 0.9044460406603847, 0.342527069670881, 0.6995171928075006);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: video0,
  origin: { x: 1, y: 3 },
  flipY: true,
}, {
  texture: texture225,
  mipLevel: 0,
  origin: {x: 19, y: 8, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let bindGroup126 = device0.createBindGroup({layout: bindGroupLayout26, entries: [{binding: 42, resource: textureView174}]});
let commandEncoder218 = device0.createCommandEncoder({});
let texture244 = device0.createTexture({
  size: [36, 12, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture245 = device0.createTexture({
  size: [39],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder170 = commandEncoder218.beginComputePass({label: '\u82c5\u0608\u{1f8ba}\uae59\u5c93\u{1fe41}\ueb3e\u{1fca4}'});
let sampler143 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 66.52,
});
try {
computePassEncoder63.setBindGroup(1, bindGroup3);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup88, new Uint32Array(235), 76, 0);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle10]);
} catch {}
let textureView252 = texture239.createView({mipLevelCount: 1});
let computePassEncoder171 = commandEncoder217.beginComputePass();
let renderPassEncoder42 = commandEncoder216.beginRenderPass({
  colorAttachments: [{view: textureView202, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet5,
});
try {
computePassEncoder4.setBindGroup(2, bindGroup125);
} catch {}
try {
computePassEncoder170.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder42.beginOcclusionQuery(128);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(1, buffer161, 0, 5_934);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture161,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(313).fill(51), /* required buffer size: 313 */
{offset: 313, bytesPerRow: 46}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder219 = device0.createCommandEncoder();
let textureView253 = texture225.createView({aspect: 'all'});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer153, 12); };
} catch {}
try {
computePassEncoder171.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder42.endOcclusionQuery();
} catch {}
try {
commandEncoder219.copyBufferToTexture({
  /* bytesInLastRow: 144 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 64 */
  offset: 64,
  bytesPerRow: 512,
  buffer: buffer39,
}, {
  texture: texture226,
  mipLevel: 0,
  origin: {x: 8, y: 12, z: 0},
  aspect: 'all',
}, {width: 9, height: 23, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder220 = device0.createCommandEncoder({});
let computePassEncoder172 = commandEncoder219.beginComputePass();
try {
computePassEncoder60.setBindGroup(3, bindGroup35, new Uint32Array(2572), 66, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer22, 0); };
} catch {}
try {
computePassEncoder169.setPipeline(pipeline4);
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
try {
computePassEncoder47.setBindGroup(1, bindGroup24);
} catch {}
try {
renderPassEncoder36.setBindGroup(3, bindGroup75, new Uint32Array(289), 26, 0);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer104, 'uint32', 620, 2_145);
} catch {}
try {
commandEncoder220.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 88 */
  offset: 88,
  rowsPerImage: 243,
  buffer: buffer44,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 1});
} catch {}
let imageData24 = new ImageData(76, 4);
let bindGroupLayout33 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 566,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 834,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let commandEncoder221 = device0.createCommandEncoder();
let computePassEncoder173 = commandEncoder221.beginComputePass({label: '\u{1f7f1}\u0b68\u070b\u30a0\uac96'});
try {
computePassEncoder52.setBindGroup(1, bindGroup126, new Uint32Array(4553), 275, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder28.end();
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer25, 'uint16', 1_246, 662);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(1, buffer109, 0, 11_969);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture195,
  mipLevel: 0,
  origin: {x: 0, y: 23, z: 0},
  aspect: 'all',
}, new Uint8Array(12_241).fill(217), /* required buffer size: 12_241 */
{offset: 11, bytesPerRow: 225, rowsPerImage: 52}, {width: 5, height: 3, depthOrArrayLayers: 2});
} catch {}
let offscreenCanvas5 = new OffscreenCanvas(151, 359);
let videoFrame42 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpteSt4281', transfer: 'gamma22curve'} });
let buffer181 = device0.createBuffer({size: 29488, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder222 = device0.createCommandEncoder({});
try {
computePassEncoder1.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup113);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup18, new Uint32Array(4658), 8, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer167, 0);
} catch {}
let gpuCanvasContext13 = offscreenCanvas5.getContext('webgpu');
let commandEncoder223 = device0.createCommandEncoder();
let texture246 = device0.createTexture({size: {width: 72}, dimension: '1d', format: 'rgba32sint', usage: GPUTextureUsage.STORAGE_BINDING});
let computePassEncoder174 = commandEncoder223.beginComputePass({});
try {
computePassEncoder8.setBindGroup(3, bindGroup80, new Uint32Array(656), 7, 0);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup59, []);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer29, 'uint16', 4_862, 1_050);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(6, buffer59);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
  await promise30;
} catch {}
try {
computePassEncoder56.setBindGroup(1, bindGroup4);
} catch {}
try {
computePassEncoder164.setBindGroup(1, bindGroup82, new Uint32Array(2960), 66, 0);
} catch {}
try {
renderPassEncoder39.setViewport(57.79236984815652, 0.5224831540768331, 36.88964555481552, 0.2524686680747187, 0.8788293473146773, 0.9225890768911936);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let bindGroup127 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 172, resource: sampler133},
    {binding: 228, resource: {buffer: buffer24, offset: 768, size: 324}},
  ],
});
let commandEncoder224 = device0.createCommandEncoder();
let computePassEncoder175 = commandEncoder224.beginComputePass({});
try {
renderPassEncoder12.setIndexBuffer(buffer179, 'uint16', 4_486, 11_409);
} catch {}
try {
commandEncoder222.copyBufferToTexture({
  /* bytesInLastRow: 184 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1064 */
  offset: 1064,
  bytesPerRow: 512,
  buffer: buffer4,
}, {
  texture: texture184,
  mipLevel: 0,
  origin: {x: 135, y: 0, z: 0},
  aspect: 'all',
}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap8 = await createImageBitmap(img5);
let bindGroupLayout34 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 170,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
    {binding: 167, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {
      binding: 643,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 101,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let computePassEncoder176 = commandEncoder222.beginComputePass({label: '\ud0d5\u{1fe2b}\u{1f915}\u{1fd92}\ub437\u0681\u9a61\u70e0\u{1f9a0}\uab65\u0204'});
try {
computePassEncoder172.setBindGroup(2, bindGroup52, []);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle3]);
} catch {}
try {
device0.queue.writeBuffer(buffer27, 3092, new Float32Array(6114), 74, 640);
} catch {}
document.body.prepend(img5);
let texture247 = device0.createTexture({
  size: [144, 48, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder4.setScissorRect(15, 43, 14, 0);
} catch {}
let promise31 = adapter0.requestAdapterInfo();
let bindGroup128 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer30, offset: 0, size: 32}}],
});
let texture248 = device0.createTexture({
  size: [105, 1, 298],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder177 = commandEncoder220.beginComputePass({});
try {
computePassEncoder23.setBindGroup(2, bindGroup91);
} catch {}
try {
computePassEncoder175.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.end();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas3,
  origin: { x: 0, y: 69 },
  flipY: false,
}, {
  texture: texture123,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 54, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder173.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture175,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(57).fill(153), /* required buffer size: 57 */
{offset: 57, rowsPerImage: 0}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55); };
} catch {}
let videoFrame43 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte170m', transfer: 'gamma28curve'} });
let texture249 = device0.createTexture({size: {width: 72}, dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder66.setBindGroup(2, bindGroup36);
} catch {}
try {
computePassEncoder150.setBindGroup(0, bindGroup99, new Uint32Array(3315), 104, 0);
} catch {}
try {
computePassEncoder177.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
} catch {}
let videoFrame44 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'bt470bg', transfer: 'unspecified'} });
let bindGroup129 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [{binding: 116, resource: textureView196}, {binding: 289, resource: textureView10}],
});
let commandEncoder225 = device0.createCommandEncoder({label: '\ub8b6\u2c68\uaf49\u{1fcb7}\u338f\u09bc\u227a\u00c2\u0196'});
let computePassEncoder178 = commandEncoder225.beginComputePass({});
let externalTexture35 = device0.importExternalTexture({source: videoFrame10});
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder24.setBlendConstant({ r: 646.3, g: 406.1, b: -941.6, a: 477.7, });
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer64, 'uint16', 162, 1_161);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(4, buffer132, 456);
} catch {}
let pipeline6 = device0.createComputePipeline({layout: pipelineLayout14, compute: {module: shaderModule14}});
try {
  await promise31;
} catch {}
let bindGroup130 = device0.createBindGroup({
  layout: bindGroupLayout21,
  entries: [{binding: 243, resource: {buffer: buffer60, offset: 256, size: 1532}}],
});
let commandEncoder226 = device0.createCommandEncoder({});
let computePassEncoder179 = commandEncoder226.beginComputePass({});
try {
computePassEncoder179.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup65, new Uint32Array(1225), 236, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer156, 'uint16', 21_126, 1_530);
} catch {}
let bindGroup131 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 102, resource: textureView176},
    {binding: 9, resource: textureView59},
    {binding: 453, resource: textureView115},
  ],
});
let commandEncoder227 = device0.createCommandEncoder();
let computePassEncoder180 = commandEncoder227.beginComputePass();
let sampler144 = device0.createSampler({
  label: '\u852f\udcb8\u2e11',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 22.10,
  lodMaxClamp: 36.86,
});
try {
computePassEncoder70.setBindGroup(2, bindGroup10, []);
} catch {}
try {
computePassEncoder19.setBindGroup(2, bindGroup80, new Uint32Array(628), 149, 0);
} catch {}
try {
computePassEncoder180.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer69, 0, 987);
} catch {}
let bindGroup132 = device0.createBindGroup({
  layout: bindGroupLayout12,
  entries: [
    {binding: 20, resource: textureView124},
    {binding: 106, resource: {buffer: buffer161, offset: 0}},
    {binding: 74, resource: sampler101},
  ],
});
try {
computePassEncoder97.setBindGroup(3, bindGroup77);
} catch {}
try {
renderPassEncoder26.executeBundles([renderBundle17, renderBundle7, renderBundle10, renderBundle21, renderBundle6]);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer169, 'uint32', 920, 175);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroup133 = device0.createBindGroup({
  layout: bindGroupLayout25,
  entries: [
    {binding: 129, resource: textureView142},
    {binding: 252, resource: textureView85},
    {binding: 6, resource: textureView69},
    {binding: 1, resource: textureView202},
    {binding: 171, resource: textureView129},
  ],
});
let commandEncoder228 = device0.createCommandEncoder({label: '\u05ec\u{1f97d}\u03ad\u00da\uba4b\ucf2b\u0c48\u0638\ue0ff'});
let texture250 = device0.createTexture({size: [39, 66, 1], format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder181 = commandEncoder228.beginComputePass({});
try {
computePassEncoder112.setBindGroup(2, bindGroup53);
} catch {}
try {
computePassEncoder176.setPipeline(pipeline4);
} catch {}
let commandEncoder229 = device0.createCommandEncoder({});
let textureView254 = texture68.createView({aspect: 'all', mipLevelCount: 1});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rg16float'], stencilReadOnly: true});
try {
computePassEncoder77.setBindGroup(3, bindGroup125);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1, 4, 1); };
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(0, buffer165, 0, 12);
} catch {}
let commandEncoder230 = device0.createCommandEncoder();
try {
computePassEncoder62.setBindGroup(1, bindGroup44, new Uint32Array(4494), 531, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(1, bindGroup116, new Uint32Array(1105), 63, 0);
} catch {}
try {
renderPassEncoder32.executeBundles([renderBundle21]);
} catch {}
try {
renderPassEncoder33.setStencilReference(1114);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer97, 'uint32', 24, 10_606);
} catch {}
try {
renderBundleEncoder28.setBindGroup(0, bindGroup129);
} catch {}
try {
renderBundleEncoder28.setBindGroup(0, bindGroup7, new Uint32Array(219), 56, 0);
} catch {}
try {
commandEncoder230.copyBufferToBuffer(buffer45, 6820, buffer48, 16, 52);
} catch {}
try {
computePassEncoder62.pushDebugGroup('\u056b');
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroup134 = device0.createBindGroup({layout: bindGroupLayout26, entries: [{binding: 42, resource: textureView174}]});
let commandEncoder231 = device0.createCommandEncoder();
let texture251 = device0.createTexture({
  size: [72, 24, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder182 = commandEncoder229.beginComputePass();
try {
computePassEncoder93.setBindGroup(1, bindGroup83, new Uint32Array(4232), 348, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(2, 1); };
} catch {}
try {
computePassEncoder178.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder26.setBindGroup(3, bindGroup101, new Uint32Array(1444), 466, 0);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer1, 'uint16', 5_618, 727);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer176, 'uint16', 1_360, 71);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(4, buffer59, 1_652, 1_281);
} catch {}
try {
commandEncoder230.copyBufferToBuffer(buffer149, 1412, buffer37, 1788, 228);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroup135 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 110, resource: sampler136},
    {binding: 145, resource: sampler124},
    {binding: 328, resource: {buffer: buffer85, offset: 2560, size: 5598}},
  ],
});
let texture252 = device0.createTexture({
  size: [32, 32, 302],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture253 = device0.createTexture({size: [36, 12, 1], mipLevelCount: 3, format: 'r8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let sampler145 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 88.90,
  lodMaxClamp: 99.97,
  maxAnisotropy: 5,
});
try {
computePassEncoder106.setBindGroup(0, bindGroup19, new Uint32Array(3014), 416, 0);
} catch {}
try {
computePassEncoder174.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer39, 'uint16', 910, 159);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(3, buffer11, 3_760);
} catch {}
try {
  await shaderModule5.getCompilationInfo();
} catch {}
let arrayBuffer28 = buffer161.getMappedRange();
let buffer182 = device0.createBuffer({size: 23521, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder232 = device0.createCommandEncoder();
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle28 = renderBundleEncoder29.finish({});
try {
computePassEncoder17.setBindGroup(3, bindGroup78);
} catch {}
try {
computePassEncoder40.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder172.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer144, 'uint16', 3_566, 889);
} catch {}
try {
commandEncoder231.copyTextureToTexture({
  texture: texture167,
  mipLevel: 1,
  origin: {x: 0, y: 3, z: 3},
  aspect: 'all',
},
{
  texture: texture199,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder233 = device0.createCommandEncoder({label: '\u{1fc23}\uabf6\u80dc\ub451\u00cc'});
let computePassEncoder183 = commandEncoder233.beginComputePass({});
try {
computePassEncoder108.setBindGroup(2, bindGroup23);
} catch {}
try {
renderPassEncoder34.executeBundles([renderBundle3, renderBundle3]);
} catch {}
try {
renderBundleEncoder28.setBindGroup(3, bindGroup99, new Uint32Array(2652), 426, 0);
} catch {}
let bindGroup136 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 4, resource: textureView197},
    {binding: 23, resource: textureView250},
    {binding: 505, resource: {buffer: buffer78, offset: 1536, size: 1370}},
    {binding: 69, resource: textureView185},
  ],
});
let buffer183 = device0.createBuffer({
  size: 10646,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture254 = device0.createTexture({
  size: {width: 78, height: 132, depthOrArrayLayers: 1},
  sampleCount: 1,
  dimension: '2d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder184 = commandEncoder230.beginComputePass({});
let renderBundle29 = renderBundleEncoder28.finish({});
let sampler146 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 96.17,
  lodMaxClamp: 96.82,
  compare: 'always',
  maxAnisotropy: 1,
});
try {
renderPassEncoder19.setBindGroup(0, bindGroup61, []);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup132, new Uint32Array(4193), 606, 0);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle21, renderBundle6]);
} catch {}
try {
renderPassEncoder22.setViewport(361.4123170438668, 0.3820458222423613, 330.9264632022653, 0.10492201151355028, 0.01631869460858182, 0.5735348489635148);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer122, 'uint32', 788, 778);
} catch {}
try {
computePassEncoder62.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer113, 56, new Float32Array(8062), 1571, 296);
} catch {}
document.body.append(canvas8);
let commandEncoder234 = device0.createCommandEncoder({label: '\u{1f9c6}\u3c7a\uf273\u3e94\u03dc\u019a\u0427'});
let textureView255 = texture65.createView({dimension: 'cube', baseArrayLayer: 2});
let texture255 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 73},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView256 = texture148.createView({mipLevelCount: 1});
try {
computePassEncoder111.setBindGroup(2, bindGroup109);
} catch {}
try {
renderPassEncoder39.setBindGroup(3, bindGroup6, new Uint32Array(196), 11, 0);
} catch {}
try {
commandEncoder234.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2332 */
  offset: 2332,
  bytesPerRow: 1024,
  rowsPerImage: 124,
  buffer: buffer145,
}, {
  texture: texture84,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder232.copyTextureToTexture({
  texture: texture180,
  mipLevel: 0,
  origin: {x: 46, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture85,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 43},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 4});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture87,
  mipLevel: 0,
  origin: {x: 11, y: 9, z: 5},
  aspect: 'all',
}, new Uint8Array(219).fill(175), /* required buffer size: 219 */
{offset: 219}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
if (!arrayBuffer17.detached) { new Uint8Array(arrayBuffer17).fill(0x55); };
} catch {}
let buffer184 = device0.createBuffer({size: 4011, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture256 = device0.createTexture({
  label: '\u{1fe52}\u111d\u{1fc79}\u0f5d\u2764\u0000\u0272\u0973\uabd7\uf749',
  size: [210, 1, 1],
  mipLevelCount: 2,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder26.setBindGroup(1, bindGroup0, new Uint32Array(1586), 492, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer37, 840); };
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup134);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer107, 'uint32', 380, 45);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder234.clearBuffer(buffer108, 4, 32);
} catch {}
let bindGroup137 = device0.createBindGroup({
  label: '\ud17e\u0003\u08b0',
  layout: bindGroupLayout25,
  entries: [
    {binding: 1, resource: textureView59},
    {binding: 171, resource: textureView168},
    {binding: 252, resource: textureView237},
    {binding: 129, resource: textureView108},
    {binding: 6, resource: textureView9},
  ],
});
let texture257 = device0.createTexture({
  size: [840],
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView257 = texture29.createView({label: '\u082e\ufce9\ubf0d\ua917\u01c6\ua9ef', dimension: '3d'});
try {
computePassEncoder184.setBindGroup(3, bindGroup134, new Uint32Array(337), 57, 0);
} catch {}
try {
computePassEncoder116.end();
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer83, 'uint16', 3_748, 2_707);
} catch {}
let arrayBuffer29 = buffer134.getMappedRange(4208);
try {
commandEncoder231.resolveQuerySet(querySet13, 23, 43, buffer136, 512);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let querySet28 = device0.createQuerySet({label: '\u795c\ue9b8\ue8af\u0479\u7de6\u4337', type: 'occlusion', count: 503});
let texture258 = device0.createTexture({
  size: [420, 1, 15],
  sampleCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView258 = texture25.createView({});
let computePassEncoder185 = commandEncoder231.beginComputePass({label: '\u{1f7b5}\ufc1e\u{1fa00}\u0892\u86fa\u02a2\u{1faa7}\u6818\u{1f994}'});
let sampler147 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 27.54,
  lodMaxClamp: 43.31,
});
try {
computePassEncoder103.setBindGroup(3, bindGroup89);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer74, 64); };
} catch {}
try {
renderPassEncoder32.setBindGroup(2, bindGroup75, new Uint32Array(513), 5, 0);
} catch {}
try {
commandEncoder234.copyBufferToBuffer(buffer120, 124, buffer129, 140, 2800);
} catch {}
let bindGroup138 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [{binding: 228, resource: textureView81}, {binding: 41, resource: textureView194}],
});
let buffer185 = device0.createBuffer({
  size: 6713,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder235 = device0.createCommandEncoder({});
let computePassEncoder186 = commandEncoder234.beginComputePass({});
let renderBundleEncoder30 = device0.createRenderBundleEncoder({
  label: '\u01b9\u0ce8\u041e\u{1f77e}\u0c04\u0898\u322b\ub6da',
  colorFormats: ['bgra8unorm-srgb'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let sampler148 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 17.33,
  lodMaxClamp: 91.17,
  compare: 'greater',
  maxAnisotropy: 13,
});
try {
computePassEncoder148.setBindGroup(0, bindGroup55);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup123);
} catch {}
try {
renderPassEncoder34.setViewport(259.79816832645156, 0.028725655716136167, 414.7907575749193, 0.6983143518387416, 0.13288073012100887, 0.3582344495407995);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(3, buffer138, 2_112, 658);
} catch {}
try {
renderBundleEncoder30.setBindGroup(1, bindGroup102, new Uint32Array(679), 346, 0);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(6, buffer121, 0, 71);
} catch {}
try {
buffer10.unmap();
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['bgra8unorm-srgb'],
});
} catch {}
let buffer186 = device0.createBuffer({
  size: 1712,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: true,
});
let texture259 = device0.createTexture({
  label: '\u233d\u{1f758}\u0d25\u7763\ubdb3\uc296\ue05f\u{1faf0}\ua933\u0f4c',
  size: {width: 32},
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView259 = texture94.createView({});
let computePassEncoder187 = commandEncoder142.beginComputePass({});
let renderBundle30 = renderBundleEncoder30.finish({});
let sampler149 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 69.24,
  compare: 'always',
});
try {
renderPassEncoder20.setBindGroup(2, bindGroup112);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup60, new Uint32Array(269), 123, 0);
} catch {}
try {
renderPassEncoder19.setBlendConstant({ r: 70.03, g: 144.2, b: 532.4, a: 699.8, });
} catch {}
try {
renderPassEncoder33.setViewport(171.13467810094787, 40.81916184852466, 100.67107335384743, 39.405598246465715, 0.9499585302478767, 0.9507027028606748);
} catch {}
try {
commandEncoder235.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 352 */
  offset: 352,
  bytesPerRow: 512,
  buffer: buffer114,
}, {
  texture: texture114,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let commandEncoder236 = device0.createCommandEncoder({});
try {
computePassEncoder181.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer167, 'uint32', 1_816, 5_337);
} catch {}
try {
buffer55.unmap();
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let imageData25 = new ImageData(8, 28);
let bindGroup139 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 453, resource: textureView185},
    {binding: 102, resource: textureView146},
    {binding: 9, resource: textureView203},
  ],
});
let pipelineLayout20 = device0.createPipelineLayout({label: '\ubdb6\u09f8\u{1fe60}', bindGroupLayouts: [bindGroupLayout27]});
let textureView260 = texture41.createView({mipLevelCount: 1});
let computePassEncoder188 = commandEncoder232.beginComputePass({});
let renderPassEncoder43 = commandEncoder235.beginRenderPass({
  label: '\u006e\ue53f\u2982\ue239\u7747',
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 150.7, g: -779.8, b: -931.1, a: 424.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 71145002,
});
try {
computePassEncoder114.setBindGroup(3, bindGroup33, new Uint32Array(332), 18, 0);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder188.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder36.setBindGroup(3, bindGroup22);
} catch {}
try {
renderPassEncoder39.setBindGroup(2, bindGroup90, new Uint32Array(4399), 868, 0);
} catch {}
try {
buffer93.unmap();
} catch {}
try {
commandEncoder236.copyTextureToTexture({
  texture: texture77,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture93,
  mipLevel: 0,
  origin: {x: 24, y: 18, z: 1},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer187 = device0.createBuffer({size: 13793, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
try {
computePassEncoder183.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder14.setScissorRect(49, 0, 3, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer36, 'uint32', 2_148, 2_434);
} catch {}
try {
renderPassEncoder42.setVertexBuffer(5, buffer105);
} catch {}
try {
buffer135.unmap();
} catch {}
try {
commandEncoder236.clearBuffer(buffer127, 32, 24);
} catch {}
let commandEncoder237 = device0.createCommandEncoder();
let texture260 = device0.createTexture({
  size: [39],
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView261 = texture119.createView({label: '\u0944\u92b2\u9bee\u3b6f\ud220\u3642'});
let sampler150 = device0.createSampler({
  label: '\u0679\u07ee\uafc3\u7c5c\u01dd\u0ae7\udaa3\u2ca5',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 2.792,
  lodMaxClamp: 14.60,
});
try {
computePassEncoder168.setBindGroup(3, bindGroup42);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(3); };
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
let bindGroup140 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 337, resource: textureView57},
    {binding: 164, resource: textureView108},
    {binding: 270, resource: textureView120},
    {binding: 221, resource: textureView120},
    {binding: 47, resource: externalTexture8},
    {binding: 261, resource: {buffer: buffer74, offset: 2816, size: 1765}},
    {binding: 141, resource: sampler138},
    {binding: 78, resource: textureView176},
    {binding: 116, resource: sampler63},
    {binding: 54, resource: externalTexture3},
    {binding: 79, resource: textureView160},
    {binding: 311, resource: {buffer: buffer31, offset: 512, size: 53}},
    {binding: 119, resource: {buffer: buffer40, offset: 5376}},
    {binding: 667, resource: textureView136},
    {binding: 414, resource: textureView8},
    {binding: 26, resource: textureView121},
  ],
});
let commandEncoder238 = device0.createCommandEncoder({});
let computePassEncoder189 = commandEncoder238.beginComputePass();
try {
renderPassEncoder42.setBindGroup(1, bindGroup99);
} catch {}
let textureView262 = texture214.createView({});
let computePassEncoder190 = commandEncoder237.beginComputePass({});
try {
computePassEncoder97.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder40.setBindGroup(2, bindGroup114, new Uint32Array(3179), 2_023, 0);
} catch {}
try {
buffer33.unmap();
} catch {}
try {
computePassEncoder106.pushDebugGroup('\ua495');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame45 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'smpte170m'} });
let texture261 = device0.createTexture({
  size: [420],
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder191 = commandEncoder236.beginComputePass({});
try {
computePassEncoder168.setBindGroup(0, bindGroup80);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
buffer182.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture194,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(38).fill(89), /* required buffer size: 38 */
{offset: 38, bytesPerRow: 102}, {width: 6, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder190.setBindGroup(3, bindGroup121, new Uint32Array(1297), 88, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer29, 'uint32', 756, 15_956);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer92, 272, new DataView(new ArrayBuffer(6283)), 730, 128);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: canvas7,
  origin: { x: 33, y: 19 },
  flipY: false,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 4, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 6, depthOrArrayLayers: 0});
} catch {}
let sampler151 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 61.76,
  lodMaxClamp: 62.68,
  maxAnisotropy: 13,
});
try {
computePassEncoder186.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder43.setBindGroup(2, bindGroup62);
} catch {}
try {
renderPassEncoder39.executeBundles([renderBundle7]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture218,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 17},
  aspect: 'all',
}, new Uint8Array(87_175).fill(3), /* required buffer size: 87_175 */
{offset: 257, bytesPerRow: 298, rowsPerImage: 26}, {width: 25, height: 6, depthOrArrayLayers: 12});
} catch {}
try {
computePassEncoder145.end();
} catch {}
try {
computePassEncoder191.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer13, 'uint32', 148, 7);
} catch {}
try {
commandEncoder187.copyBufferToTexture({
  /* bytesInLastRow: 144 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2812 */
  offset: 2812,
  buffer: buffer93,
}, {
  texture: texture256,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 36, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder187.copyTextureToTexture({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture199,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let textureView263 = texture190.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 37});
let computePassEncoder192 = commandEncoder187.beginComputePass({});
let sampler152 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 90.28,
  maxAnisotropy: 7,
});
try {
computePassEncoder103.setBindGroup(1, bindGroup128);
} catch {}
try {
computePassEncoder138.setBindGroup(2, bindGroup126, new Uint32Array(664), 47, 0);
} catch {}
try {
computePassEncoder184.setPipeline(pipeline6);
} catch {}
let bindGroupLayout35 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 138,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
  ],
});
let commandEncoder239 = device0.createCommandEncoder({});
try {
computePassEncoder56.setBindGroup(1, bindGroup40, []);
} catch {}
try {
computePassEncoder122.setBindGroup(1, bindGroup46, new Uint32Array(467), 27, 0);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup52);
} catch {}
try {
renderPassEncoder42.beginOcclusionQuery(15);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer134, 'uint32', 252, 947);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(4_294_967_295, undefined, 0, 394_911_733);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let videoFrame46 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpte170m', transfer: 'gamma28curve'} });
let commandEncoder240 = device0.createCommandEncoder({label: '\u{1fb90}\u973e\u{1ff1a}'});
let texture262 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 7},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder15.setBindGroup(3, bindGroup44, new Uint32Array(5669), 2_466, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer178, 276); };
} catch {}
try {
commandEncoder239.copyTextureToTexture({
  texture: texture95,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture194,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
},
{width: 2, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer96, 60, new BigUint64Array(17026), 11888, 28);
} catch {}
try {
gpuCanvasContext11.unconfigure();
} catch {}
let texture263 = device0.createTexture({
  size: {width: 420, height: 1, depthOrArrayLayers: 1},
  format: 'rg16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView264 = texture95.createView({label: '\u143c\ub37d\u09f1\ue8b6\u{1f713}\u031d\u0c9f\u0cd0\u236d\u6c58', mipLevelCount: 1});
let computePassEncoder193 = commandEncoder240.beginComputePass({});
let sampler153 = device0.createSampler({
  label: '\u7e46\u{1fe94}\ua293\u0329\u0f55',
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 58.73,
  lodMaxClamp: 61.52,
});
let externalTexture36 = device0.importExternalTexture({source: videoFrame42});
try {
computePassEncoder76.setBindGroup(1, bindGroup54, new Uint32Array(533), 78, 0);
} catch {}
try {
renderPassEncoder4.setBlendConstant({ r: -910.0, g: 160.2, b: 264.7, a: -981.1, });
} catch {}
try {
computePassEncoder106.popDebugGroup();
} catch {}
try {
gpuCanvasContext13.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let texture264 = device0.createTexture({
  size: {width: 105},
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView265 = texture83.createView({
  label: '\u{1ff49}\u8b9b\uc5ca\u{1f889}\u0efe\u756f\u04c4\uc77e\u73c7\u3d7b\uc4ca',
  dimension: '2d',
  mipLevelCount: 1,
  baseArrayLayer: 27,
});
let sampler154 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 57.90,
  lodMaxClamp: 78.50,
});
try {
renderPassEncoder36.setIndexBuffer(buffer7, 'uint16', 3_874, 374);
} catch {}
try {
commandEncoder239.copyTextureToBuffer({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 560 */
  offset: 560,
  buffer: buffer151,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder37.insertDebugMarker('\u068e');
} catch {}
try {
device0.queue.writeBuffer(buffer50, 1612, new DataView(new ArrayBuffer(16903)), 69, 6028);
} catch {}
let buffer188 = device0.createBuffer({
  size: 13411,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder241 = device0.createCommandEncoder();
let textureView266 = texture119.createView({});
try {
renderPassEncoder37.setVertexBuffer(7, buffer145, 652);
} catch {}
let buffer189 = device0.createBuffer({
  size: 66,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder242 = device0.createCommandEncoder({label: '\u304c\u0b6f\u9156\u90b1\u0892\u{1fad8}\u014d\udcbc\u6dce\u3c6a\ub9d9'});
let texture265 = device0.createTexture({
  label: '\u9c0c\uec40\ueee9',
  size: [288],
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder194 = commandEncoder239.beginComputePass({});
try {
commandEncoder241.copyTextureToBuffer({
  texture: texture69,
  mipLevel: 0,
  origin: {x: 89, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1376 widthInBlocks: 86 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 6592 */
  offset: 6592,
  bytesPerRow: 1536,
  buffer: buffer185,
}, {width: 86, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let videoFrame47 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'linear'} });
try {
computePassEncoder146.setBindGroup(3, bindGroup16, []);
} catch {}
try {
renderPassEncoder29.setBindGroup(1, bindGroup28, new Uint32Array(704), 204, 0);
} catch {}
try {
renderPassEncoder42.endOcclusionQuery();
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer64, 'uint32', 5_608, 6_630);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer149, 396, 1_782);
} catch {}
try {
commandEncoder241.resolveQuerySet(querySet7, 181, 33, buffer83, 11008);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup141 = device0.createBindGroup({
  layout: bindGroupLayout25,
  entries: [
    {binding: 6, resource: textureView69},
    {binding: 1, resource: textureView120},
    {binding: 129, resource: textureView120},
    {binding: 252, resource: textureView72},
    {binding: 171, resource: textureView168},
  ],
});
let computePassEncoder195 = commandEncoder241.beginComputePass({});
let sampler155 = device0.createSampler({
  label: '\u13c4\u7396\u0448\uf643\u{1fc8d}',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 45.17,
  lodMaxClamp: 92.68,
  maxAnisotropy: 1,
});
try {
computePassEncoder122.setBindGroup(0, bindGroup2, new Uint32Array(3302), 726, 0);
} catch {}
try {
renderPassEncoder27.setBindGroup(2, bindGroup130);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer59, 'uint32', 5_512, 1_791);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(7, buffer156, 1_568);
} catch {}
try {
commandEncoder242.resolveQuerySet(querySet17, 16, 29, buffer92, 0);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
try {
computePassEncoder132.setBindGroup(3, bindGroup91, new Uint32Array(1395), 136, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer182, 9_956); };
} catch {}
try {
computePassEncoder18.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder40.setBindGroup(3, bindGroup126);
} catch {}
let promise32 = device0.queue.onSubmittedWorkDone();
let textureView267 = texture222.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1});
let computePassEncoder196 = commandEncoder242.beginComputePass();
let sampler156 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 10.83,
  lodMaxClamp: 94.70,
});
try {
computePassEncoder175.setPipeline(pipeline6);
} catch {}
try {
computePassEncoder192.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(7, buffer75, 2_280);
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
window.someLabel = externalTexture30.label;
} catch {}
let commandEncoder243 = device0.createCommandEncoder();
let computePassEncoder197 = commandEncoder243.beginComputePass();
let sampler157 = device0.createSampler({
  label: '\u03d6\u{1f92e}\u179a\u0500\u087b\u47c6\u0510\u{1f9f5}\ue426\ub335',
  addressModeU: 'mirror-repeat',
  lodMaxClamp: 92.01,
});
try {
computePassEncoder191.setBindGroup(3, bindGroup60, new Uint32Array(54), 1, 0);
} catch {}
try {
computePassEncoder195.setPipeline(pipeline0);
} catch {}
try {
buffer43.unmap();
} catch {}
let bindGroup142 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [{binding: 116, resource: textureView10}, {binding: 289, resource: textureView69}],
});
let buffer190 = device0.createBuffer({size: 6978, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let commandEncoder244 = device0.createCommandEncoder({});
let querySet29 = device0.createQuerySet({type: 'occlusion', count: 582});
let textureView268 = texture50.createView({baseMipLevel: 0});
let sampler158 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 60.71,
  lodMaxClamp: 79.45,
});
let externalTexture37 = device0.importExternalTexture({source: video1, colorSpace: 'srgb'});
try {
computePassEncoder16.setBindGroup(1, bindGroup49, new Uint32Array(877), 312, 0);
} catch {}
try {
computePassEncoder190.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder39.setBindGroup(3, bindGroup108, new Uint32Array(374), 34, 0);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(4, buffer80, 1_848, 983);
} catch {}
try {
commandEncoder244.copyTextureToBuffer({
  texture: texture175,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2378 */
  offset: 2378,
  bytesPerRow: 0,
  buffer: buffer23,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let texture266 = device0.createTexture({
  size: {width: 288},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView269 = texture181.createView({});
let computePassEncoder198 = commandEncoder244.beginComputePass({});
let sampler159 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 51.23,
  lodMaxClamp: 94.22,
});
try {
computePassEncoder156.setBindGroup(0, bindGroup67);
} catch {}
try {
computePassEncoder58.setBindGroup(1, bindGroup107, new Uint32Array(101), 6, 0);
} catch {}
try {
computePassEncoder182.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup34, new Uint32Array(5541), 61, 0);
} catch {}
try {
renderPassEncoder43.setViewport(32.37387151773498, 7.820299766423325, 3.2222153182686193, 1.2667530873184367, 0.013406054075805862, 0.4057562309826597);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(7, buffer165, 0, 0);
} catch {}
try {
  await promise32;
} catch {}
let texture267 = device0.createTexture({
  label: '\u87ee\u{1fefb}\u07b9',
  size: [105, 1, 7],
  sampleCount: 1,
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture268 = device0.createTexture({
  size: [39, 66, 240],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let texture269 = gpuCanvasContext7.getCurrentTexture();
let textureView270 = texture196.createView({label: '\u6a01\u{1f9b3}\u99bc\u4aeb\u0a46\u{1ff3c}'});
let sampler160 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 47.23,
  lodMaxClamp: 69.47,
  maxAnisotropy: 20,
});
try {
computePassEncoder4.setBindGroup(2, bindGroup102);
} catch {}
try {
computePassEncoder92.end();
} catch {}
try {
computePassEncoder197.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(3, buffer172, 324, 2_108);
} catch {}
try {
commandEncoder113.copyBufferToBuffer(buffer45, 968, buffer161, 10620, 640);
} catch {}
try {
renderPassEncoder39.insertDebugMarker('\u0054');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData26 = new ImageData(20, 20);
let commandEncoder245 = device0.createCommandEncoder({});
let computePassEncoder199 = commandEncoder113.beginComputePass({});
try {
computePassEncoder196.setBindGroup(2, bindGroup106);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer142, 'uint16', 318, 794);
} catch {}
try {
device0.queue.writeBuffer(buffer145, 1420, new DataView(new ArrayBuffer(27236)), 732, 1160);
} catch {}
try {
if (!arrayBuffer27.detached) { new Uint8Array(arrayBuffer27).fill(0x55); };
} catch {}
try {
window.someLabel = externalTexture12.label;
} catch {}
let computePassEncoder200 = commandEncoder245.beginComputePass({label: '\u{1ff24}\u0542\u{1ff7a}\u0852\u9461\u37f3\u08f5\u{1fec8}\u0d54'});
try {
renderPassEncoder42.setBindGroup(1, bindGroup142);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup43, new Uint32Array(1588), 146, 0);
} catch {}
try {
renderPassEncoder20.setViewport(21.593640914621584, 1.3022580725727324, 6.491412586649728, 1.0716900560722384, 0.7929351895307211, 0.8067627192732055);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(5, buffer46, 5_340);
} catch {}
try {
device0.queue.writeBuffer(buffer19, 4, new Float32Array(7830), 86, 4);
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); };
} catch {}
let bindGroup143 = device0.createBindGroup({layout: bindGroupLayout27, entries: [{binding: 313, resource: textureView39}]});
let commandEncoder246 = device0.createCommandEncoder({});
let textureView271 = texture138.createView({label: '\ub133\u0ba9'});
let computePassEncoder201 = commandEncoder246.beginComputePass({});
try {
renderPassEncoder41.setIndexBuffer(buffer22, 'uint16', 134, 87);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer13, 48, 55);
} catch {}
document.body.append(img3);
let texture270 = device0.createTexture({
  size: [9, 16, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler161 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 79.49,
  lodMaxClamp: 86.58,
  maxAnisotropy: 1,
});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroupsIndirect(buffer41, 5_204); };
} catch {}
let arrayBuffer30 = buffer45.getMappedRange(96, 28);
let pipeline7 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule0, entryPoint: 'compute0'}});
video1.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let buffer191 = device0.createBuffer({
  label: '\u9d28\u0ded\u{1fbe1}\u57b9\u0f0f',
  size: 8757,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture271 = device0.createTexture({
  size: [72, 24, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture272 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder24.setBindGroup(0, bindGroup111);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(39);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
buffer102.unmap();
} catch {}
try {
renderPassEncoder26.insertDebugMarker('\u0a46');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture130,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(61).fill(234), /* required buffer size: 61 */
{offset: 61, rowsPerImage: 114}, {width: 33, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder41.setBindGroup(2, bindGroup46);
} catch {}
try {
renderPassEncoder38.executeBundles([renderBundle20]);
} catch {}
try {
device0.queue.writeBuffer(buffer170, 324, new DataView(new ArrayBuffer(26159)), 2249, 260);
} catch {}
await gc();
let textureView272 = texture0.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder187.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer153, 'uint32', 316, 236);
} catch {}
try {
computePassEncoder100.insertDebugMarker('\u001b');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture242,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 17},
  aspect: 'all',
}, new Uint8Array(29_587).fill(210), /* required buffer size: 29_587 */
{offset: 99, bytesPerRow: 97, rowsPerImage: 38}, {width: 11, height: 0, depthOrArrayLayers: 9});
} catch {}
let bindGroup144 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 172, resource: sampler161},
    {binding: 228, resource: {buffer: buffer113, offset: 768, size: 4016}},
  ],
});
let sampler162 = device0.createSampler({addressModeU: 'repeat', mipmapFilter: 'nearest', lodMinClamp: 33.31, lodMaxClamp: 56.74});
try {
computePassEncoder113.setBindGroup(1, bindGroup14);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer176, 'uint32', 2_236, 143);
} catch {}
try {
buffer1.unmap();
} catch {}
await gc();
let promise33 = adapter0.requestAdapterInfo();
let bindGroup145 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 23, resource: textureView93},
    {binding: 505, resource: {buffer: buffer7, offset: 1280, size: 929}},
    {binding: 69, resource: textureView36},
    {binding: 4, resource: textureView162},
  ],
});
let pipelineLayout21 = device0.createPipelineLayout({label: '\u69ed\u{1fd8c}', bindGroupLayouts: [bindGroupLayout9, bindGroupLayout34]});
try {
computePassEncoder146.setBindGroup(0, bindGroup47, new Uint32Array(1578), 604, 0);
} catch {}
try {
computePassEncoder196.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer19, 20, new BigUint64Array(6927), 6, 0);
} catch {}
let bindGroup146 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer171, offset: 768, size: 2268}}],
});
let buffer192 = device0.createBuffer({
  label: '\u5208\u1ad5',
  size: 13291,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder247 = device0.createCommandEncoder({});
try {
computePassEncoder143.setBindGroup(3, bindGroup87);
} catch {}
try {
computePassEncoder193.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer28, 'uint32', 2_992, 6_987);
} catch {}
try {
texture162.destroy();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame28,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 98, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder248 = device0.createCommandEncoder({label: '\u4fff\u2d3c\u0e39\u0953\u627c\ud623\u{1fdcf}\u3696\u{1fe00}\ue3dc\u7e99'});
let computePassEncoder202 = commandEncoder248.beginComputePass({});
try {
computePassEncoder75.setBindGroup(3, bindGroup30);
} catch {}
try {
renderPassEncoder41.executeBundles([renderBundle17]);
} catch {}
let commandEncoder249 = device0.createCommandEncoder({label: '\uf8cd\u{1fe4a}\u0775\ucf6d\u0b6f\u0ef6\u4a1c\u07c8\u038f'});
try {
computePassEncoder148.dispatchWorkgroupsIndirect(buffer44, 1_260);
} catch {}
try {
computePassEncoder129.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup98, new Uint32Array(237), 74, 0);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer142, 'uint16', 2_694, 156);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
renderPassEncoder34.insertDebugMarker('\u456b');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture179,
  mipLevel: 2,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(84).fill(150), /* required buffer size: 84 */
{offset: 84}, {width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup147 = device0.createBindGroup({
  label: '\ue2f6\u07e0\u8b44\u{1fb6d}\u{1fd8f}\ucd22\u{1f6b0}\u0c9d\u0f17\u3b24\u0192',
  layout: bindGroupLayout12,
  entries: [
    {binding: 106, resource: {buffer: buffer75, offset: 256, size: 120}},
    {binding: 20, resource: textureView124},
    {binding: 74, resource: sampler137},
  ],
});
let computePassEncoder203 = commandEncoder249.beginComputePass();
try {
computePassEncoder58.setBindGroup(2, bindGroup87, new Uint32Array(149), 11, 0);
} catch {}
try {
computePassEncoder202.setPipeline(pipeline3);
} catch {}
let arrayBuffer31 = buffer45.getMappedRange(128, 12);
try {
gpuCanvasContext5.unconfigure();
} catch {}
let imageData27 = new ImageData(72, 12);
let commandEncoder250 = device0.createCommandEncoder({});
let textureView273 = texture267.createView({dimension: '2d', mipLevelCount: 1});
let textureView274 = texture267.createView({dimension: '2d', arrayLayerCount: 1});
let renderPassEncoder44 = commandEncoder250.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: -746.0, g: -694.2, b: 987.8, a: 325.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet28,
  maxDrawCount: 200633284,
});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroupsIndirect(buffer136, 792); };
} catch {}
try {
computePassEncoder203.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(6, buffer41);
} catch {}
try {
commandEncoder247.copyTextureToBuffer({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 97 */
  offset: 97,
  bytesPerRow: 256,
  buffer: buffer80,
}, {width: 8, height: 16, depthOrArrayLayers: 0});
} catch {}
try {
  await promise33;
} catch {}
let bindGroup148 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [{binding: 86, resource: sampler50}, {binding: 277, resource: textureView53}],
});
let sampler163 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 3.668,
  lodMaxClamp: 12.28,
  maxAnisotropy: 1,
});
try {
computePassEncoder138.setBindGroup(1, bindGroup129, new Uint32Array(1167), 389, 0);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer58, 'uint32', 172, 181);
} catch {}
try {
commandEncoder247.insertDebugMarker('\u{1fa22}');
} catch {}
let img6 = await imageWithData(2, 45, '#10101010', '#20202020');
let querySet30 = device0.createQuerySet({type: 'occlusion', count: 945});
let computePassEncoder204 = commandEncoder247.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroups(2, 1); };
} catch {}
try {
computePassEncoder198.setPipeline(pipeline3);
} catch {}
let commandEncoder251 = device0.createCommandEncoder({label: '\ua6e1\u0a02\udb32\u{1fc64}\u6ce4\u81c9\u{1fdcf}\uc482\u6945\ue45e'});
let computePassEncoder205 = commandEncoder251.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder185.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder29.setBindGroup(1, bindGroup10, new Uint32Array(2734), 336, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageData27,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture175,
  mipLevel: 0,
  origin: {x: 4, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder112.setBindGroup(0, bindGroup142);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer105, 280); };
} catch {}
try {
computePassEncoder205.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder26.setBindGroup(2, bindGroup6, new Uint32Array(167), 63, 0);
} catch {}
document.body.prepend(img5);
let commandEncoder252 = device0.createCommandEncoder({label: '\u09aa\u03a7\u{1fc0e}\u9d1e\udcab'});
try {
computePassEncoder183.setBindGroup(1, bindGroup95);
} catch {}
try {
computePassEncoder127.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder204.setPipeline(pipeline7);
} catch {}
let bindGroup149 = device0.createBindGroup({layout: bindGroupLayout11, entries: [{binding: 212, resource: textureView55}]});
let buffer193 = device0.createBuffer({
  size: 2182,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let externalTexture38 = device0.importExternalTexture({source: videoFrame28});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(2, 1, 2); };
} catch {}
try {
computePassEncoder189.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup93, []);
} catch {}
try {
renderPassEncoder43.setBindGroup(2, bindGroup95, new Uint32Array(3312), 74, 0);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle0, renderBundle7]);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer85, 'uint16', 324, 158);
} catch {}
let arrayBuffer32 = buffer174.getMappedRange();
try {
commandEncoder252.copyBufferToTexture({
  /* bytesInLastRow: 34 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5868 */
  offset: 5868,
  buffer: buffer86,
}, {
  texture: texture243,
  mipLevel: 0,
  origin: {x: 84, y: 0, z: 0},
  aspect: 'all',
}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder252.clearBuffer(buffer96, 24, 56);
} catch {}
document.body.append(video0);
try {
adapter1.label = '\u0fa4\ua544\u8285';
} catch {}
let texture273 = gpuCanvasContext11.getCurrentTexture();
let computePassEncoder206 = commandEncoder252.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer48, 12); };
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup121, new Uint32Array(2405), 113, 0);
} catch {}
try {
renderPassEncoder43.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer154, 'uint32', 56, 522);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
try {
computePassEncoder55.setBindGroup(1, bindGroup76, new Uint32Array(232), 1, 0);
} catch {}
try {
computePassEncoder201.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder44.setBlendConstant({ r: 12.45, g: 89.62, b: 144.8, a: -604.9, });
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer86, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 2, y: 23, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule15 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 15 max align: 1 */
struct T0 {
  @align(1) @size(15) f0: vec2i,
}
/* target size: 15 max align: 1 */
struct T1 {
  @align(1) @size(15) f0: array<atomic<u32>>,
}
/* target size: 8 max align: 8 */
struct T2 {
  f0: array<array<vec2i, 1>>,
}
/* target size: 14 max align: 2 */
struct T3 {
  @align(2) f0: atomic<i32>,
  @align(2) @size(10) f1: atomic<u32>,
}
/* target size: 58 max align: 2 */
struct T4 {
  @align(2) f0: vec2i,
  @align(2) @size(6) f1: array<atomic<i32>, 1>,
  @align(2) @size(44) f2: T2,
}
/* target size: 12 max align: 4 */
struct T5 {
  @align(4) f0: vec3u,
}
/* target size: 15 max align: 1 */
struct T6 {
  @align(1) @size(15) f0: array<atomic<u32>>,
}
@group(1) @binding(167) var sam12: sampler_comparison;
@group(0) @binding(388) var<uniform> buffer195: array<f16, 29>;
@group(1) @binding(643) var tex14: texture_3d<f32>;
@group(1) @binding(170) var tex13: texture_3d<i32>;
@group(0) @binding(159) var<storage, read> buffer197: array<vec2f>;
@group(1) @binding(101) var<uniform> buffer199: array<f16, 2>;
@group(0) @binding(238) var sam11: sampler;
@group(0) @binding(57) var st3: texture_storage_1d<rgba32float, write>;
@group(0) @binding(56) var tex10: texture_cube<f32>;
@group(0) @binding(286) var sam10: sampler;
@group(0) @binding(33) var<uniform> buffer196: array<array<array<u32, 1>, 7>, 1>;
@group(0) @binding(103) var tex11: texture_2d_array<f32>;
@group(0) @binding(313) var<storage, read> buffer194: vec4h;
@group(0) @binding(21) var tex9: texture_cube_array<u32>;
@group(0) @binding(151) var<uniform> buffer198: T0;
@group(0) @binding(309) var tex12: texture_cube<u32>;
@group(0) @binding(528) var sam9: sampler;
struct VertexOutput10 {
  @location(1) @interpolate(flat, centroid) f25: vec3i,
  @builtin(position) f26: vec4f,
  @location(9) @interpolate(perspective, center) f27: vec2f
}

@vertex
fn vertex0() -> VertexOutput10 {
  var out: VertexOutput10;
  _ = buffer196[0];
  _ = buffer197[arrayLength(&buffer197)];
  _ = buffer196[0][6][0];
  _ = textureSampleGrad(tex14, sam10, vec3f(), vec3f(), vec3f());
  return out;
}
struct FragmentOutput9 {
  @location(2) @interpolate(flat) f0: vec4i,
  @location(0) f1: vec4i,
  @location(1) f2: vec2f
}

@fragment
fn fragment0() -> FragmentOutput9 {
  var out: FragmentOutput9;
  _ = textureSampleLevel(tex11, sam11, vec2f(), 0, 0.0);
  _ = buffer199[1];
  _ = textureSampleBias(tex11, sam10, vec2f(), 0i, 0.0, vec2i());
  _ = buffer197;
  if bool(textureLoad(tex13, vec3i(), 0)[2]) {
    out.f2 = vec2f(0.1858, 0.3075);
  }
  textureStore(st3, 0, vec4f(0.1985, 0.04998, 0.09440, 0.1903));
  return out;
}
struct FragmentOutput10 {
  @location(2) @interpolate(linear) f0: vec4f,
  @location(0) f1: vec3f
}

@fragment
fn fragment1() -> FragmentOutput10 {
  var out: FragmentOutput10;
  _ = textureGather(2, tex11, sam11, vec2f(), 0i);
  _ = textureLoad(tex11, vec2i(), 0, 0);
  return out;
}`,
});
let commandEncoder253 = device0.createCommandEncoder({});
let textureView275 = texture147.createView({dimension: '2d'});
let texture274 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 166},
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder45 = commandEncoder253.beginRenderPass({
  colorAttachments: [{
  view: textureView85,
  clearValue: { r: -307.9, g: 681.3, b: -384.9, a: -906.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet12,
});
try {
renderPassEncoder22.setIndexBuffer(buffer142, 'uint32', 264, 1_391);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(3, buffer157, 2_312, 60);
} catch {}
let promise34 = device0.queue.onSubmittedWorkDone();
try {
  await promise34;
} catch {}
let querySet31 = device0.createQuerySet({label: '\ueb70\u0c02\u{1fc3b}\uf73d\u7d32\ufb31\u0c0e\u794d\u75ba', type: 'occlusion', count: 4});
try {
computePassEncoder69.end();
} catch {}
try {
computePassEncoder194.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder38.setBindGroup(0, bindGroup71);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 105, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame29,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture256,
  mipLevel: 1,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u059e\u2ce1\u524f\u8da2';
} catch {}
let buffer200 = device0.createBuffer({
  label: '\u{1fd7b}\u{1fa3d}\u0188\ueaa7\uccc9\u051a\u8788\u9241',
  size: 18493,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder254 = device0.createCommandEncoder({});
let textureView276 = texture266.createView({label: '\u2297\u5d67\u94e9', mipLevelCount: 1});
let renderPassEncoder46 = commandEncoder84.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: 101.0, g: 555.7, b: 594.7, a: -577.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 615932618,
});
let sampler164 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 45.18,
  lodMaxClamp: 86.23,
  compare: 'not-equal',
});
let externalTexture39 = device0.importExternalTexture({source: videoFrame38});
try {
computePassEncoder200.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(2, buffer55);
} catch {}
let pipeline8 = device0.createRenderPipeline({
  label: '\u8599\u0a55\u27e1\u5be5',
  layout: pipelineLayout12,
  fragment: {
  module: shaderModule9,
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA}, {format: 'rg32float'}, {format: 'rgba16sint'}],
},
  vertex: {
    module: shaderModule10,
    constants: {43_440: 1},
    buffers: [
      {
        arrayStride: 156,
        attributes: [
          {format: 'uint8x4', offset: 24, shaderLocation: 8},
          {format: 'float16x2', offset: 12, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 15},
          {format: 'float32x4', offset: 24, shaderLocation: 12},
          {format: 'sint32', offset: 4, shaderLocation: 5},
          {format: 'unorm8x2', offset: 54, shaderLocation: 14},
          {format: 'uint32', offset: 12, shaderLocation: 4},
          {format: 'float32', offset: 56, shaderLocation: 11},
          {format: 'snorm8x2', offset: 32, shaderLocation: 6},
          {format: 'uint32x3', offset: 48, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: false},
});
try {
  await adapter0.requestAdapterInfo();
} catch {}
let buffer201 = device0.createBuffer({size: 5491, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder255 = device0.createCommandEncoder();
let texture275 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 11},
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler165 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.96,
  maxAnisotropy: 16,
});
try {
computePassEncoder73.end();
} catch {}
try {
computePassEncoder206.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder41.setStencilReference(121);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
buffer109.unmap();
} catch {}
try {
commandEncoder62.copyBufferToBuffer(buffer10, 1524, buffer91, 8, 440);
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 7, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(18).fill(137), /* required buffer size: 18 */
{offset: 18, bytesPerRow: 91}, {width: 3, height: 14, depthOrArrayLayers: 0});
} catch {}
let buffer202 = device0.createBuffer({
  size: 16592,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder17.setBindGroup(2, bindGroup14);
} catch {}
try {
computePassEncoder199.setPipeline(pipeline6);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture276 = device0.createTexture({
  label: '\u2076\u04c7\u1e68',
  size: {width: 39, height: 66, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
});
} catch {}
let bindGroupLayout36 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 186,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 558,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 146,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 29,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let texture277 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder47 = commandEncoder62.beginRenderPass({
  colorAttachments: [{view: textureView202, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 101022514,
});
try {
computePassEncoder126.setBindGroup(2, bindGroup111);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup113);
} catch {}
try {
renderPassEncoder45.setIndexBuffer(buffer177, 'uint32', 996, 91);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 26, y: 54 },
  flipY: false,
}, {
  texture: texture175,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let buffer203 = device0.createBuffer({
  label: '\udc77\u{1ff6b}\u047c\u0a3c\u79d5\u7aa9\u0718',
  size: 20025,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
try {
computePassEncoder129.setBindGroup(1, bindGroup33);
} catch {}
try {
computePassEncoder16.setBindGroup(0, bindGroup38, new Uint32Array(611), 80, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroupsIndirect(buffer167, 1_984); };
} catch {}
try {
renderPassEncoder41.setBindGroup(3, bindGroup99, []);
} catch {}
try {
commandEncoder255.resolveQuerySet(querySet6, 27, 9, buffer108, 0);
} catch {}
let bindGroup150 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView10}]});
let textureView277 = texture201.createView({label: '\u0dc1\u75f2\u{1ffc8}\uf718\u83d6\u7979', baseArrayLayer: 6, arrayLayerCount: 7});
let computePassEncoder207 = commandEncoder254.beginComputePass({});
let renderBundleEncoder31 = device0.createRenderBundleEncoder({label: '\u7606\u1f1b\u201a', colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true});
let renderBundle31 = renderBundleEncoder31.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder47.setBindGroup(0, bindGroup76);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup29, new Uint32Array(3497), 502, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
try {
commandEncoder255.copyTextureToTexture({
  texture: texture209,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
},
{width: 72, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas8);
let bindGroup151 = device0.createBindGroup({layout: bindGroupLayout26, entries: [{binding: 42, resource: textureView174}]});
let buffer204 = device0.createBuffer({
  size: 961,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let computePassEncoder208 = commandEncoder255.beginComputePass({});
try {
computePassEncoder204.setBindGroup(3, bindGroup129, new Uint32Array(1719), 56, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer60, 'uint16', 454, 872);
} catch {}
let texture278 = device0.createTexture({
  size: [144, 48, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let sampler166 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 12.28,
  lodMaxClamp: 52.14,
  maxAnisotropy: 6,
});
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer153, 440); };
} catch {}
try {
computePassEncoder208.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(4, buffer131, 628, 1_492);
} catch {}
document.body.append(video1);
let buffer205 = device0.createBuffer({size: 572, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder256 = device0.createCommandEncoder();
let texture279 = device0.createTexture({
  size: [420, 1, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView278 = texture155.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 0});
try {
computePassEncoder147.setBindGroup(0, bindGroup55);
} catch {}
try {
computePassEncoder207.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder32.setBindGroup(3, bindGroup78);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer58, 'uint16', 224, 76);
} catch {}
try {
buffer34.unmap();
} catch {}
try {
commandEncoder256.copyTextureToTexture({
  texture: texture141,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 12},
  aspect: 'all',
},
{
  texture: texture177,
  mipLevel: 0,
  origin: {x: 376, y: 0, z: 0},
  aspect: 'all',
},
{width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 105, height: 1, depthOrArrayLayers: 298}
*/
{
  source: videoFrame20,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture248,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 227},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas6);
await gc();
try {
computePassEncoder158.setBindGroup(0, bindGroup24, new Uint32Array(1500), 19, 0);
} catch {}
try {
renderPassEncoder43.setBindGroup(1, bindGroup113);
} catch {}
try {
renderPassEncoder27.setViewport(6.1716443619650505, 7.859509410146085, 1.0064044234287484, 4.169388993687892, 0.129974987323503, 0.7432132631064163);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
let videoFrame48 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'film', transfer: 'bt1361ExtendedColourGamut'} });
let commandEncoder257 = device0.createCommandEncoder({});
let computePassEncoder209 = commandEncoder257.beginComputePass({});
try {
computePassEncoder209.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder33.executeBundles([renderBundle6, renderBundle6]);
} catch {}
let bindGroup152 = device0.createBindGroup({
  label: '\u2976\u{1f6f8}\u6d58\u9a04\ued53\u{1fe56}',
  layout: bindGroupLayout12,
  entries: [
    {binding: 74, resource: sampler140},
    {binding: 20, resource: textureView118},
    {binding: 106, resource: {buffer: buffer30, offset: 0, size: 180}},
  ],
});
let texture280 = device0.createTexture({
  size: {width: 78},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16sint'],
});
try {
computePassEncoder91.setBindGroup(1, bindGroup112);
} catch {}
try {
renderPassEncoder38.executeBundles([renderBundle17, renderBundle17, renderBundle7, renderBundle0, renderBundle7]);
} catch {}
try {
commandEncoder256.resolveQuerySet(querySet21, 22, 44, buffer39, 512);
} catch {}
let commandEncoder258 = device0.createCommandEncoder({label: '\uf110\u{1fafa}\u{1ffc6}\u{1f7a6}\u{1ff5c}\u0212\u{1fe34}\u04aa\u0a88'});
let texture281 = device0.createTexture({
  label: '\u0b8c\uc947\u{1f886}\u0bff\u03a9\u76e2\u{1ff66}\u3949',
  size: [840],
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView279 = texture95.createView({mipLevelCount: 1});
let computePassEncoder210 = commandEncoder258.beginComputePass({});
let renderPassEncoder48 = commandEncoder256.beginRenderPass({
  label: '\u08e4\udf16\u863a\u70ac\u9bb0\u0f0d',
  colorAttachments: [{
  view: textureView171,
  clearValue: { r: 484.7, g: 498.1, b: 43.99, a: -268.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder210.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder30.beginOcclusionQuery(81);
} catch {}
let commandEncoder259 = device0.createCommandEncoder({});
let computePassEncoder211 = commandEncoder259.beginComputePass({});
let renderBundleEncoder32 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true, stencilReadOnly: true});
let externalTexture40 = device0.importExternalTexture({source: videoFrame36});
try {
computePassEncoder13.setBindGroup(1, bindGroup124);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(5, buffer185, 2_700);
} catch {}
try {
renderBundleEncoder32.setBindGroup(2, bindGroup128);
} catch {}
let arrayBuffer33 = buffer104.getMappedRange(0, 4868);
try {
buffer76.unmap();
} catch {}
let imageData28 = new ImageData(48, 64);
let bindGroup153 = device0.createBindGroup({layout: bindGroupLayout26, entries: [{binding: 42, resource: textureView174}]});
let commandEncoder260 = device0.createCommandEncoder({});
try {
computePassEncoder211.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(0, buffer66, 0);
} catch {}
try {
renderBundleEncoder32.setBindGroup(0, bindGroup12, new Uint32Array(1883), 141, 0);
} catch {}
try {
computePassEncoder11.insertDebugMarker('\u4e3c');
} catch {}
let commandEncoder261 = device0.createCommandEncoder({});
let computePassEncoder212 = commandEncoder261.beginComputePass({});
let renderBundle32 = renderBundleEncoder32.finish({});
try {
computePassEncoder80.setBindGroup(1, bindGroup6);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroupsIndirect(buffer74, 2_844); };
} catch {}
try {
computePassEncoder212.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setStencilReference(316);
} catch {}
try {
renderPassEncoder45.setIndexBuffer(buffer74, 'uint32', 5_400, 6_962);
} catch {}
let pipeline9 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout21,
  fragment: {
  module: shaderModule15,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint'}, {format: 'rg32float', writeMask: 0}, {format: 'rgba16sint'}],
},
  vertex: {module: shaderModule15, constants: {}, buffers: []},
  primitive: {frontFace: 'cw'},
});
canvas8.height = 1141;
let commandEncoder262 = device0.createCommandEncoder({label: '\u0773\u2c59\u01e7\u0402'});
let computePassEncoder213 = commandEncoder262.beginComputePass();
try {
computePassEncoder213.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder48.setBindGroup(1, bindGroup130, new Uint32Array(192), 5, 0);
} catch {}
try {
renderPassEncoder45.beginOcclusionQuery(70);
} catch {}
try {
renderPassEncoder41.setIndexBuffer(buffer161, 'uint16', 9_132, 1_050);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture123,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(396).fill(42), /* required buffer size: 396 */
{offset: 396}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder263 = device0.createCommandEncoder({});
let texture282 = device0.createTexture({
  size: [72, 24, 19],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let externalTexture41 = device0.importExternalTexture({label: '\u0d73\u026c\u{1f6aa}\u495b', source: video1});
try {
computePassEncoder54.setBindGroup(3, bindGroup77, new Uint32Array(1867), 25, 0);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(6, buffer156);
} catch {}
let promise35 = device0.queue.onSubmittedWorkDone();
document.body.prepend(video0);
let buffer206 = device0.createBuffer({
  label: '\u{1fe69}\u6ab6\ucc6c',
  size: 23077,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder209.end();
} catch {}
try {
renderPassEncoder30.endOcclusionQuery();
} catch {}
try {
commandEncoder263.copyTextureToBuffer({
  texture: texture225,
  mipLevel: 0,
  origin: {x: 20, y: 6, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 96 widthInBlocks: 24 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1608 */
  offset: 1608,
  bytesPerRow: 512,
  buffer: buffer65,
}, {width: 24, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
  await promise35;
} catch {}
let shaderModule16 = device0.createShaderModule({
  code: `
enable f16;
enable f16;
/* target size: 42 max align: 2 */
struct T0 {
  @align(2) @size(42) f0: mat2x2h,
}
/* target size: 8 max align: 8 */
struct T1 {
  @size(8) f0: vec2h,
}
/* target size: 16 max align: 16 */
struct T2 {
  f0: array<vec2u, 2>,
}
@id(55578) override override70 : u32;
override override75 : i32;
@id(39834) override override74 : f16 = -31595.6;
@id(680) override override72 : u32;
@id(47591) override override76 : u32 = 350;
@id(18621) override override71 : bool;
@id(31984) override override73 : f16 = -52322.7;
@group(0) @binding(74) var sam13: sampler_comparison;
@group(0) @binding(20) var st4: texture_storage_2d<rg32sint, read>;
@group(0) @binding(106) var<storage, read_write> buffer207: T2;
struct VertexOutput11 {
  @builtin(position) @invariant f28: vec4f,
  @location(11) @interpolate(perspective, centroid) f29: f16,
  @location(10) @interpolate(flat, center) f30: vec3u,
  @location(15) f31: vec4f,
  @location(3) @interpolate(flat, centroid) f32: vec2u
}

@vertex
fn vertex0(@location(15) a0: vec4f, @location(12) a1: i32, @location(4) a2: f16, @location(7) a3: vec4i, @location(3) @interpolate(perspective, center) a4: vec3h, @location(8) a5: vec2h) -> VertexOutput11 {
  var out: VertexOutput11;
  _ = a4;
  _ = override72;
  return out;
}

@fragment
fn fragment0(@location(12) @interpolate(flat) a0: vec3i) -> @location(200) @interpolate(perspective) vec3f {
  var out: vec3f;
  _ = a0;
  _ = buffer207.f0;
  if override71 {
    buffer207.f0[1] = vec2u(425, 146);
  }
  return out;
}
struct FragmentOutput11 {
  @location(1) @interpolate(flat, sample) f0: vec3i,
  @location(0) @interpolate(perspective, centroid) f1: vec4f
}

@fragment
fn fragment1() -> FragmentOutput11 {
  var out: FragmentOutput11;
  _ = override70;
  _ = buffer207.f0[1];
  out.f0 = vec3i(bitcast<i32>(override75));
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let textureView280 = texture114.createView({label: '\uaed2\uae2e\u0f26\u0505\u2ff5', dimension: '2d-array', mipLevelCount: 1});
try {
device0.queue.writeTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(96).fill(102), /* required buffer size: 96 */
{offset: 96, bytesPerRow: 290}, {width: 288, height: 96, depthOrArrayLayers: 0});
} catch {}
let bindGroup154 = device0.createBindGroup({
  label: '\u5417\u06b1\uf37e',
  layout: bindGroupLayout0,
  entries: [{binding: 65, resource: textureView8}],
});
let buffer208 = device0.createBuffer({
  label: '\u01fd\u77f7\u8b4c\u4cca\u{1fc1e}\u096e\u{1f94a}\u98f3',
  size: 38189,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder214 = commandEncoder260.beginComputePass({});
try {
computePassEncoder204.setBindGroup(1, bindGroup112);
} catch {}
try {
computePassEncoder214.setPipeline(pipeline4);
} catch {}
let arrayBuffer34 = buffer47.getMappedRange(760, 248);
let bindGroup155 = device0.createBindGroup({
  layout: bindGroupLayout33,
  entries: [{binding: 566, resource: textureView8}, {binding: 834, resource: textureView171}],
});
let commandEncoder264 = device0.createCommandEncoder();
let sampler167 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 62.39,
  lodMaxClamp: 77.43,
});
try {
renderPassEncoder41.executeBundles([renderBundle10]);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer209 = device0.createBuffer({
  size: 704,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture283 = device0.createTexture({
  label: '\ueac3\u{1ff65}',
  size: {width: 144, height: 48, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder215 = commandEncoder263.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroups(1); };
} catch {}
try {
commandEncoder264.resolveQuerySet(querySet19, 1, 4, buffer56, 0);
} catch {}
try {
commandEncoder257.insertDebugMarker('\u{1f79b}');
} catch {}
let videoFrame49 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt2020', transfer: 'logSqrt'} });
let bindGroup156 = device0.createBindGroup({
  label: '\u{1ff76}\u11fa\uf9cb\u18ed\u476a\u6e27\u4b4a\u01e5\u00b6',
  layout: bindGroupLayout30,
  entries: [{binding: 176, resource: {buffer: buffer14, offset: 256, size: 600}}],
});
let buffer210 = device0.createBuffer({
  size: 6019,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder265 = device0.createCommandEncoder();
let querySet32 = device0.createQuerySet({type: 'occlusion', count: 314});
let sampler168 = device0.createSampler({
  label: '\u7b3a\u74c4\u0757\ufa00\ube1b\u0735\u{1f85a}\ud44e\u{1f647}\u0062',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 80.96,
});
try {
computePassEncoder126.setBindGroup(3, bindGroup82);
} catch {}
try {
computePassEncoder215.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder20.end();
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer78, 0);
} catch {}
await gc();
try {
window.someLabel = externalTexture40.label;
} catch {}
let bindGroupLayout37 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 63,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer211 = device0.createBuffer({
  size: 20683,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder37.dispatchWorkgroups(2);
} catch {}
try {
renderPassEncoder24.setViewport(6.2240973074806885, 1.8943377073900955, 25.962312559772144, 9.256623961554942, 0.18785409037503342, 0.786225148661541);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture83,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 26},
  aspect: 'all',
}, new Uint8Array(2_814).fill(223), /* required buffer size: 2_814 */
{offset: 262, bytesPerRow: 58, rowsPerImage: 11}, {width: 9, height: 0, depthOrArrayLayers: 5});
} catch {}
document.body.prepend(video0);
let querySet33 = device0.createQuerySet({type: 'occlusion', count: 1222});
try {
computePassEncoder205.setBindGroup(0, bindGroup35, new Uint32Array(42), 1, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder32.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer156, 'uint16', 9_192, 172);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(5, undefined, 151_946_359);
} catch {}
let textureView281 = texture225.createView({label: '\u5c45\u{1f645}\u0674\u0150\u8151\u9b00'});
let computePassEncoder216 = commandEncoder265.beginComputePass({});
try {
computePassEncoder216.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup97);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup2, new Uint32Array(112), 10, 0);
} catch {}
try {
commandEncoder257.insertDebugMarker('\uebce');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture99,
  mipLevel: 4,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(29).fill(219), /* required buffer size: 29 */
{offset: 29, bytesPerRow: 104, rowsPerImage: 95}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroupLayout38 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 116,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 208, visibility: 0, buffer: { type: 'read-only-storage', hasDynamicOffset: false }},
    {
      binding: 166,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 158, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 131,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 222,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 209,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 15,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 752,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 396,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let bindGroup157 = device0.createBindGroup({
  label: '\u1152\u686e\u0b2d\u{1ffd9}\u0e7a\udc6c\u0901\u0ac0\u043a\u{1fc3f}\u07f0',
  layout: bindGroupLayout31,
  entries: [{binding: 9, resource: textureView57}, {binding: 80, resource: textureView187}],
});
try {
computePassEncoder187.setBindGroup(3, bindGroup45);
} catch {}
try {
computePassEncoder57.setBindGroup(3, bindGroup97, new Uint32Array(1001), 143, 0);
} catch {}
try {
renderPassEncoder45.endOcclusionQuery();
} catch {}
try {
if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); };
} catch {}
let buffer212 = device0.createBuffer({
  label: '\u9fb6\u89af\u{1f756}\u177f\u{1fc32}\ua1db',
  size: 19590,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let computePassEncoder217 = commandEncoder264.beginComputePass({});
try {
renderPassEncoder32.setBindGroup(2, bindGroup82, []);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer13, 0);
} catch {}
try {
commandEncoder257.copyBufferToBuffer(buffer101, 40, buffer50, 25472, 9904);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture215,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(42).fill(98), /* required buffer size: 42 */
{offset: 42}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder266 = device0.createCommandEncoder({});
let texture284 = device0.createTexture({
  size: [36],
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder152.setBindGroup(0, bindGroup63);
} catch {}
try {
computePassEncoder118.setBindGroup(0, bindGroup157, new Uint32Array(2011), 988, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroupsIndirect(buffer26, 784); };
} catch {}
try {
computePassEncoder217.setPipeline(pipeline1);
} catch {}
try {
commandEncoder257.copyTextureToBuffer({
  texture: texture92,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 200 */
  offset: 200,
  buffer: buffer64,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture55,
  mipLevel: 0,
  origin: {x: 60, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(324).fill(29), /* required buffer size: 324 */
{offset: 324, bytesPerRow: 1279}, {width: 155, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 840, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame47,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture99,
  mipLevel: 0,
  origin: {x: 233, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas9 = document.createElement('canvas');
let computePassEncoder218 = commandEncoder257.beginComputePass({});
try {
computePassEncoder183.setBindGroup(1, bindGroup73, new Uint32Array(1356), 167, 0);
} catch {}
try {
computePassEncoder218.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder30.setBindGroup(2, bindGroup116, new Uint32Array(273), 6, 0);
} catch {}
try {
renderPassEncoder30.beginOcclusionQuery(96);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer118, 'uint16', 740, 510);
} catch {}
try {
querySet25.destroy();
} catch {}
try {
computePassEncoder47.insertDebugMarker('\u073b');
} catch {}
let videoFrame50 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'unspecified', transfer: 'iec61966-2-1'} });
try {
window.someLabel = textureView126.label;
} catch {}
let sampler169 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 84.48,
  maxAnisotropy: 16,
});
try {
computePassEncoder40.setBindGroup(1, bindGroup26, new Uint32Array(227), 27, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup127);
} catch {}
try {
renderPassEncoder44.setBindGroup(2, bindGroup7, new Uint32Array(10000), 833, 0);
} catch {}
try {
commandEncoder266.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 44 */
  offset: 44,
  rowsPerImage: 196,
  buffer: buffer65,
}, {
  texture: texture267,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame24,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer213 = device0.createBuffer({
  size: 3553,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder267 = device0.createCommandEncoder({});
let computePassEncoder219 = commandEncoder266.beginComputePass({});
let sampler170 = device0.createSampler({
  label: '\u168e\u0a5c\uf6b4\u{1f9fb}\u061c\uff5e\u{1f81b}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 97.45,
  lodMaxClamp: 98.48,
  maxAnisotropy: 4,
});
try {
computePassEncoder6.setBindGroup(3, bindGroup57, new Uint32Array(1855), 92, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder219.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(5, buffer108, 48, 27);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let videoFrame51 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'iec61966-2-1'} });
let commandEncoder268 = device0.createCommandEncoder({});
let texture285 = device0.createTexture({
  size: {width: 288},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder220 = commandEncoder268.beginComputePass({});
try {
computePassEncoder117.setBindGroup(0, bindGroup62, []);
} catch {}
try {
computePassEncoder90.setBindGroup(0, bindGroup17, new Uint32Array(3160), 559, 0);
} catch {}
try {
renderPassEncoder36.setBindGroup(0, bindGroup112, new Uint32Array(3992), 356, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(17);
} catch {}
try {
commandEncoder267.copyBufferToBuffer(buffer205, 12, buffer149, 748, 52);
} catch {}
await gc();
let commandEncoder269 = device0.createCommandEncoder({});
let commandBuffer14 = commandEncoder269.finish({});
let textureView282 = texture89.createView({mipLevelCount: 1});
let computePassEncoder221 = commandEncoder267.beginComputePass({});
try {
computePassEncoder221.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder26.setBindGroup(0, bindGroup27, []);
} catch {}
try {
renderPassEncoder44.beginOcclusionQuery(177);
} catch {}
let videoFrame52 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpteRp431', transfer: 'iec61966-2-1'} });
let querySet34 = device0.createQuerySet({type: 'occlusion', count: 205});
let texture286 = device0.createTexture({
  size: {width: 144, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler171 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 93.36,
  lodMaxClamp: 93.54,
  maxAnisotropy: 7,
});
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer47, 1_532); };
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup8, []);
} catch {}
let gpuCanvasContext14 = canvas9.getContext('webgpu');
let bindGroup158 = device0.createBindGroup({
  layout: bindGroupLayout38,
  entries: [
    {binding: 158, resource: externalTexture36},
    {binding: 131, resource: sampler31},
    {binding: 396, resource: {buffer: buffer171, offset: 256, size: 2260}},
    {binding: 75, resource: textureView77},
    {binding: 15, resource: textureView246},
    {binding: 209, resource: {buffer: buffer82, offset: 0, size: 1664}},
    {binding: 116, resource: {buffer: buffer147, offset: 7168, size: 440}},
    {binding: 222, resource: {buffer: buffer107, offset: 0, size: 348}},
    {binding: 166, resource: {buffer: buffer179, offset: 512, size: 7358}},
    {binding: 208, resource: {buffer: buffer26, offset: 4352, size: 132}},
    {binding: 752, resource: {buffer: buffer43, offset: 0, size: 1526}},
  ],
});
let texture287 = gpuCanvasContext1.getCurrentTexture();
let textureView283 = texture214.createView({});
try {
computePassEncoder152.setBindGroup(2, bindGroup35);
} catch {}
try {
computePassEncoder198.setBindGroup(3, bindGroup30, new Uint32Array(136), 18, 0);
} catch {}
try {
computePassEncoder220.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder47.setScissorRect(1, 0, 4, 0);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(4, buffer138, 0, 151);
} catch {}
try {
computePassEncoder56.insertDebugMarker('\u0355');
} catch {}
let bindGroup159 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [{binding: 41, resource: textureView194}, {binding: 228, resource: textureView85}],
});
let commandEncoder270 = device0.createCommandEncoder({});
let computePassEncoder222 = commandEncoder270.beginComputePass({});
let sampler172 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 57.38,
  lodMaxClamp: 72.72,
  compare: 'not-equal',
});
let externalTexture42 = device0.importExternalTexture({source: videoFrame6});
try {
computePassEncoder5.setBindGroup(1, bindGroup107, new Uint32Array(4439), 656, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder32.setScissorRect(7, 8, 0, 0);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer78, 'uint32', 5_880, 3_351);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(6, buffer91, 0);
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let imageBitmap9 = await createImageBitmap(videoFrame1);
let textureView284 = texture254.createView({dimension: '2d-array'});
let sampler173 = device0.createSampler({
  label: '\u{1fda0}\u0f2d\u0fe9\udef7\u1204',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 97.95,
  compare: 'equal',
});
try {
computePassEncoder195.setBindGroup(0, bindGroup65, []);
} catch {}
try {
computePassEncoder123.setBindGroup(3, bindGroup15, new Uint32Array(402), 270, 0);
} catch {}
try {
renderPassEncoder45.executeBundles([renderBundle10]);
} catch {}
try {
renderPassEncoder22.setStencilReference(1658);
} catch {}
try {
renderPassEncoder42.setViewport(26.545117846335764, 10.94005940581572, 5.933836604300103, 0.8747140960858988, 0.5247865956535904, 0.6302974141527511);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture195,
  mipLevel: 0,
  origin: {x: 17, y: 3, z: 5},
  aspect: 'all',
}, new Uint8Array(73).fill(37), /* required buffer size: 73 */
{offset: 73, rowsPerImage: 33}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup160 = device0.createBindGroup({layout: bindGroupLayout22, entries: [{binding: 4, resource: textureView235}]});
let buffer214 = device0.createBuffer({
  size: 2150,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let querySet35 = device0.createQuerySet({type: 'occlusion', count: 173});
try {
renderPassEncoder24.setBindGroup(1, bindGroup51, new Uint32Array(1229), 191, 0);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer141, 'uint16', 1_236, 1_091);
} catch {}
document.body.prepend(canvas2);
let bindGroup161 = device0.createBindGroup({layout: bindGroupLayout32, entries: [{binding: 51, resource: textureView129}]});
let texture288 = gpuCanvasContext9.getCurrentTexture();
try {
computePassEncoder222.setPipeline(pipeline6);
} catch {}
let buffer215 = device0.createBuffer({
  size: 60276,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let textureView285 = texture142.createView({dimension: '2d-array'});
try {
renderPassEncoder22.setIndexBuffer(buffer37, 'uint32', 192, 468);
} catch {}
let videoFrame53 = new VideoFrame(videoFrame41, {timestamp: 0});
let bindGroup162 = device0.createBindGroup({
  label: '\u0cbe\u{1fda4}',
  layout: bindGroupLayout14,
  entries: [
    {binding: 69, resource: textureView185},
    {binding: 23, resource: textureView196},
    {binding: 505, resource: {buffer: buffer193, offset: 0, size: 232}},
    {binding: 4, resource: textureView93},
  ],
});
let textureView286 = texture172.createView({
  label: '\ue43e\u65d1\u2161\u0316\uea08\u3208\u0048\u61c5\u8368\ua740\u17ad',
  baseMipLevel: 0,
  baseArrayLayer: 0,
});
let sampler174 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 27.43,
  compare: 'equal',
});
try {
computePassEncoder87.end();
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup90, new Uint32Array(5408), 2_117, 0);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer22, 'uint32', 120, 931);
} catch {}
try {
renderPassEncoder32.insertDebugMarker('\ud717');
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let bindGroup163 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [{binding: 116, resource: textureView93}, {binding: 289, resource: textureView9}],
});
let commandBuffer15 = commandEncoder107.finish({});
let sampler175 = device0.createSampler({minFilter: 'linear', mipmapFilter: 'linear', lodMinClamp: 8.328, lodMaxClamp: 55.64});
try {
renderPassEncoder45.beginOcclusionQuery(20);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer42, 'uint16', 512, 194);
} catch {}
try {
if (!arrayBuffer23.detached) { new Uint8Array(arrayBuffer23).fill(0x55); };
} catch {}
let bindGroup164 = device0.createBindGroup({
  label: '\u0006\u0381',
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer71, offset: 0, size: 684}}],
});
let commandEncoder271 = device0.createCommandEncoder({});
let textureView287 = texture94.createView({});
let computePassEncoder223 = commandEncoder271.beginComputePass({});
try {
computePassEncoder223.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder43.setBindGroup(2, bindGroup19, new Uint32Array(627), 30, 0);
} catch {}
video1.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let bindGroup165 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer135, offset: 256, size: 160}}],
});
let texture289 = device0.createTexture({size: [9, 16, 629], dimension: '3d', format: 'rg16sint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder144.setBindGroup(2, bindGroup112);
} catch {}
try {
renderPassEncoder44.setBindGroup(3, bindGroup146);
} catch {}
try {
renderPassEncoder44.endOcclusionQuery();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); };
} catch {}
let imageData29 = new ImageData(76, 60);
let texture290 = device0.createTexture({
  label: '\u4882\u{1fdf2}\ub24e\u9ef0',
  size: [144, 48, 571],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroupsIndirect(buffer6, 2_840); };
} catch {}
try {
renderPassEncoder29.setBindGroup(3, bindGroup25, new Uint32Array(1292), 516, 0);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(4, buffer12);
} catch {}
try {
device0.queue.submit([commandBuffer15]);
} catch {}
let pipeline10 = device0.createRenderPipeline({
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule8,
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex0',
    constants: {override20: 1},
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 72, shaderLocation: 10},
          {format: 'sint8x4', offset: 292, shaderLocation: 7},
          {format: 'sint32x3', offset: 116, shaderLocation: 4},
          {format: 'sint32x4', offset: 1488, shaderLocation: 13},
          {format: 'float16x2', offset: 424, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'front'},
});
try {
computePassEncoder46.setBindGroup(1, bindGroup162, new Uint32Array(3713), 53, 0);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(5, buffer75, 0, 649);
} catch {}
let promise36 = shaderModule13.getCompilationInfo();
try {
buffer139.unmap();
} catch {}
let buffer216 = device0.createBuffer({
  label: '\u{1f9e6}\u{1f936}\u4de7\u4197\u00f9\u0ea0\u{1f87b}',
  size: 2932,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView288 = texture209.createView({label: '\uf577\u2ffe\u0d07\u{1fc63}\u211f\u8a96', mipLevelCount: 1});
let sampler176 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 0.8028,
  lodMaxClamp: 45.62,
  compare: 'greater-equal',
  maxAnisotropy: 18,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup79, new Uint32Array(773), 69, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(48);
} catch {}
let texture291 = device0.createTexture({
  label: '\u93c7\u0bad\u{1fc88}\u{1f633}\u0778',
  size: {width: 72},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView289 = texture14.createView({dimension: '2d-array'});
try {
computePassEncoder111.setBindGroup(1, bindGroup18, new Uint32Array(2279), 147, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer204, 264, new Float32Array(1651), 120, 12);
} catch {}
let texture292 = device0.createTexture({
  label: '\u8d32\u03dd\u{1fcd9}\u0fdd\u9f3f\u6b40\u0f0c',
  size: [32, 32, 150],
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView290 = texture167.createView({dimension: 'cube', mipLevelCount: 1});
let sampler177 = device0.createSampler({
  label: '\u665b\uc30c\u0fc9\ubd86\u97ed',
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 25.74,
  lodMaxClamp: 67.62,
});
try {
renderPassEncoder30.endOcclusionQuery();
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle5, renderBundle23]);
} catch {}
try {
gpuCanvasContext12.unconfigure();
} catch {}
let buffer217 = device0.createBuffer({
  label: '\u12aa\u0c14\u{1fd22}\u{1ffa3}\ub112\u8ddb\u1d3f',
  size: 6904,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: true,
});
let texture293 = device0.createTexture({
  size: [78, 132, 1],
  sampleCount: 4,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let externalTexture43 = device0.importExternalTexture({source: videoFrame18});
try {
computePassEncoder111.setBindGroup(1, bindGroup24, new Uint32Array(465), 10, 0);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(110);
} catch {}
try {
renderPassEncoder45.endOcclusionQuery();
} catch {}
try {
renderPassEncoder46.executeBundles([renderBundle3, renderBundle17, renderBundle10]);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let canvas10 = document.createElement('canvas');
let buffer218 = device0.createBuffer({
  size: 3389,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler178 = device0.createSampler({
  label: '\ud64a\u{1fcd7}\u{1fe58}\u2e01',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMinClamp: 49.40,
  lodMaxClamp: 94.35,
  compare: 'always',
});
try {
computePassEncoder148.dispatchWorkgroups(3, 1);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer1, 'uint32', 4_604, 1_181);
} catch {}
try {
  await shaderModule13.getCompilationInfo();
} catch {}
try {
computePassEncoder198.pushDebugGroup('\u{1f909}');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: videoFrame17,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame54 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt470bg', transfer: 'bt1361ExtendedColourGamut'} });
let sampler179 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 26.33,
  lodMaxClamp: 59.46,
  compare: 'not-equal',
});
try {
renderPassEncoder4.setBindGroup(2, bindGroup32, new Uint32Array(1386), 887, 0);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.setVertexBuffer(5, buffer48, 0);
} catch {}
try {
computePassEncoder218.pushDebugGroup('\u1cee');
} catch {}
try {
renderPassEncoder33.setBindGroup(0, bindGroup17);
} catch {}
try {
buffer142.unmap();
} catch {}
document.body.prepend(img1);
await gc();
try {
  await adapter1.requestAdapterInfo();
} catch {}
let texture294 = device0.createTexture({
  size: [19, 33, 91],
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler180 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 44.73,
  lodMaxClamp: 71.78,
  compare: 'not-equal',
  maxAnisotropy: 1,
});
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
let offscreenCanvas6 = new OffscreenCanvas(183, 35);
let bindGroup166 = device0.createBindGroup({layout: bindGroupLayout27, entries: [{binding: 313, resource: textureView12}]});
try {
computePassEncoder162.setBindGroup(2, bindGroup65, new Uint32Array(8617), 1_127, 0);
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer47, 'uint16', 272, 465);
} catch {}
document.body.prepend(canvas2);
let promise37 = adapter0.requestAdapterInfo();
let texture295 = device0.createTexture({
  label: '\u02b1\u0e73\ue974\u{1f786}\ua814\u{1fc98}\u{1ff53}\u0f0c',
  size: [9, 16, 33],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let texture296 = gpuCanvasContext11.getCurrentTexture();
let textureView291 = texture292.createView({});
let sampler181 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 35.01,
  lodMaxClamp: 97.34,
  compare: 'greater',
  maxAnisotropy: 18,
});
try {
computePassEncoder62.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup73, new Uint32Array(5523), 2_901, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(132);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer142, 'uint16', 22, 1_628);
} catch {}
try {
computePassEncoder148.pushDebugGroup('\u0fa3');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 1, depthOrArrayLayers: 149}
*/
{
  source: imageBitmap7,
  origin: { x: 39, y: 99 },
  flipY: true,
}, {
  texture: texture248,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup167 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [{binding: 97, resource: textureView275}, {binding: 123, resource: textureView128}],
});
let texture297 = gpuCanvasContext8.getCurrentTexture();
let renderBundleEncoder33 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle33 = renderBundleEncoder33.finish({});
try {
renderPassEncoder24.setBindGroup(2, bindGroup60, new Uint32Array(230), 49, 0);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer7, 'uint16', 8_720, 245);
} catch {}
let bindGroup168 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 110, resource: sampler61},
    {binding: 145, resource: sampler24},
    {binding: 328, resource: {buffer: buffer178, offset: 0, size: 455}},
  ],
});
let textureView292 = texture149.createView({
  label: '\ufd86\uf8dd\u6390\u{1f877}\u0588\u{1f9c4}\u0913\u9ee7\u15f8\u5c54',
  dimension: 'cube-array',
  baseArrayLayer: 1,
  arrayLayerCount: 6,
});
try {
renderPassEncoder4.executeBundles([renderBundle7, renderBundle20, renderBundle3, renderBundle21]);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(4, buffer185, 1_400, 16);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture267,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(1_080).fill(132), /* required buffer size: 1_080 */
{offset: 1000, bytesPerRow: 5, rowsPerImage: 16}, {width: 0, height: 0, depthOrArrayLayers: 2});
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle10, renderBundle6]);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(3, buffer91, 168);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder197.pushDebugGroup('\u8e19');
} catch {}
let bindGroup169 = device0.createBindGroup({
  label: '\u8abb\u0363\u42e9\u{1fa25}\u{1f8aa}\ua32d\u4d3e\u0562\u0b89',
  layout: bindGroupLayout17,
  entries: [
    {binding: 408, resource: {buffer: buffer212, offset: 1792, size: 3420}},
    {binding: 27, resource: textureView168},
    {binding: 50, resource: textureView238},
  ],
});
let textureView293 = texture128.createView({aspect: 'stencil-only', format: 'stencil8'});
let renderBundleEncoder34 = device0.createRenderBundleEncoder({colorFormats: ['rg16float']});
let renderBundle34 = renderBundleEncoder34.finish({label: '\ud4bb\u{1f945}\u{1fe3b}\ud1b4\u{1f9b2}\ueb98\ued57\u09b9\u5f1c'});
try {
computePassEncoder104.setBindGroup(0, bindGroup78);
} catch {}
try {
computePassEncoder127.setBindGroup(2, bindGroup35, new Uint32Array(244), 6, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup90);
} catch {}
try {
renderPassEncoder36.setBindGroup(3, bindGroup149, new Uint32Array(1461), 61, 0);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(4, buffer66, 0, 0);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
buffer116.unmap();
} catch {}
let shaderModule17 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 23 max align: 1 */
struct T0 {
  @align(1) f0: atomic<i32>,
  @align(1) @size(19) f1: atomic<u32>,
}
@group(0) @binding(265) var<storage, read_write> buffer219: T0;
struct VertexOutput12 {
  @location(1) f33: vec2u,
  @location(7) @interpolate(perspective, center) f34: vec3h,
  @location(5) f35: vec4f,
  @location(9) @interpolate(flat, centroid) f36: vec4u,
  @builtin(position) f37: vec4f,
  @location(12) @interpolate(flat, centroid) f38: vec4i,
  @location(11) f39: vec3h,
  @location(13) f40: vec3i
}

@vertex
fn vertex0(@location(11) @interpolate(linear) a0: vec3h, @location(3) @interpolate(flat, center) a1: i32, @location(15) a2: vec3f, @location(10) a3: i32, @location(8) a4: i32) -> VertexOutput12 {
  var out: VertexOutput12;
  return out;
}
struct VertexOutput13 {
  @location(7) f41: vec4f,
  @location(0) @interpolate(flat, center) f42: i32,
  @builtin(position) f43: vec4f,
  @location(12) f44: vec4u,
  @location(2) @interpolate(perspective, center) f45: vec2f,
  @location(4) f46: vec2u
}

@vertex
fn vertex1() -> VertexOutput13 {
  var out: VertexOutput13;
  return out;
}

@compute @workgroup_size(5, 1, 1)
fn compute0() {
  _ = buffer219.f1;
}`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout39 = device0.createBindGroupLayout({
  label: '\ua178\uf235\u23c7\u{1f6e1}\uc842\u425f\uffc4\u{1fd29}',
  entries: [
    {
      binding: 512,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let bindGroup170 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [{binding: 97, resource: textureView64}, {binding: 123, resource: textureView132}],
});
try {
computePassEncoder24.setBindGroup(2, bindGroup124);
} catch {}
try {
renderPassEncoder39.setBindGroup(2, bindGroup163, new Uint32Array(3676), 621, 0);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder34.executeBundles([renderBundle21, renderBundle6, renderBundle3, renderBundle0, renderBundle10, renderBundle7]);
} catch {}
try {
gpuCanvasContext8.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture203,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(66).fill(170), /* required buffer size: 66 */
{offset: 66, rowsPerImage: 102}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext15 = offscreenCanvas6.getContext('webgpu');
let texture298 = device0.createTexture({
  size: [105, 1, 273],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder80.setBindGroup(2, bindGroup2, new Uint32Array(509), 148, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder26.setVertexBuffer(1, buffer141, 1_144);
} catch {}
let bindGroup171 = device0.createBindGroup({
  layout: bindGroupLayout31,
  entries: [{binding: 9, resource: textureView69}, {binding: 80, resource: textureView62}],
});
let textureView294 = texture281.createView({dimension: '1d', baseMipLevel: 0, baseArrayLayer: 0});
let sampler182 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 38.20,
  lodMaxClamp: 60.10,
});
try {
renderPassEncoder39.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer160, 'uint16', 116, 246);
} catch {}
try {
gpuCanvasContext12.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext16 = canvas10.getContext('webgpu');
try {
gpuCanvasContext15.unconfigure();
} catch {}
let buffer220 = device0.createBuffer({
  label: '\ub93c\u5e58\u404a\u7d52\u{1fa63}\u0249\u78c4\u73b3\u{1f9e5}\u{1f670}\u6580',
  size: 14386,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
try {
renderPassEncoder29.executeBundles([renderBundle17, renderBundle10]);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
document.body.append(img0);
let texture299 = device0.createTexture({
  size: [72, 24, 1],
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView295 = texture265.createView({});
let bindGroup172 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 50, resource: textureView143},
    {binding: 27, resource: textureView275},
    {binding: 408, resource: {buffer: buffer97, offset: 9472, size: 255}},
  ],
});
try {
computePassEncoder104.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(7, buffer189, 0, 18);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
computePassEncoder198.popDebugGroup();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 48}
*/
{
  source: imageData26,
  origin: { x: 2, y: 3 },
  flipY: false,
}, {
  texture: texture220,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 26},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer221 = device0.createBuffer({
  size: 924,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let textureView296 = texture193.createView({});
let renderBundleEncoder35 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], stencilReadOnly: true});
video0.height = 21;
let textureView297 = texture93.createView({baseMipLevel: 0});
try {
renderPassEncoder27.setIndexBuffer(buffer145, 'uint16', 10_506, 375);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(2, buffer191);
} catch {}
let arrayBuffer35 = buffer112.getMappedRange(744, 8);
try {
computePassEncoder148.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 8, y: 10, z: 0},
  aspect: 'all',
}, new Uint8Array(153).fill(54), /* required buffer size: 153 */
{offset: 153, bytesPerRow: 209}, {width: 11, height: 10, depthOrArrayLayers: 0});
} catch {}
let bindGroup173 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 408, resource: {buffer: buffer37, offset: 512}},
    {binding: 50, resource: textureView87},
    {binding: 27, resource: textureView168},
  ],
});
let buffer222 = device0.createBuffer({size: 10827, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let renderBundle35 = renderBundleEncoder35.finish({});
try {
renderPassEncoder27.setBindGroup(0, bindGroup102);
} catch {}
let textureView298 = texture195.createView({dimension: '2d', mipLevelCount: 1});
document.body.prepend(video1);
let canvas11 = document.createElement('canvas');
let querySet36 = device0.createQuerySet({
  label: '\u7136\ue514\u09c9\ue02d\udd32\u0d8b\u0cbd\ud43f\ub599\u{1f806}',
  type: 'occlusion',
  count: 73,
});
let sampler183 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 20.94,
  lodMaxClamp: 33.16,
  maxAnisotropy: 7,
});
try {
renderPassEncoder40.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder41.setViewport(44.978878636321696, 23.683956321763546, 221.0387828148021, 43.678821536105964, 0.4496793165533183, 0.5364270181304664);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer187, 'uint16', 356, 2_066);
} catch {}
try {
gpuCanvasContext14.unconfigure();
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup61, new Uint32Array(1367), 4, 0);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer118, 'uint32', 1_088, 179);
} catch {}
try {
gpuCanvasContext10.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'display-p3'});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
window.someLabel = shaderModule9.label;
} catch {}
let bindGroup174 = device0.createBindGroup({
  layout: bindGroupLayout38,
  entries: [
    {binding: 158, resource: externalTexture33},
    {binding: 396, resource: {buffer: buffer169, offset: 1280, size: 68}},
    {binding: 116, resource: {buffer: buffer216, offset: 256, size: 1292}},
    {binding: 752, resource: {buffer: buffer206, offset: 7424, size: 4508}},
    {binding: 166, resource: {buffer: buffer153, offset: 0, size: 11}},
    {binding: 209, resource: {buffer: buffer131, offset: 768, size: 1484}},
    {binding: 222, resource: {buffer: buffer147, offset: 5632, size: 924}},
    {binding: 75, resource: textureView92},
    {binding: 131, resource: sampler81},
    {binding: 15, resource: textureView183},
    {binding: 208, resource: {buffer: buffer117, offset: 0, size: 24}},
  ],
});
try {
computePassEncoder54.setBindGroup(2, bindGroup81);
} catch {}
try {
renderPassEncoder39.setBindGroup(0, bindGroup65);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle10, renderBundle0]);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(5, buffer91);
} catch {}
try {
  await promise36;
} catch {}
offscreenCanvas6.width = 412;
let buffer223 = device0.createBuffer({size: 1738, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let sampler184 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 42.04,
  lodMaxClamp: 78.94,
});
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer208, 12_392); };
} catch {}
try {
renderPassEncoder37.setBindGroup(2, bindGroup161, new Uint32Array(5903), 822, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer75);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let videoFrame55 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpteRp431', transfer: 'smpteSt4281'} });
let textureView299 = texture64.createView({dimension: 'cube', format: 'r32sint', mipLevelCount: 1, baseArrayLayer: 1});
let texture300 = device0.createTexture({
  size: [9, 16, 1],
  sampleCount: 4,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderPassEncoder33.setBindGroup(3, bindGroup131);
} catch {}
try {
renderPassEncoder47.setBindGroup(2, bindGroup18, new Uint32Array(670), 3, 0);
} catch {}
let buffer224 = device0.createBuffer({
  label: '\u4fd6\u0086\u5166\u44a8\u{1fd90}\ub2b4\u{1f654}\u2a40\u555b\u51c0\u2784',
  size: 7537,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture301 = device0.createTexture({
  size: {width: 78, height: 132, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler185 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 69.29,
  lodMaxClamp: 74.57,
  compare: 'greater',
});
let externalTexture44 = device0.importExternalTexture({source: videoFrame50});
try {
computePassEncoder203.setBindGroup(0, bindGroup150, new Uint32Array(1219), 357, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer82, 'uint32', 1_276, 68);
} catch {}
try {
device0.queue.writeBuffer(buffer142, 1140, new DataView(new ArrayBuffer(6737)), 653, 436);
} catch {}
let promise38 = device0.queue.onSubmittedWorkDone();
let videoFrame56 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'bt709', transfer: 'logSqrt'} });
let bindGroup175 = device0.createBindGroup({
  label: '\u{1f73c}\u83e9\u0fce\u2fff\uc194\u{1fc9e}\u0265\u4409\u09d0',
  layout: bindGroupLayout27,
  entries: [{binding: 313, resource: textureView12}],
});
let textureView300 = texture203.createView({aspect: 'all'});
try {
computePassEncoder85.setBindGroup(0, bindGroup166);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroupsIndirect(buffer59, 4_552); };
} catch {}
try {
renderPassEncoder46.setBindGroup(3, bindGroup59, new Uint32Array(123), 25, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 3}
*/
{
  source: videoFrame29,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture173,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let sampler186 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMinClamp: 92.35,
  lodMaxClamp: 96.20,
  maxAnisotropy: 1,
});
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer183, 2_108); };
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup43);
} catch {}
let pipelineLayout22 = device0.createPipelineLayout({label: '\u0462\u{1ff4f}', bindGroupLayouts: [bindGroupLayout11, bindGroupLayout34]});
try {
computePassEncoder219.setBindGroup(0, bindGroup144);
} catch {}
try {
renderPassEncoder44.setBindGroup(0, bindGroup81);
} catch {}
try {
renderPassEncoder29.setViewport(95.95587058375061, 92.55131362442484, 128.5491621017243, 1.1993708375259362, 0.8547637751681608, 0.9282633715045419);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture77,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(83).fill(172), /* required buffer size: 83 */
{offset: 83, bytesPerRow: 66}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
let imageData30 = new ImageData(8, 48);
let textureView301 = texture243.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder80.setBindGroup(2, bindGroup87);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer25, 'uint32', 320, 190);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.queue.submit([commandBuffer14]);
} catch {}
try {
device0.queue.writeBuffer(buffer82, 328, new BigUint64Array(5831), 1505, 12);
} catch {}
let textureView302 = texture217.createView({format: 'rgba32sint', mipLevelCount: 1, baseArrayLayer: 0});
let renderBundleEncoder36 = device0.createRenderBundleEncoder({label: '\u017a\u1610\u0c7d\u0bef\ud80b\u01a2', colorFormats: ['rg16float'], stencilReadOnly: true});
try {
computePassEncoder57.setBindGroup(2, bindGroup106);
} catch {}
try {
computePassEncoder147.setBindGroup(3, bindGroup175, new Uint32Array(993), 83, 0);
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup80, []);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer131, 'uint16', 434, 118);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer142, 'uint16', 1_226, 70);
} catch {}
try {
buffer157.unmap();
} catch {}
let promise39 = device0.queue.onSubmittedWorkDone();
let bindGroup176 = device0.createBindGroup({
  label: '\u{1f861}\u52a5\u808b\uba69\u0c26\u9c07',
  layout: bindGroupLayout28,
  entries: [{binding: 55, resource: textureView286}],
});
let texture302 = device0.createTexture({
  size: [210, 1, 565],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler187 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 46.62,
  lodMaxClamp: 63.24,
  compare: 'not-equal',
});
let externalTexture45 = device0.importExternalTexture({source: videoFrame10});
try {
renderPassEncoder16.setBindGroup(1, bindGroup68, new Uint32Array(285), 1, 0);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle7, renderBundle10]);
} catch {}
try {
renderBundleEncoder36.setBindGroup(1, bindGroup104);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer39, 'uint32', 100, 854);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(7, buffer60, 0, 2_652);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer41, 1000, new Float32Array(1567), 38, 1004);
} catch {}
try {
if (!arrayBuffer31.detached) { new Uint8Array(arrayBuffer31).fill(0x55); };
} catch {}
let texture303 = device0.createTexture({
  label: '\u8af9\u67f1\u706b\u{1fa33}\u06e5\ueb74\u1592\u175e\u3323\u043c',
  size: {width: 105, height: 1, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler188 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 92.15,
});
try {
computePassEncoder43.setBindGroup(3, bindGroup139);
} catch {}
try {
renderPassEncoder44.setBindGroup(2, bindGroup90, new Uint32Array(1973), 241, 0);
} catch {}
try {
renderPassEncoder43.executeBundles([renderBundle7, renderBundle21, renderBundle20]);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer145, 'uint16', 4_128, 2_253);
} catch {}
let promise40 = device0.queue.onSubmittedWorkDone();
let texture304 = device0.createTexture({
  size: [9],
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle36 = renderBundleEncoder36.finish({});
try {
renderPassEncoder26.setVertexBuffer(3, buffer91, 16, 16);
} catch {}
try {
if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55); };
} catch {}
let buffer225 = device0.createBuffer({
  size: 37472,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let sampler189 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 16.49,
  maxAnisotropy: 7,
});
try {
computePassEncoder179.setBindGroup(3, bindGroup69, []);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(43);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle21, renderBundle5]);
} catch {}
try {
buffer188.unmap();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let textureView303 = texture223.createView({dimension: '1d'});
let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true});
let sampler190 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 2.442,
  lodMaxClamp: 60.21,
});
try {
renderPassEncoder24.setVertexBuffer(4, buffer79);
} catch {}
let imageData31 = new ImageData(20, 36);
let buffer226 = device0.createBuffer({size: 7744, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: true});
let querySet37 = device0.createQuerySet({type: 'occlusion', count: 216});
let textureView304 = texture113.createView({label: '\u07b1\u626c', aspect: 'all', baseMipLevel: 0});
let sampler191 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 98.19,
  lodMaxClamp: 99.56,
});
try {
computePassEncoder203.setBindGroup(2, bindGroup147);
} catch {}
try {
renderPassEncoder37.setBindGroup(2, bindGroup98);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle23]);
} catch {}
try {
renderBundleEncoder37.setBindGroup(3, bindGroup46, new Uint32Array(5149), 427, 0);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(2, buffer185, 1_100, 1_411);
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u{1f63a}');
} catch {}
let bindGroup177 = device0.createBindGroup({layout: bindGroupLayout22, entries: [{binding: 4, resource: textureView235}]});
try {
computePassEncoder94.setBindGroup(3, bindGroup134, new Uint32Array(1099), 99, 0);
} catch {}
try {
renderPassEncoder32.setBindGroup(1, bindGroup67);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup66, new Uint32Array(10000), 590, 0);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(0, buffer166, 0);
} catch {}
try {
renderBundleEncoder37.setBindGroup(2, bindGroup123);
} catch {}
try {
renderBundleEncoder37.setIndexBuffer(buffer153, 'uint32', 60, 101);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(7, buffer30, 148, 70);
} catch {}
try {
computePassEncoder28.pushDebugGroup('\u1ec5');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture257,
  mipLevel: 0,
  origin: {x: 154, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(12).fill(141), /* required buffer size: 12 */
{offset: 12}, {width: 85, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame57 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'logSqrt'} });
let buffer227 = device0.createBuffer({
  size: 9243,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder39.setVertexBuffer(5, buffer85, 468, 74);
} catch {}
try {
renderBundleEncoder37.setBindGroup(2, bindGroup143);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let promise41 = shaderModule5.getCompilationInfo();
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 49, y: 18, z: 0},
  aspect: 'all',
}, new Uint8Array(214).fill(59), /* required buffer size: 214 */
{offset: 214, bytesPerRow: 55}, {width: 2, height: 16, depthOrArrayLayers: 0});
} catch {}
let texture305 = device0.createTexture({
  size: {width: 36},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle37 = renderBundleEncoder37.finish({label: '\u535b\u{1f7ba}'});
try {
computePassEncoder62.setPipeline(pipeline4);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
buffer103.unmap();
} catch {}
let textureView305 = texture78.createView({dimension: '1d', format: 'rgba16sint'});
try {
computePassEncoder147.dispatchWorkgroupsIndirect(buffer28, 10_768);
} catch {}
try {
renderPassEncoder44.setBindGroup(2, bindGroup46, []);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 4316, new BigUint64Array(9318), 1465, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 10, y: 8, z: 0},
  aspect: 'all',
}, new Uint8Array(361).fill(88), /* required buffer size: 361 */
{offset: 361, bytesPerRow: 22, rowsPerImage: 15}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await promise38;
} catch {}
let offscreenCanvas7 = new OffscreenCanvas(53, 91);
try {
renderPassEncoder15.setBindGroup(2, bindGroup7, new Uint32Array(413), 144, 0);
} catch {}
try {
window.someLabel = externalTexture19.label;
} catch {}
let textureView306 = texture29.createView({});
try {
renderPassEncoder44.executeBundles([renderBundle20, renderBundle3]);
} catch {}
try {
renderPassEncoder48.setVertexBuffer(6, buffer13, 0, 90);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let buffer228 = device0.createBuffer({
  size: 3078,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder179.setBindGroup(0, bindGroup56);
} catch {}
try {
computePassEncoder165.setBindGroup(0, bindGroup59, new Uint32Array(437), 342, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroups(3, 1); };
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer12, 'uint32', 308, 15_151);
} catch {}
let buffer229 = device0.createBuffer({size: 4804, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
try {
computePassEncoder8.setBindGroup(0, bindGroup29, new Uint32Array(2676), 908, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroupsIndirect(buffer2, 1_656); };
} catch {}
try {
computePassEncoder189.setPipeline(pipeline6);
} catch {}
let imageData32 = new ImageData(20, 128);
try {
computePassEncoder154.setBindGroup(2, bindGroup104);
} catch {}
try {
renderPassEncoder43.setBindGroup(0, bindGroup62);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer79, 'uint32', 88, 2_395);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 16}
*/
{
  source: img6,
  origin: { x: 0, y: 6 },
  flipY: false,
}, {
  texture: texture31,
  mipLevel: 1,
  origin: {x: 5, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let imageBitmap10 = await createImageBitmap(imageData7);
let bindGroupLayout40 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 94,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 263,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 25,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let texture306 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 359},
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder39.setBindGroup(3, bindGroup51);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture306,
  mipLevel: 0,
  origin: {x: 18, y: 1, z: 34},
  aspect: 'all',
}, new Uint8Array(151_895).fill(245), /* required buffer size: 151_895 */
{offset: 179, bytesPerRow: 43, rowsPerImage: 75}, {width: 6, height: 4, depthOrArrayLayers: 48});
} catch {}
let buffer230 = device0.createBuffer({
  size: 63290,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
try {
renderPassEncoder14.setBindGroup(0, bindGroup124);
} catch {}
try {
renderPassEncoder34.setBindGroup(3, bindGroup109, new Uint32Array(3027), 2_948, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer71, 'uint32', 108, 86);
} catch {}
try {
computePassEncoder197.popDebugGroup();
} catch {}
await gc();
let shaderModule18 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  @size(16) f0: f16,
}
override override83 : f32;
@id(363) override override77 : u32 = 513;
override override81 : f32;
override override80 : i32;
@id(42974) override override82 : i32 = 48;
@id(21437) override override79 : f32;
override override78 : i32;
@group(0) @binding(313) var tex15: texture_1d<u32>;
struct VertexOutput14 {
  @builtin(position) f47: vec4f
}

@vertex
fn vertex0(@location(12) a0: vec3f, @location(7) @interpolate(flat) a1: vec2i) -> VertexOutput14 {
  var out: VertexOutput14;
  _ = textureLoad(tex15, 0, 0);
  return out;
}
struct FragmentOutput12 {
  @location(2) f0: vec4i,
  @location(7) f1: vec3f,
  @location(1) f2: vec4f,
  @location(0) f3: vec4i
}

@fragment
fn fragment0() -> FragmentOutput12 {
  var out: FragmentOutput12;
  _ = textureLoad(tex15, 0, 0);
  _ = override80;
  if bool(override79) {
    out.f3 = vec4i(bitcast<i32>(override79));
  }
  if bool(override83) {
    out.f1 = vec3f(bitcast<f32>(override79));
  }
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
  if bool(override81) {
    return;
  }
}`,
  sourceMap: {},
  hints: {},
});
let textureView307 = texture203.createView({label: '\uad4c\ucf9e\u0218\ufdaa\u75b1\u{1f800}\u600b\ud9c9', dimension: '1d', aspect: 'all'});
try {
renderPassEncoder45.setBindGroup(0, bindGroup10, new Uint32Array(702), 153, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer7, 'uint16', 846, 3_579);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(5, buffer211, 0, 311);
} catch {}
let bindGroup178 = device0.createBindGroup({
  label: '\uce93\u{1fe96}\u0a0c\u23af\uade0\u4062\u5254',
  layout: bindGroupLayout32,
  entries: [{binding: 51, resource: textureView105}],
});
let sampler192 = device0.createSampler({
  label: '\u294f\u88df\u76a0\u{1fb91}\u0219\u028b\u708f\u01a9\u{1f9c9}\uadad',
  addressModeU: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 49.17,
  lodMaxClamp: 82.44,
});
try {
computePassEncoder182.setBindGroup(3, bindGroup89);
} catch {}
try {
renderPassEncoder36.end();
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle0, renderBundle17, renderBundle17, renderBundle23]);
} catch {}
try {
buffer218.unmap();
} catch {}
let textureView308 = texture218.createView({dimension: '3d', mipLevelCount: 1});
let textureView309 = texture208.createView({mipLevelCount: 1});
let sampler193 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 65.86,
  lodMaxClamp: 89.73,
});
try {
computePassEncoder193.setBindGroup(1, bindGroup36, new Uint32Array(539), 210, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(0, bindGroup68, new Uint32Array(1342), 500, 0);
} catch {}
try {
renderPassEncoder42.beginOcclusionQuery(177);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer16, 'uint16', 614, 599);
} catch {}
let textureView310 = texture234.createView({dimension: '3d'});
let textureView311 = texture187.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder122.setBindGroup(1, bindGroup46, new Uint32Array(1995), 328, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer151, 312); };
} catch {}
try {
  await promise37;
} catch {}
try {
renderPassEncoder44.beginOcclusionQuery(62);
} catch {}
try {
renderPassEncoder42.endOcclusionQuery();
} catch {}
let buffer231 = device0.createBuffer({
  size: 5710,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView312 = texture280.createView({arrayLayerCount: 1});
try {
computePassEncoder80.setBindGroup(2, bindGroup131, new Uint32Array(5405), 2_509, 0);
} catch {}
try {
renderPassEncoder45.setBindGroup(2, bindGroup150);
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); };
} catch {}
let shaderModule19 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 23 max align: 1 */
struct T0 {
  @align(1) f0: vec2i,
  @align(1) @size(15) f1: array<vec2f, 1>,
}
@group(0) @binding(265) var<storage, read_write> buffer232: T0;
struct S8 {
  @location(15) f0: vec3u
}
struct VertexOutput15 {
  @builtin(position) f48: vec4f
}

@vertex
fn vertex0(@location(12) @interpolate(flat) a0: vec4i, a1: S8) -> VertexOutput15 {
  var out: VertexOutput15;
  _ = a0;
  return out;
}

@vertex
fn vertex1(@location(14) a0: vec4f, @location(12) @interpolate(flat, centroid) a1: vec2f, @location(3) a2: vec2h, @location(4) a3: i32, @location(1) @interpolate(flat, centroid) a4: i32, @location(0) @interpolate(linear) a5: f16, @location(6) a6: f32, @location(2) @interpolate(flat) a7: i32, @location(10) @interpolate(linear) a8: vec3h) -> @builtin(position) vec4f {
  var out: vec4f;
  _ = a8;
  return out;
}
struct FragmentOutput13 {
  @location(0) @interpolate(linear, center) f0: vec2f,
  @location(6) @interpolate(flat) f1: vec2i
}

@fragment
fn fragment0() -> FragmentOutput13 {
  var out: FragmentOutput13;
  return out;
}
struct FragmentOutput14 {
  @location(0) @interpolate(flat) f0: vec4i,
  @location(1) @interpolate(flat) f1: vec3f,
  @location(2) @interpolate(flat) f2: vec4i,
  @location(7) @interpolate(flat, sample) f3: vec4u
}

@fragment
fn fragment1(@location(10) a0: vec2h) -> FragmentOutput14 {
  var out: FragmentOutput14;
  _ = buffer232.f1[0];
  return out;
}
struct FragmentOutput15 {
  @location(3) @interpolate(linear, sample) f0: vec4f,
  @location(0) f1: vec2f
}

@fragment
fn fragment2(@builtin(position) a0: vec4f) -> FragmentOutput15 {
  var out: FragmentOutput15;
  _ = a0;
  _ = buffer232.f0;
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(num_workgroups) a0: vec3u) {
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup179 = device0.createBindGroup({layout: bindGroupLayout39, entries: [{binding: 512, resource: textureView9}]});
let textureView313 = texture99.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData33 = new ImageData(56, 4);
let bindGroup180 = device0.createBindGroup({
  layout: bindGroupLayout34,
  entries: [
    {binding: 167, resource: sampler173},
    {binding: 170, resource: textureView32},
    {binding: 643, resource: textureView14},
    {binding: 101, resource: {buffer: buffer101, offset: 8448, size: 3099}},
  ],
});
let texture307 = device0.createTexture({size: [115, 5, 101], format: 'astc-5x5-unorm-srgb', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder85.setBindGroup(0, bindGroup144);
} catch {}
try {
renderPassEncoder44.setBindGroup(2, bindGroup26);
} catch {}
try {
renderPassEncoder34.executeBundles([renderBundle10, renderBundle20, renderBundle7, renderBundle21]);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer166, 'uint32', 3_708, 2_186);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer106, 284, new BigUint64Array(15557), 5, 116);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise41;
} catch {}
let textureView314 = texture80.createView({
  label: '\ue037\u9c62\u{1f78b}\ua3fc\u4a90\u{1fdc6}\u{1fe6d}\u{1fcc9}\u0b7d\u1f03\u617c',
  format: 'r16float',
});
try {
computePassEncoder58.setBindGroup(0, bindGroup2);
} catch {}
try {
computePassEncoder197.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder32.setBindGroup(0, bindGroup16, new Uint32Array(1272), 112, 0);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(0, buffer34, 0, 66);
} catch {}
try {
renderPassEncoder19.pushDebugGroup('\u0d86');
} catch {}
try {
renderPassEncoder34.insertDebugMarker('\u49ca');
} catch {}
let pipeline11 = await device0.createRenderPipelineAsync({
  label: '\uf21b\u016d',
  layout: pipelineLayout4,
  multisample: {mask: 0xe612d2b},
  fragment: {
  module: shaderModule19,
  entryPoint: 'fragment2',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'dst'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule4,
    constants: {override20: 1},
    buffers: [
      {
        arrayStride: 88,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x4', offset: 24, shaderLocation: 7},
          {format: 'sint32x3', offset: 0, shaderLocation: 13},
          {format: 'sint32', offset: 48, shaderLocation: 4},
          {format: 'float32', offset: 8, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 240,
        stepMode: 'instance',
        attributes: [{format: 'unorm10-10-10-2', offset: 104, shaderLocation: 10}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'none'},
});
try {
renderPassEncoder22.setBindGroup(3, bindGroup40);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup10, new Uint32Array(2338), 200, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let gpuCanvasContext17 = offscreenCanvas7.getContext('webgpu');
try {
gpuCanvasContext5.unconfigure();
} catch {}
let imageBitmap11 = await createImageBitmap(imageData26);
let texture308 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler194 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 92.34,
  lodMaxClamp: 94.26,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup56);
} catch {}
try {
renderPassEncoder46.setBindGroup(2, bindGroup145);
} catch {}
try {
renderPassEncoder44.endOcclusionQuery();
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer142, 'uint32', 820, 1_143);
} catch {}
try {
querySet9.destroy();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
offscreenCanvas7.width = 518;
let texture309 = device0.createTexture({
  label: '\u0421\u0a7b\u39b2\u67a8\u040a',
  size: [39],
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder46.setVertexBuffer(4, buffer228, 132, 803);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 1612, new Int16Array(8784), 1315, 864);
} catch {}
let sampler195 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 0.03061,
  lodMaxClamp: 17.77,
  maxAnisotropy: 18,
});
try {
computePassEncoder141.setBindGroup(1, bindGroup51, new Uint32Array(952), 51, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder44.setBindGroup(0, bindGroup45, []);
} catch {}
try {
renderPassEncoder46.setBindGroup(0, bindGroup114, new Uint32Array(1971), 293, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer26, 2980, new DataView(new ArrayBuffer(8704)), 4673, 56);
} catch {}
try {
computePassEncoder155.setBindGroup(1, bindGroup26, new Uint32Array(383), 17, 0);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(95);
} catch {}
try {
buffer176.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData34 = new ImageData(76, 4);
let textureView315 = texture110.createView({});
try {
computePassEncoder199.setBindGroup(1, bindGroup96);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 78, height: 132, depthOrArrayLayers: 31}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture93,
  mipLevel: 0,
  origin: {x: 11, y: 17, z: 13},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise40;
} catch {}
let texture310 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder144.setBindGroup(3, bindGroup39);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle21]);
} catch {}
let texture311 = device0.createTexture({
  size: [78, 132, 13],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture312 = device0.createTexture({size: {width: 288}, dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder32.setBindGroup(2, bindGroup99, new Uint32Array(2457), 254, 0);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer74, 'uint32', 296, 2_699);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
  await promise39;
} catch {}
let buffer233 = device0.createBuffer({
  label: '\ud834\ud56f\u{1fc21}\u0347\ud9b4\u077a',
  size: 18466,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
try {
renderPassEncoder29.setScissorRect(15, 8, 71, 53);
} catch {}
let texture313 = device0.createTexture({
  label: '\u0ccc\u2bb7\u0823\u{1fd29}\u164e\u44f6',
  size: [288, 96, 1],
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView316 = texture200.createView({label: '\ufbe2\u9f73\u900c'});
try {
computePassEncoder28.setBindGroup(2, bindGroup63, new Uint32Array(1545), 10, 0);
} catch {}
try {
computePassEncoder134.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup175, new Uint32Array(2912), 736, 0);
} catch {}
try {
renderPassEncoder47.setScissorRect(2, 1, 4, 0);
} catch {}
let textureView317 = texture283.createView({arrayLayerCount: 1});
let texture314 = device0.createTexture({
  size: {width: 19, height: 33, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder22.setBindGroup(1, bindGroup18, new Uint32Array(1593), 242, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer153, 32); };
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(42);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(1, buffer10);
} catch {}
let pipeline12 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule2}});
let gpuCanvasContext18 = canvas11.getContext('webgpu');
let texture315 = device0.createTexture({
  size: {width: 39, height: 66, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder141.setBindGroup(2, bindGroup176);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
let texture316 = device0.createTexture({
  label: '\u{1f72a}\u76d7\u5e76\ua70b\u{1f904}\u{1ffa9}',
  size: [32],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView318 = texture243.createView({dimension: '2d', mipLevelCount: 1});
try {
computePassEncoder124.setBindGroup(0, bindGroup163);
} catch {}
try {
computePassEncoder114.setBindGroup(3, bindGroup175, new Uint32Array(2378), 306, 0);
} catch {}
try {
renderPassEncoder48.setBindGroup(3, bindGroup47, new Uint32Array(1125), 133, 0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle21]);
} catch {}
try {
if (!arrayBuffer34.detached) { new Uint8Array(arrayBuffer34).fill(0x55); };
} catch {}
offscreenCanvas0.height = 848;
let video2 = await videoWithData(69);
let buffer234 = device0.createBuffer({
  label: '\u69b4\u0229\u059d\u0143\ua870\u{1f84a}\ue483\u{1f9de}\uf287',
  size: 6851,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler196 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 34.85,
  lodMaxClamp: 42.09,
  compare: 'less-equal',
});
try {
renderPassEncoder26.setBindGroup(2, bindGroup47, new Uint32Array(480), 147, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer64, 'uint16', 24_020, 299);
} catch {}
try {
device0.queue.writeBuffer(buffer56, 100, new Float32Array(15122), 876, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture256,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(118).fill(193), /* required buffer size: 118 */
{offset: 118, rowsPerImage: 17}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer235 = device0.createBuffer({
  size: 8608,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView319 = texture194.createView({label: '\u2cb3\u3aca\u5241\ub1fe', dimension: '2d-array', mipLevelCount: 1});
let sampler197 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 48.42,
  lodMaxClamp: 57.50,
});
try {
computePassEncoder26.setBindGroup(1, bindGroup26);
} catch {}
let arrayBuffer36 = buffer66.getMappedRange(9432, 0);
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  alphaMode: 'opaque',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
window.someLabel = commandEncoder53.label;
} catch {}
let texture317 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 482},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder42.setBindGroup(2, bindGroup71, new Uint32Array(1495), 29, 0);
} catch {}
let shaderModule20 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 4 max align: 4 */
struct T0 {
  f0: array<f32>,
}
/* target size: 84 max align: 4 */
struct T1 {
  @size(20) f0: atomic<u32>,
  @align(4) @size(36) f1: mat4x3h,
  @size(28) f2: atomic<i32>,
}
@group(0) @binding(313) var tex16: texture_2d<i32>;
struct S9 {
  @location(2) f0: vec4h,
  @location(15) @interpolate(flat, center) f1: vec2u,
  @location(8) @interpolate(flat, sample) f2: vec4u,
  @location(5) f3: f32
}
struct VertexOutput16 {
  @builtin(position) f49: vec4f
}

@vertex
fn vertex0(@location(7) @interpolate(flat) a0: vec4u, a1: S9, @location(4) @interpolate(flat, center) a2: i32) -> VertexOutput16 {
  var out: VertexOutput16;
  _ = a1.f0;
  _ = a2;
  return out;
}

@fragment
fn fragment0(@builtin(sample_mask) a0: u32) -> @location(200) @interpolate(perspective) vec2f {
  var out: vec2f;
  return out;
}

@compute @workgroup_size(3, 1, 1)
fn compute0() {
}`,
  sourceMap: {},
  hints: {},
});
let buffer236 = device0.createBuffer({size: 7153, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let textureView320 = texture293.createView({});
try {
computePassEncoder39.setBindGroup(3, bindGroup77);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup73);
} catch {}
try {
renderPassEncoder32.end();
} catch {}
try {
computePassEncoder28.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer201, 216, new DataView(new ArrayBuffer(4124)), 301, 884);
} catch {}
let bindGroup181 = device0.createBindGroup({layout: bindGroupLayout22, entries: [{binding: 4, resource: textureView125}]});
let querySet38 = device0.createQuerySet({type: 'occlusion', count: 221});
let texture318 = device0.createTexture({
  label: '\uc2b7\u0a6a\uecc6\u0ab1\uc81f\u309a',
  size: {width: 39, height: 66, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder160.setBindGroup(2, bindGroup153, new Uint32Array(231), 7, 0);
} catch {}
try {
renderPassEncoder26.setViewport(3.8594870070253355, 12.00215239892262, 4.1459251839600535, 3.3180791590777616, 0.5111089637218806, 0.9483043820272887);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(3, buffer69);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 19, height: 33, depthOrArrayLayers: 120}
*/
{
  source: imageData19,
  origin: { x: 0, y: 4 },
  flipY: false,
}, {
  texture: texture268,
  mipLevel: 1,
  origin: {x: 8, y: 13, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture319 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView321 = texture257.createView({aspect: 'all'});
let renderBundleEncoder38 = device0.createRenderBundleEncoder({
  label: '\u3799\u{1fe85}\u{1ffdb}\u0472\ua02e\u7218\u{1fd06}\u189e\u0626\u{1fe2d}\u5d0c',
  colorFormats: ['r8unorm'],
  stencilReadOnly: false,
});
let renderBundle38 = renderBundleEncoder38.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder47.setBindGroup(2, bindGroup171, new Uint32Array(1365), 165, 0);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(1, buffer17, 960);
} catch {}
let bindGroupLayout41 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 87,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let bindGroup182 = device0.createBindGroup({
  layout: bindGroupLayout25,
  entries: [
    {binding: 1, resource: textureView33},
    {binding: 252, resource: textureView318},
    {binding: 6, resource: textureView57},
    {binding: 171, resource: textureView85},
    {binding: 129, resource: textureView120},
  ],
});
let texture320 = device0.createTexture({
  size: [36, 12, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView322 = texture142.createView({dimension: '2d-array'});
let sampler198 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 6.575,
});
try {
renderPassEncoder41.setVertexBuffer(4, buffer210, 572, 3_893);
} catch {}
let arrayBuffer37 = buffer29.getMappedRange(23032, 7480);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 28, y: 27 },
  flipY: false,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 0, y: 9, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let textureView323 = texture320.createView({});
let texture321 = device0.createTexture({
  label: '\u{1f740}\u372e\u{1fa83}\u063e\uc993\ue35d\u6bf0',
  size: {width: 72, height: 24, depthOrArrayLayers: 53},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder26.setIndexBuffer(buffer107, 'uint32', 484, 42);
} catch {}
let promise42 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55); };
} catch {}
let textureView324 = texture140.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0});
let sampler199 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 46.19,
  lodMaxClamp: 92.96,
  compare: 'never',
  maxAnisotropy: 4,
});
try {
computePassEncoder154.setBindGroup(2, bindGroup141);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup107, new Uint32Array(1067), 508, 0);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer42, 'uint32', 156, 5_997);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(0, undefined, 0);
} catch {}
try {
buffer10.unmap();
} catch {}
try {
  await buffer190.mapAsync(GPUMapMode.READ, 0, 116);
} catch {}
try {
commandEncoder108.label = '\u997a\u30a6\u9144\ua482\u2f71\u0d15\ud2a8\u{1fb5e}\ua171\u00f2';
} catch {}
let bindGroup183 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView9}]});
let texture322 = device0.createTexture({size: [105, 1, 1], mipLevelCount: 3, format: 'rg16float', usage: GPUTextureUsage.COPY_DST});
let sampler200 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 66.69,
  lodMaxClamp: 82.43,
  compare: 'greater-equal',
  maxAnisotropy: 8,
});
let externalTexture46 = device0.importExternalTexture({source: video2, colorSpace: 'srgb'});
try {
renderPassEncoder33.setIndexBuffer(buffer16, 'uint32', 120, 152);
} catch {}
try {
computePassEncoder218.popDebugGroup();
} catch {}
let bindGroup184 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [{binding: 41, resource: textureView195}, {binding: 228, resource: textureView9}],
});
let querySet39 = device0.createQuerySet({type: 'occlusion', count: 1128});
try {
computePassEncoder123.setBindGroup(1, bindGroup84, new Uint32Array(1178), 46, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer93, 1_604); };
} catch {}
try {
renderPassEncoder33.setBindGroup(2, bindGroup1, []);
} catch {}
try {
renderPassEncoder19.popDebugGroup();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 4, height: 8, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas6,
  origin: { x: 9, y: 11 },
  flipY: false,
}, {
  texture: texture175,
  mipLevel: 1,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder198.setBindGroup(2, bindGroup121, new Uint32Array(587), 86, 0);
} catch {}
try {
renderPassEncoder48.setBindGroup(0, bindGroup167, new Uint32Array(492), 47, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(358);
} catch {}
let arrayBuffer38 = buffer141.getMappedRange(1696, 6824);
try {
gpuCanvasContext11.unconfigure();
} catch {}
let imageBitmap12 = await createImageBitmap(imageData33);
let texture323 = device0.createTexture({
  label: '\u026c\u{1fd2b}\u{1face}\u0473\u0329\ufcd9\u{1fef8}\u{1fef5}',
  size: [210, 1, 33],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
computePassEncoder136.setBindGroup(3, bindGroup87, []);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(50).fill(124), /* required buffer size: 50 */
{offset: 50}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 1, depthOrArrayLayers: 136}
*/
{
  source: imageData30,
  origin: { x: 1, y: 1 },
  flipY: false,
}, {
  texture: texture298,
  mipLevel: 1,
  origin: {x: 21, y: 0, z: 41},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout23 = device0.createPipelineLayout({label: '\u6723\u8832\u5433\ucd83\u61f2\uca65\u0bb8\uadcd', bindGroupLayouts: []});
let textureView325 = texture272.createView({dimension: '2d-array', aspect: 'all'});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroupsIndirect(buffer136, 13_136); };
} catch {}
try {
device0.queue.writeTexture({
  texture: texture204,
  mipLevel: 0,
  origin: {x: 13, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(180).fill(175), /* required buffer size: 180 */
{offset: 180, bytesPerRow: 125}, {width: 52, height: 9, depthOrArrayLayers: 0});
} catch {}
let sampler201 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 87.75,
  lodMaxClamp: 89.93,
});
try {
renderPassEncoder33.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup169, new Uint32Array(747), 149, 0);
} catch {}
try {
renderPassEncoder42.end();
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle6, renderBundle20, renderBundle17, renderBundle7, renderBundle38, renderBundle7, renderBundle17]);
} catch {}
try {
buffer114.unmap();
} catch {}
let pipeline13 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule19, constants: {}}});
try {
window.someLabel = bindGroup46.label;
} catch {}
let textureView326 = texture252.createView({});
let texture324 = device0.createTexture({
  label: '\u0739\u6a17\u{1fce7}\u0f94\u{1fcec}\u87e2\u01ff\u4a5b\ubed1\uaa46',
  size: [288, 96, 1],
  mipLevelCount: 3,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView327 = texture93.createView({});
let sampler202 = device0.createSampler({
  label: '\u{1fd0b}\u{1fdbe}\uc56f\uc7f3\ubb95\u6d2d\u0d1e\u0384',
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.31,
  maxAnisotropy: 6,
});
try {
renderPassEncoder4.setBindGroup(1, bindGroup155, new Uint32Array(1323), 29, 0);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer141, 'uint32', 3_780, 918);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
if (!arrayBuffer18.detached) { new Uint8Array(arrayBuffer18).fill(0x55); };
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let sampler203 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 17.85,
  lodMaxClamp: 96.14,
  maxAnisotropy: 3,
});
try {
renderPassEncoder26.setVertexBuffer(7, buffer223, 0, 36);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
await gc();
let bindGroupLayout42 = device0.createBindGroupLayout({
  entries: [
    {binding: 21, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {
      binding: 12,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let texture325 = device0.createTexture({
  label: '\uaa5d\u3ce4\uabb2\u0c8f\u2c95\u0b80\uaa9e\u58b9\ued70',
  size: {width: 78, height: 132, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView328 = texture75.createView({});
try {
device0.queue.writeBuffer(buffer227, 716, new Float32Array(20456), 2226, 0);
} catch {}
let imageData35 = new ImageData(36, 4);
let texture326 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 10},
  mipLevelCount: 4,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView329 = texture270.createView({label: '\ub3d9\u0ad6\u0f15\u2df6\u0e12\u78e6\u0401\u03d6\u0ff8\u9bed', dimension: '2d-array'});
try {
computePassEncoder107.pushDebugGroup('\u382d');
} catch {}
try {
device0.queue.writeBuffer(buffer149, 344, new BigUint64Array(14901), 512, 16);
} catch {}
let sampler204 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 93.55,
  lodMaxClamp: 93.73,
  compare: 'greater-equal',
  maxAnisotropy: 3,
});
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroupsIndirect(buffer93, 5_204); };
} catch {}
try {
gpuCanvasContext12.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, alphaMode: 'opaque'});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: videoFrame10,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let sampler205 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.85,
  lodMaxClamp: 79.83,
  compare: 'not-equal',
  maxAnisotropy: 9,
});
try {
computePassEncoder181.setBindGroup(1, bindGroup81);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup17);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup169, new Uint32Array(1542), 443, 0);
} catch {}
try {
renderPassEncoder19.setViewport(133.32847262202162, 20.59275004083418, 136.3493989477447, 25.782447164081614, 0.37029816060073906, 0.8909097651461125);
} catch {}
let texture327 = device0.createTexture({
  label: '\u041e\u805d\u05f1\u{1f80f}\u{1fc60}\u{1fc4f}\u0ba8\uf08c\u00d4\ud03a\u4e2e',
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  format: 'astc-8x8-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView330 = texture139.createView({mipLevelCount: 1, baseArrayLayer: 0});
let sampler206 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 45.79,
  lodMaxClamp: 67.33,
});
try {
computePassEncoder21.setBindGroup(3, bindGroup61, new Uint32Array(1267), 253, 0);
} catch {}
try {
computePassEncoder107.popDebugGroup();
} catch {}
let imageData36 = new ImageData(16, 32);
try {
adapter1.label = '\u{1fb44}\u3055\u67a7';
} catch {}
try {
computePassEncoder94.setBindGroup(0, bindGroup111, new Uint32Array(1434), 13, 0);
} catch {}
let texture328 = device0.createTexture({
  size: [288, 96, 1],
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let texture329 = gpuCanvasContext12.getCurrentTexture();
try {
computePassEncoder130.setBindGroup(0, bindGroup80);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 16}
*/
{
  source: imageData5,
  origin: { x: 8, y: 0 },
  flipY: false,
}, {
  texture: texture31,
  mipLevel: 1,
  origin: {x: 0, y: 5, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 9, height: 1, depthOrArrayLayers: 0});
} catch {}
let sampler207 = device0.createSampler({
  label: '\uf0e2\u90eb\u3331\u00ee',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 88.74,
  lodMaxClamp: 90.05,
  compare: 'less',
});
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer213, 0); };
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(282);
} catch {}
let bindGroup185 = device0.createBindGroup({
  label: '\u037d\u{1f8dc}\uf3c0\ud5b2\ude55',
  layout: bindGroupLayout22,
  entries: [{binding: 4, resource: textureView285}],
});
let texture330 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 56},
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup59, []);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder26.setScissorRect(0, 0, 1, 3);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(6, buffer35, 0, 16);
} catch {}
let promise43 = device0.queue.onSubmittedWorkDone();
let textureView331 = texture325.createView({});
let texture331 = device0.createTexture({
  label: '\u0093\ua958\u5973',
  size: [105, 1, 1],
  sampleCount: 4,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder37.setBindGroup(3, bindGroup155);
} catch {}
try {
renderPassEncoder33.executeBundles([renderBundle38, renderBundle38]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer36, 'uint32', 3_508, 6_170);
} catch {}
try {
gpuCanvasContext13.unconfigure();
} catch {}
let buffer237 = device0.createBuffer({
  label: '\u9bf4\u0f23\udf1a\u0bbf\u{1f9a3}',
  size: 15645,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture332 = device0.createTexture({
  size: [144],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler208 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 94.35,
  lodMaxClamp: 94.86,
  maxAnisotropy: 13,
});
try {
computePassEncoder70.setBindGroup(3, bindGroup61);
} catch {}
try {
renderPassEncoder43.end();
} catch {}
try {
renderPassEncoder26.setViewport(8.347227302931548, 2.456498066069363, 0.4368140451498964, 4.800032015058378, 0.46494168302776917, 0.642520959493013);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer115, 0, 2_402);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline14 = await device0.createComputePipelineAsync({layout: pipelineLayout12, compute: {module: shaderModule13, constants: {override58: 1, 54_280: 1}}});
try {
  await adapter0.requestAdapterInfo();
} catch {}
try {
computePassEncoder58.setBindGroup(1, bindGroup95);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup116, new Uint32Array(1181), 57, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer208, 'uint16', 11_436, 225);
} catch {}
let textureView332 = texture225.createView({});
let sampler209 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 58.62,
  lodMaxClamp: 64.54,
  compare: 'equal',
});
try {
computePassEncoder207.setBindGroup(1, bindGroup44, new Uint32Array(1043), 158, 0);
} catch {}
try {
renderPassEncoder38.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer156, 'uint32', 3_124, 9_313);
} catch {}
let videoFrame58 = videoFrame48.clone();
let bindGroup186 = device0.createBindGroup({
  label: '\u89f0\u0d3d',
  layout: bindGroupLayout17,
  entries: [
    {binding: 27, resource: textureView159},
    {binding: 408, resource: {buffer: buffer206, offset: 768, size: 2736}},
    {binding: 50, resource: textureView238},
  ],
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer183, 2_492); };
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer50, 'uint32', 5_596, 103);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let shaderModule21 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 4 max align: 4 */
struct T0 {
  f0: array<vec2h, 1>,
}
/* target size: 7 max align: 1 */
struct T1 {
  @align(1) @size(7) f0: T0,
}
/* target size: 8 max align: 8 */
struct T2 {
  @align(1) @size(8) f0: vec2h,
}
/* target size: 6 max align: 2 */
struct T3 {
  @align(2) @size(6) f0: atomic<u32>,
}
@group(0) @binding(100) var tex18: texture_depth_cube_array;
@group(0) @binding(191) var tex17: texture_2d<f32>;
struct VertexOutput17 {
  @builtin(position) @invariant f50: vec4f
}

@vertex
fn vertex0(@location(9) a0: vec4f, @builtin(instance_index) a1: u32) -> VertexOutput17 {
  var out: VertexOutput17;
  if bool(a1) {
    var v: vec4f;
  }
  return out;
}
struct FragmentOutput16 {
  @location(0) @interpolate(flat, centroid) f0: vec3f
}

@fragment
fn fragment0(@builtin(front_facing) a0: bool, @location(12) a1: vec3i, @location(0) a2: vec2u, @location(15) a3: vec3h, @location(1) @interpolate(perspective, sample) a4: vec4h) -> FragmentOutput16 {
  var out: FragmentOutput16;
  _ = a4;
  return out;
}
struct FragmentOutput17 {
  @location(0) @interpolate(perspective) f0: vec4f
}

@fragment
fn fragment1() -> FragmentOutput17 {
  var out: FragmentOutput17;
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(local_invocation_id) a0: vec3u) {
}`,
  sourceMap: {},
});
let textureView333 = texture250.createView({dimension: '2d-array'});
let renderBundleEncoder39 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], stencilReadOnly: true});
let renderBundle39 = renderBundleEncoder39.finish({label: '\u0369\u04a8'});
try {
renderPassEncoder30.setBindGroup(1, bindGroup146);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(6, buffer26, 0, 2_377);
} catch {}
try {
buffer147.unmap();
} catch {}
let texture333 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder29.setBindGroup(0, bindGroup78, new Uint32Array(2392), 300, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let bindGroup187 = device0.createBindGroup({layout: bindGroupLayout11, entries: [{binding: 212, resource: textureView209}]});
let texture334 = device0.createTexture({
  size: [39],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder192.setBindGroup(1, bindGroup38, new Uint32Array(691), 41, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup162, new Uint32Array(1392), 259, 0);
} catch {}
try {
renderPassEncoder47.setScissorRect(6, 2, 6, 1);
} catch {}
try {
renderPassEncoder33.setViewport(121.31547433350676, 75.21395293846868, 5.756059902616146, 6.707151082553635, 0.02961347443658391, 0.05123794525675668);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(4_294_967_294, undefined);
} catch {}
try {
device0.queue.writeBuffer(buffer200, 3244, new DataView(new ArrayBuffer(22350)), 6962, 2440);
} catch {}
let imageData37 = new ImageData(4, 20);
let buffer238 = device0.createBuffer({
  size: 5612,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture335 = device0.createTexture({
  size: [9],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder158.setBindGroup(1, bindGroup81);
} catch {}
try {
computePassEncoder8.setBindGroup(0, bindGroup44, new Uint32Array(432), 81, 0);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(1, buffer149);
} catch {}
try {
computePassEncoder103.pushDebugGroup('\u0355');
} catch {}
let buffer239 = device0.createBuffer({size: 11811, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
try {
renderPassEncoder22.setBindGroup(0, bindGroup28, []);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(1, buffer138, 0, 117);
} catch {}
let arrayBuffer39 = buffer209.getMappedRange(0, 124);
try {
computePassEncoder103.popDebugGroup();
} catch {}
let canvas12 = document.createElement('canvas');
let sampler210 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 52.37,
  lodMaxClamp: 74.98,
});
try {
computePassEncoder166.setBindGroup(0, bindGroup113);
} catch {}
try {
renderPassEncoder46.setBindGroup(1, bindGroup102, []);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer78, 'uint16', 10_836, 291);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(3, buffer210, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer27, 16252, new Int16Array(2811), 1265);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup188 = device0.createBindGroup({
  layout: bindGroupLayout18,
  entries: [
    {binding: 114, resource: textureView81},
    {binding: 28, resource: textureView157},
    {binding: 178, resource: sampler36},
    {binding: 119, resource: {buffer: buffer170, offset: 0, size: 460}},
    {binding: 810, resource: {buffer: buffer172, offset: 2304, size: 41}},
    {binding: 192, resource: textureView9},
    {binding: 150, resource: textureView84},
    {binding: 56, resource: {buffer: buffer51, offset: 1280}},
    {binding: 245, resource: textureView265},
    {binding: 90, resource: {buffer: buffer40, offset: 4096}},
    {binding: 132, resource: {buffer: buffer176, offset: 512, size: 640}},
    {binding: 196, resource: {buffer: buffer30, offset: 0, size: 236}},
    {binding: 220, resource: sampler27},
    {binding: 62, resource: {buffer: buffer211, offset: 1536, size: 5028}},
    {binding: 839, resource: {buffer: buffer183, offset: 1792, size: 6272}},
    {binding: 65, resource: textureView49},
    {binding: 598, resource: {buffer: buffer165, offset: 0, size: 48}},
    {binding: 249, resource: sampler34},
    {binding: 698, resource: textureView204},
    {binding: 301, resource: {buffer: buffer92, offset: 0}},
    {binding: 52, resource: sampler0},
    {binding: 58, resource: sampler70},
    {binding: 304, resource: externalTexture0},
    {binding: 296, resource: textureView6},
    {binding: 209, resource: textureView162},
    {binding: 77, resource: externalTexture15},
    {binding: 6, resource: {buffer: buffer206, offset: 1280, size: 284}},
    {binding: 171, resource: textureView46},
    {binding: 27, resource: {buffer: buffer63, offset: 256, size: 1536}},
    {binding: 55, resource: sampler32},
    {binding: 66, resource: textureView299},
    {binding: 152, resource: {buffer: buffer120, offset: 1280}},
    {binding: 142, resource: textureView250},
    {binding: 99, resource: textureView87},
    {binding: 386, resource: sampler135},
    {binding: 113, resource: textureView9},
    {binding: 8, resource: textureView182},
    {binding: 380, resource: textureView77},
    {binding: 277, resource: textureView69},
    {binding: 91, resource: {buffer: buffer37, offset: 256, size: 512}},
    {binding: 7, resource: sampler48},
    {binding: 50, resource: {buffer: buffer40, offset: 5888}},
    {binding: 225, resource: sampler194},
    {binding: 15, resource: textureView186},
    {binding: 125, resource: sampler36},
    {binding: 566, resource: {buffer: buffer177, offset: 1792}},
    {binding: 102, resource: {buffer: buffer59, offset: 2816, size: 6780}},
    {binding: 32, resource: textureView180},
    {binding: 82, resource: {buffer: buffer221, offset: 0}},
    {binding: 308, resource: externalTexture27},
    {binding: 0, resource: externalTexture38},
    {binding: 203, resource: textureView128},
  ],
});
let externalTexture47 = device0.importExternalTexture({source: videoFrame21, colorSpace: 'display-p3'});
try {
renderPassEncoder29.setIndexBuffer(buffer115, 'uint16', 344, 744);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(1, buffer132, 376);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise42;
} catch {}
await gc();
let renderBundleEncoder40 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint']});
let sampler211 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 12.99,
  lodMaxClamp: 86.14,
  compare: 'greater',
  maxAnisotropy: 16,
});
try {
computePassEncoder127.setBindGroup(1, bindGroup153, new Uint32Array(4656), 63, 0);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup168);
} catch {}
try {
renderPassEncoder46.setBindGroup(0, bindGroup62, new Uint32Array(1178), 19, 0);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer22, 'uint16', 30, 37);
} catch {}
let promise44 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext19 = canvas12.getContext('webgpu');
let bindGroup189 = device0.createBindGroup({layout: bindGroupLayout27, entries: [{binding: 313, resource: textureView20}]});
let texture336 = device0.createTexture({
  label: '\u76e6\u{1f6eb}\u8736\u{1ff20}\u8d88\u{1ff7d}\u1793\u76bf\ufec2\u{1fc20}\u24fb',
  size: {width: 144, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView334 = texture184.createView({label: '\u5705\u9b2b\u595b\uecc0\u6a98\ub64d\u0458\u{1f73a}\u0dae', dimension: '2d-array'});
let renderBundle40 = renderBundleEncoder40.finish({});
try {
computePassEncoder146.setBindGroup(3, bindGroup35);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer20, 'uint32', 8, 128);
} catch {}
try {
buffer60.unmap();
} catch {}
document.body.prepend(canvas0);
let buffer240 = device0.createBuffer({
  size: 17396,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let sampler212 = device0.createSampler({
  label: '\u0a15\u{1f6b6}\ud404\u5659\ucf90\u14b1\u95eb\u{1fb32}\u00f2\u{1fd7f}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 40.88,
  lodMaxClamp: 76.53,
});
try {
computePassEncoder55.setBindGroup(3, bindGroup9, new Uint32Array(1506), 270, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer22, 264); };
} catch {}
try {
computePassEncoder217.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup19, new Uint32Array(4098), 91, 0);
} catch {}
try {
renderPassEncoder15.setViewport(25.83020781482479, 0.5595433494043057, 80.29032903250595, 0.2258762966066184, 0.09701810769643748, 0.8189993880813129);
} catch {}
try {
renderPassEncoder45.setIndexBuffer(buffer26, 'uint16', 1_726, 489);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(6, buffer237);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 78, height: 132, depthOrArrayLayers: 31}
*/
{
  source: img1,
  origin: { x: 1, y: 7 },
  flipY: false,
}, {
  texture: texture93,
  mipLevel: 0,
  origin: {x: 16, y: 45, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer241 = device0.createBuffer({
  size: 1113,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture337 = device0.createTexture({
  label: '\u0a8a\u671a',
  size: {width: 39},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView335 = texture156.createView({mipLevelCount: 1});
try {
computePassEncoder81.setBindGroup(2, bindGroup123);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer7, 272); };
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup58);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(5, buffer234, 0, 2_472);
} catch {}
try {
device0.queue.writeBuffer(buffer64, 8800, new Float32Array(4899), 1653);
} catch {}
let bindGroup190 = device0.createBindGroup({layout: bindGroupLayout32, entries: [{binding: 51, resource: textureView81}]});
let externalTexture48 = device0.importExternalTexture({source: video2, colorSpace: 'display-p3'});
try {
computePassEncoder98.setBindGroup(3, bindGroup128);
} catch {}
try {
renderPassEncoder29.setBindGroup(3, bindGroup46, new Uint32Array(734), 104, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let videoFrame59 = new VideoFrame(videoFrame0, {timestamp: 0});
let bindGroup191 = device0.createBindGroup({
  layout: bindGroupLayout36,
  entries: [
    {binding: 29, resource: textureView77},
    {binding: 558, resource: sampler58},
    {binding: 146, resource: {buffer: buffer216, offset: 0, size: 249}},
    {binding: 186, resource: {buffer: buffer33, offset: 512, size: 56}},
  ],
});
let buffer242 = device0.createBuffer({
  size: 1980,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder41.setBindGroup(0, bindGroup174, new Uint32Array(7010), 3_875, 0);
} catch {}
try {
  await promise44;
} catch {}
let bindGroup192 = device0.createBindGroup({
  label: '\u071a\u7427\u0485\uc02e\u{1f766}\u0a9a\u{1f94c}\uf636\u{1fb1e}\u{1f900}',
  layout: bindGroupLayout5,
  entries: [{binding: 18, resource: textureView69}],
});
let texture338 = device0.createTexture({
  size: [144, 48, 7],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView336 = texture8.createView({arrayLayerCount: 1});
try {
computePassEncoder65.setBindGroup(1, bindGroup175);
} catch {}
try {
computePassEncoder16.setBindGroup(2, bindGroup59, new Uint32Array(873), 28, 0);
} catch {}
try {
computePassEncoder99.dispatchWorkgroups(1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageData33,
  origin: { x: 20, y: 0 },
  flipY: true,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 3, y: 20, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData38 = new ImageData(76, 64);
try {
computePassEncoder64.setBindGroup(3, bindGroup119, new Uint32Array(1328), 261, 0);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle0, renderBundle0, renderBundle20]);
} catch {}
await gc();
let video3 = await videoWithData(77);
let texture339 = device0.createTexture({
  size: [39, 66, 1],
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView337 = texture328.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder158.setBindGroup(2, bindGroup113);
} catch {}
document.body.prepend(video0);
let videoFrame60 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'jedecP22Phosphors', transfer: 'smpteSt4281'} });
let textureView338 = texture218.createView({mipLevelCount: 1});
let sampler213 = device0.createSampler({
  label: '\uaba9\u2e5b\u3730\uf531\uf8ea\udef2\u{1fa1b}\ua64d\u347d\ua69f',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 45.88,
  lodMaxClamp: 47.86,
  maxAnisotropy: 1,
});
try {
renderPassEncoder45.setIndexBuffer(buffer64, 'uint16', 184, 4_857);
} catch {}
try {
device0.queue.writeBuffer(buffer139, 1224, new DataView(new ArrayBuffer(320)), 26, 28);
} catch {}
let pipelineLayout24 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture340 = device0.createTexture({size: [105, 1, 13], format: 'bgra8unorm-srgb', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView339 = texture194.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder26.setBindGroup(0, bindGroup165);
} catch {}
try {
computePassEncoder158.pushDebugGroup('\u1586');
} catch {}
try {
gpuCanvasContext15.configure({
  device: device0,
  format: 'astc-6x5-unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['stencil8'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroup193 = device0.createBindGroup({
  label: '\u57ee\u0db5\u51b3\uc06f\u0052\u09d7\u0ebc\uaf8a',
  layout: bindGroupLayout13,
  entries: [{binding: 97, resource: textureView119}, {binding: 123, resource: textureView161}],
});
try {
computePassEncoder15.setBindGroup(1, bindGroup26);
} catch {}
try {
renderPassEncoder46.setVertexBuffer(6, buffer47);
} catch {}
let videoFrame61 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpte432', transfer: 'bt1361ExtendedColourGamut'} });
let buffer243 = device0.createBuffer({size: 12467, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup67, new Uint32Array(711), 93, 0);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle21]);
} catch {}
try {
renderPassEncoder44.setVertexBuffer(0, buffer172, 0);
} catch {}
try {
  await promise43;
} catch {}
document.body.append(video1);
let bindGroup194 = device0.createBindGroup({layout: bindGroupLayout22, entries: [{binding: 4, resource: textureView322}]});
let buffer244 = device0.createBuffer({size: 4608, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
try {
computePassEncoder40.setBindGroup(3, bindGroup69, new Uint32Array(3610), 709, 0);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer58, 'uint32', 36, 48);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let buffer245 = device0.createBuffer({size: 2423, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroupsIndirect(buffer142, 120); };
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer36, 'uint16', 1_162, 2_306);
} catch {}
try {
computePassEncoder158.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer233, 3548, new Float32Array(570), 19, 60);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(3_375).fill(125), /* required buffer size: 3_375 */
{offset: 375, bytesPerRow: 60, rowsPerImage: 46}, {width: 0, height: 5, depthOrArrayLayers: 2});
} catch {}
await gc();
let buffer246 = device0.createBuffer({size: 314, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
try {
renderPassEncoder4.setBindGroup(1, bindGroup27, new Uint32Array(600), 55, 0);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(2, buffer241);
} catch {}
try {
gpuCanvasContext12.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let promise45 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 105, height: 1, depthOrArrayLayers: 273}
*/
{
  source: imageData35,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture298,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 13},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(video3);
let bindGroup195 = device0.createBindGroup({
  label: '\u{1f666}\u2bb9\ubcea\u{1ffcf}\u0aae',
  layout: bindGroupLayout39,
  entries: [{binding: 512, resource: textureView69}],
});
let texture341 = device0.createTexture({
  label: '\u{1fbec}\u{1f8b4}\uf246\u80eb\u4a2e\u0c39\u{1f8e8}\u3c45',
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView340 = texture187.createView({mipLevelCount: 1});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
externalTexture2.label = '\u0f87\u9d19\u8969\u513c\u05c0\u{1f7b7}\u0943\u{1fde3}';
} catch {}
let renderBundleEncoder41 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb']});
let sampler214 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 50.67,
  lodMaxClamp: 82.49,
  maxAnisotropy: 20,
});
try {
renderBundleEncoder41.setBindGroup(1, bindGroup176);
} catch {}
try {
renderBundleEncoder41.setIndexBuffer(buffer39, 'uint16', 170, 70);
} catch {}
try {
  await buffer81.mapAsync(GPUMapMode.WRITE, 0, 344);
} catch {}
let promise46 = adapter0.requestAdapterInfo();
let bindGroup196 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [
    {binding: 228, resource: {buffer: buffer169, offset: 0, size: 1288}},
    {binding: 172, resource: sampler125},
  ],
});
let buffer247 = device0.createBuffer({
  size: 1508,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let sampler215 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 23.68,
  lodMaxClamp: 91.23,
  compare: 'less',
});
try {
renderPassEncoder44.setBindGroup(0, bindGroup96);
} catch {}
try {
renderPassEncoder33.setScissorRect(1, 26, 41, 1);
} catch {}
try {
renderBundleEncoder41.setBindGroup(2, bindGroup114, new Uint32Array(675), 98, 0);
} catch {}
let arrayBuffer40 = buffer112.getMappedRange(776, 20);
try {
device0.queue.writeTexture({
  texture: texture175,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(392).fill(244), /* required buffer size: 392 */
{offset: 392, bytesPerRow: 11}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let texture342 = device0.createTexture({
  size: [3210, 4, 1],
  format: 'astc-5x4-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder29.beginOcclusionQuery(10);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(3, buffer46, 3_464, 1_852);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: canvas8,
  origin: { x: 14, y: 325 },
  flipY: false,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 5, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise47 = device0.createRenderPipelineAsync({
  layout: pipelineLayout20,
  fragment: {
  module: shaderModule20,
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'one', dstFactor: 'dst'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule18,
    buffers: [
      {
        arrayStride: 568,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 124, shaderLocation: 12},
          {format: 'sint8x4', offset: 48, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front'},
});
let bindGroup197 = device0.createBindGroup({layout: bindGroupLayout41, entries: [{binding: 87, resource: textureView331}]});
let buffer248 = device0.createBuffer({
  label: '\u0cd5\u00bd\u{1f80c}\u0036\u4af2\u0b26\u9fe1',
  size: 10844,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let externalTexture49 = device0.importExternalTexture({label: '\u{1f7aa}\u093d\u917c', source: videoFrame30});
try {
computePassEncoder75.setBindGroup(0, bindGroup197, new Uint32Array(1401), 44, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer162, 588); };
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup174, new Uint32Array(130), 32, 0);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer229, 'uint32', 396, 450);
} catch {}
try {
renderBundleEncoder41.setBindGroup(2, bindGroup161);
} catch {}
document.body.prepend(video1);
try {
computePassEncoder113.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer187, 'uint32', 6_848, 263);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData36,
  origin: { x: 0, y: 2 },
  flipY: true,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(video0);
let buffer249 = device0.createBuffer({
  size: 6081,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
computePassEncoder34.setBindGroup(2, bindGroup98, new Uint32Array(1960), 21, 0);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle5]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 105, height: 1, depthOrArrayLayers: 298}
*/
{
  source: imageData17,
  origin: { x: 10, y: 24 },
  flipY: true,
}, {
  texture: texture248,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 101},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder47.setBindGroup(0, bindGroup127, new Uint32Array(1344), 545, 0);
} catch {}
try {
renderBundleEncoder41.setBindGroup(0, bindGroup130, new Uint32Array(235), 27, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer156, 4136, new BigUint64Array(12966), 2908, 296);
} catch {}
let imageData39 = new ImageData(48, 4);
let bindGroup198 = device0.createBindGroup({
  layout: bindGroupLayout31,
  entries: [{binding: 9, resource: textureView162}, {binding: 80, resource: textureView67}],
});
let texture343 = device0.createTexture({
  label: '\u0be3\ub187\u0c29\uc573\ua311\u{1ffc6}\u{1f63d}\u{1f884}\u3d17\u5f2a',
  size: [9, 16, 1],
  sampleCount: 1,
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture344 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView341 = texture249.createView({baseMipLevel: 0});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer117, 44); };
} catch {}
try {
renderPassEncoder4.end();
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(7, undefined);
} catch {}
canvas0.width = 896;
let textureView342 = texture343.createView({dimension: '2d-array', baseMipLevel: 0, baseArrayLayer: 0});
let texture345 = device0.createTexture({
  size: {width: 144, height: 48, depthOrArrayLayers: 8},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder168.setBindGroup(3, bindGroup68);
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup182, new Uint32Array(874), 85, 0);
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer204, 'uint32', 64, 215);
} catch {}
try {
renderBundleEncoder41.setBindGroup(1, bindGroup15);
} catch {}
try {
renderBundleEncoder41.setIndexBuffer(buffer177, 'uint16', 1_840, 1_912);
} catch {}
let bindGroup199 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [{binding: 116, resource: textureView197}, {binding: 289, resource: textureView71}],
});
let texture346 = device0.createTexture({
  label: '\ubc52\u9331\u0962\u{1fe11}\u96b0\u19ce\ub29b\u0972\u33a4\u0cdc\u215f',
  size: [9, 16, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder172.setBindGroup(2, bindGroup3);
} catch {}
try {
computePassEncoder181.setBindGroup(1, bindGroup146, new Uint32Array(437), 21, 0);
} catch {}
try {
renderPassEncoder29.endOcclusionQuery();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture306,
  mipLevel: 0,
  origin: {x: 14, y: 3, z: 18},
  aspect: 'all',
}, new Uint8Array(96).fill(222), /* required buffer size: 96 */
{offset: 94, bytesPerRow: 1}, {width: 0, height: 3, depthOrArrayLayers: 1});
} catch {}
let img7 = await imageWithData(21, 144, '#10101010', '#20202020');
let imageData40 = new ImageData(40, 4);
let pipelineLayout25 = device0.createPipelineLayout({
  label: '\u7e42\u3394\u020c\u5649\u69db\u75a5\u{1f854}\u{1f968}\u0284',
  bindGroupLayouts: [bindGroupLayout36],
});
let textureView343 = texture284.createView({});
try {
computePassEncoder186.setBindGroup(0, bindGroup102);
} catch {}
try {
renderPassEncoder33.setBindGroup(0, bindGroup116);
} catch {}
try {
renderPassEncoder46.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder34.setViewport(559.2209335722678, 0.41233793391176543, 221.3723442681137, 0.19469693742478578, 0.8013285946686952, 0.9329198365866335);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(5, buffer47, 24, 165);
} catch {}
try {
renderBundleEncoder41.setBindGroup(1, bindGroup192);
} catch {}
try {
renderBundleEncoder41.setBindGroup(1, bindGroup185, new Uint32Array(4995), 537, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer72, 232, new Float32Array(3897), 1539, 72);
} catch {}
let bindGroup200 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView84}]});
let buffer250 = device0.createBuffer({
  size: 15230,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture347 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 89},
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderBundle41 = renderBundleEncoder41.finish({});
try {
computePassEncoder36.setBindGroup(2, bindGroup102, new Uint32Array(3175), 1_706, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder130); computePassEncoder130.dispatchWorkgroupsIndirect(buffer157, 108); };
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer218, 'uint16', 134, 80);
} catch {}
try {
buffer40.unmap();
} catch {}
let imageData41 = new ImageData(20, 16);
let bindGroup201 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 141, resource: sampler60},
    {binding: 261, resource: {buffer: buffer212, offset: 2304, size: 1048}},
    {binding: 270, resource: textureView142},
    {binding: 119, resource: {buffer: buffer100, offset: 512}},
    {binding: 47, resource: externalTexture26},
    {binding: 667, resource: textureView174},
    {binding: 311, resource: {buffer: buffer93, offset: 3328, size: 651}},
    {binding: 26, resource: textureView121},
    {binding: 54, resource: externalTexture46},
    {binding: 337, resource: textureView162},
    {binding: 79, resource: textureView113},
    {binding: 414, resource: textureView8},
    {binding: 164, resource: textureView142},
    {binding: 116, resource: sampler159},
    {binding: 221, resource: textureView171},
    {binding: 78, resource: textureView165},
  ],
});
try {
computePassEncoder133.setBindGroup(2, bindGroup146, new Uint32Array(3457), 509, 0);
} catch {}
try {
computePassEncoder44.end();
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup170, []);
} catch {}
try {
renderPassEncoder45.setScissorRect(12, 7, 0, 1);
} catch {}
try {
commandEncoder57.copyBufferToBuffer(buffer181, 10624, buffer103, 500, 88);
} catch {}
try {
gpuCanvasContext13.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING});
} catch {}
try {
device0.queue.writeBuffer(buffer25, 160, new Int16Array(8574), 341, 268);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture111,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(72).fill(101), /* required buffer size: 72 */
{offset: 72, bytesPerRow: 265, rowsPerImage: 0}, {width: 33, height: 0, depthOrArrayLayers: 34});
} catch {}
let bindGroupLayout43 = device0.createBindGroupLayout({
  entries: [{binding: 192, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}],
});
let commandBuffer16 = commandEncoder57.finish({});
let sampler216 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 61.75,
  lodMaxClamp: 87.87,
  compare: 'less',
});
let externalTexture50 = device0.importExternalTexture({source: video2});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 16}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture31,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture348 = gpuCanvasContext8.getCurrentTexture();
let sampler217 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 92.74,
});
try {
computePassEncoder134.setBindGroup(0, bindGroup132);
} catch {}
try {
buffer250.destroy();
} catch {}
document.body.append(img4);
let promise48 = adapter0.requestAdapterInfo();
let commandEncoder272 = device0.createCommandEncoder({});
let textureView344 = texture228.createView({});
let computePassEncoder224 = commandEncoder272.beginComputePass({});
let texture349 = device0.createTexture({
  label: '\uae5d\ue709\u3665\ufae1\u028a\ue5f1\u029c',
  size: {width: 840},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder224.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder27.setScissorRect(1, 2, 0, 0);
} catch {}
try {
renderPassEncoder16.setViewport(104.87276830649024, 0.20353983363128103, 26.854610199234344, 0.06418108343293259, 0.7046007863532463, 0.9682342452107855);
} catch {}
let buffer251 = device0.createBuffer({
  label: '\u0299\u{1fcb0}\u88bc\u0a33\u{1f6e1}\u4747\u5b59\u9244',
  size: 8346,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler218 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 14.88,
  lodMaxClamp: 31.27,
  maxAnisotropy: 18,
});
try {
computePassEncoder187.setBindGroup(3, bindGroup167, new Uint32Array(378), 37, 0);
} catch {}
try {
renderPassEncoder30.setBindGroup(2, bindGroup198);
} catch {}
let arrayBuffer41 = buffer45.getMappedRange(32, 0);
try {
device0.queue.submit([commandBuffer16]);
} catch {}
let buffer252 = device0.createBuffer({
  size: 32180,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
try {
renderPassEncoder19.setBindGroup(1, bindGroup113, new Uint32Array(3336), 3_336, 0);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle21]);
} catch {}
let renderBundleEncoder42 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], stencilReadOnly: true});
try {
computePassEncoder54.setBindGroup(2, bindGroup33, []);
} catch {}
try {
renderBundleEncoder42.setBindGroup(1, bindGroup171);
} catch {}
try {
renderBundleEncoder42.setIndexBuffer(buffer153, 'uint32', 1_048, 188);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(7, buffer209);
} catch {}
let pipeline15 = device0.createRenderPipeline({
  layout: pipelineLayout12,
  fragment: {
  module: shaderModule9,
  targets: [{format: 'rgba32sint'}, {
  format: 'rg32float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rgba16sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  vertex: {
    module: shaderModule9,
    constants: {50_087: 1},
    buffers: [
      {
        arrayStride: 100,
        stepMode: 'instance',
        attributes: [{format: 'sint32x2', offset: 0, shaderLocation: 7}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
document.body.prepend(video0);
let texture350 = device0.createTexture({
  size: [32, 32, 16],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder207.setBindGroup(0, bindGroup182, new Uint32Array(218), 32, 0);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(4, buffer237, 4_492);
} catch {}
try {
renderBundleEncoder42.setBindGroup(1, bindGroup172, new Uint32Array(78), 17, 0);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(5, buffer13);
} catch {}
let texture351 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView345 = texture276.createView({dimension: '2d-array', baseArrayLayer: 0, arrayLayerCount: 1});
try {
renderPassEncoder37.setBindGroup(2, bindGroup36, new Uint32Array(935), 73, 0);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer20, 'uint16', 10, 364);
} catch {}
try {
renderBundleEncoder42.setBindGroup(3, bindGroup52, []);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(6, buffer185);
} catch {}
try {
querySet16.destroy();
} catch {}
try {
  await buffer133.mapAsync(GPUMapMode.READ, 0, 2636);
} catch {}
try {
renderPassEncoder24.insertDebugMarker('\u{1f7ad}');
} catch {}
try {
device0.queue.writeBuffer(buffer227, 364, new BigUint64Array(4270), 1494, 284);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline16 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule3, constants: {8_882: 1}}});
let bindGroupLayout44 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 27,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let querySet40 = device0.createQuerySet({type: 'occlusion', count: 395});
try {
renderPassEncoder41.executeBundles([renderBundle6, renderBundle17]);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(1, buffer114, 0);
} catch {}
try {
renderBundleEncoder42.setIndexBuffer(buffer60, 'uint32', 1_464, 652);
} catch {}
try {
renderBundleEncoder42.setPipeline(pipeline10);
} catch {}
try {
  await promise48;
} catch {}
let querySet41 = device0.createQuerySet({type: 'occlusion', count: 266});
let texture352 = device0.createTexture({
  size: [550, 20, 1],
  mipLevelCount: 2,
  format: 'astc-10x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder43 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], stencilReadOnly: false});
let sampler219 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 46.38,
  lodMaxClamp: 48.11,
  maxAnisotropy: 8,
});
try {
renderPassEncoder30.setBindGroup(3, bindGroup39);
} catch {}
try {
renderPassEncoder23.setScissorRect(74, 13, 18, 20);
} catch {}
try {
renderBundleEncoder42.setBindGroup(1, bindGroup33, new Uint32Array(877), 89, 0);
} catch {}
try {
renderBundleEncoder43.setVertexBuffer(0, buffer244, 1_160);
} catch {}
try {
buffer58.unmap();
} catch {}
let shaderModule22 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 33 max align: 1 */
struct T0 {
  @align(1) @size(33) f0: atomic<u32>,
}
@group(0) @binding(558) var sam14: sampler;
@group(0) @binding(29) var tex19: texture_cube<f32>;
@group(0) @binding(186) var<storage, read> buffer253: array<T0>;
@group(0) @binding(146) var<uniform> buffer254: array<f16, 21>;

@vertex
fn vertex0() -> @builtin(position) vec4f {
  var out: vec4f;
  out *= vec4f(0.01749, 0.1822, 0.08146, 0.01179);
  return out;
}

@fragment
fn fragment0() -> @location(200) vec3f {
  var out: vec3f;
  return out;
}

@compute @workgroup_size(1, 2, 1)
fn compute0() {
  _ = buffer254[0];
}

@compute @workgroup_size(2, 1, 1)
fn compute1() {
}`,
  sourceMap: {},
  hints: {},
});
try {
computePassEncoder199.setBindGroup(0, bindGroup121);
} catch {}
try {
renderBundleEncoder42.setBindGroup(3, bindGroup193);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 150}
*/
{
  source: img5,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture292,
  mipLevel: 0,
  origin: {x: 6, y: 6, z: 42},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder137.setBindGroup(1, bindGroup16, new Uint32Array(2871), 1_050, 0);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(5, buffer18, 0);
} catch {}
document.body.append(img5);
video2.height = 10;
let videoFrame62 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte170m', transfer: 'smpteSt4281'} });
let bindGroup202 = device0.createBindGroup({
  layout: bindGroupLayout33,
  entries: [{binding: 834, resource: textureView301}, {binding: 566, resource: textureView7}],
});
let buffer255 = device0.createBuffer({size: 38003, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
renderPassEncoder24.executeBundles([renderBundle10, renderBundle20]);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer134, 'uint32', 188, 4_786);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(0, buffer193);
} catch {}
try {
renderBundleEncoder42.setBindGroup(0, bindGroup29, new Uint32Array(5090), 2_169, 0);
} catch {}
await gc();
let offscreenCanvas8 = new OffscreenCanvas(572, 407);
let bindGroup203 = device0.createBindGroup({layout: bindGroupLayout24, entries: [{binding: 425, resource: textureView197}]});
let buffer256 = device0.createBuffer({
  size: 8654,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let renderBundle42 = renderBundleEncoder43.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer14, 76); };
} catch {}
try {
renderPassEncoder33.setBindGroup(1, bindGroup71);
} catch {}
try {
renderPassEncoder38.setBindGroup(2, bindGroup49, new Uint32Array(3139), 425, 0);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(7, buffer252, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer257 = device0.createBuffer({
  size: 13324,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
try {
renderPassEncoder27.setBindGroup(3, bindGroup75);
} catch {}
try {
renderPassEncoder26.end();
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle23, renderBundle5]);
} catch {}
try {
renderBundleEncoder42.setBindGroup(3, bindGroup78, new Uint32Array(2790), 84, 0);
} catch {}
try {
renderBundleEncoder42.setIndexBuffer(buffer162, 'uint32', 5_080, 5_352);
} catch {}
try {
renderBundleEncoder42.setPipeline(pipeline10);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let arrayBuffer42 = buffer67.getMappedRange(1952, 20);
let texture353 = device0.createTexture({
  label: '\u8da8\u{1fa57}\u10a7',
  size: [105, 1, 13],
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder134.setBindGroup(3, bindGroup70, []);
} catch {}
try {
computePassEncoder205.setBindGroup(3, bindGroup164, new Uint32Array(2017), 118, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer212, 2_556); };
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer117, 'uint16', 80, 6);
} catch {}
try {
renderBundleEncoder42.setBindGroup(1, bindGroup102, []);
} catch {}
try {
renderBundleEncoder42.setIndexBuffer(buffer82, 'uint16', 180, 14);
} catch {}
let arrayBuffer43 = buffer217.getMappedRange(440, 664);
try {
device0.queue.writeTexture({
  texture: texture322,
  mipLevel: 2,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(188).fill(14), /* required buffer size: 188 */
{offset: 188}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer258 = device0.createBuffer({
  size: 36540,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder16.setBindGroup(3, bindGroup158);
} catch {}
try {
renderPassEncoder34.setBindGroup(2, bindGroup185, new Uint32Array(3707), 141, 0);
} catch {}
try {
renderBundleEncoder42.setIndexBuffer(buffer83, 'uint32', 1_124, 2_102);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let renderBundle43 = renderBundleEncoder42.finish({});
try {
renderPassEncoder33.executeBundles([renderBundle21]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
  await promise45;
} catch {}
document.body.prepend(canvas2);
canvas11.height = 990;
let textureView346 = texture41.createView({mipLevelCount: 1});
try {
renderPassEncoder46.executeBundles([renderBundle21, renderBundle6, renderBundle21]);
} catch {}
try {
renderPassEncoder19.setScissorRect(54, 8, 12, 0);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
let gpuCanvasContext20 = offscreenCanvas8.getContext('webgpu');
try {
  await promise46;
} catch {}
let texture354 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 53},
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder37.setBindGroup(1, bindGroup171, new Uint32Array(2018), 242, 0);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let videoFrame63 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt470bg', transfer: 'bt2020_12bit'} });
let bindGroup204 = device0.createBindGroup({layout: bindGroupLayout41, entries: [{binding: 87, resource: textureView323}]});
try {
renderPassEncoder33.executeBundles([renderBundle10, renderBundle0, renderBundle20]);
} catch {}
try {
renderPassEncoder37.setScissorRect(0, 0, 0, 0);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(1, buffer223, 456, 50);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture177,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(19).fill(16), /* required buffer size: 19 */
{offset: 19}, {width: 124, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule23 = device0.createShaderModule({
  label: '\ud5e4\u{1fa13}\u78f6\ua75c\ue460\u45d6\u{1f89c}',
  code: `
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  f0: mat2x4h,
}
/* target size: 8 max align: 8 */
struct T1 {
  @size(8) f0: array<atomic<u32>>,
}
/* target size: 149 max align: 1 */
struct T2 {
  @align(1) f0: array<atomic<u32>, 1>,
  @align(1) f1: vec2u,
  @align(1) @size(137) f2: T1,
}
/* target size: 16 max align: 16 */
struct T3 {
  @size(16) f0: T1,
}
/* target size: 37 max align: 1 */
struct T4 {
  @align(1) @size(37) f0: array<f16, 2>,
}
@group(0) @binding(313) var tex20: texture_depth_2d_array;
struct VertexOutput18 {
  @builtin(position) f51: vec4f,
  @location(11) @interpolate(flat, centroid) f52: vec3i
}

@vertex
fn vertex0(@location(14) @interpolate(flat) a0: vec3i) -> VertexOutput18 {
  var out: VertexOutput18;
  if bool(textureLoad(tex20, vec2i(), 0, 0)) {
    out.f51 = vec4f(bitcast<f32>(textureLoad(tex20, vec2i(), 0, 0)));
  }
  return out;
}
struct FragmentOutput18 {
  @location(1) f0: vec3i,
  @location(0) @interpolate(flat) f1: vec3f,
  @location(6) @interpolate(linear, center) f2: vec3f
}

@fragment
fn fragment0() -> FragmentOutput18 {
  var out: FragmentOutput18;
  if bool(textureLoad(tex20, vec2i(), 0, 0)) {
    discard;
  }
  if bool(textureLoad(tex20, vec2i(), 0, 0)) {
    out.f0 *= vec3i(bitcast<i32>(textureLoad(tex20, vec2i(), 0, 0)));
  }
  return out;
}`,
  hints: {},
});
let buffer259 = device0.createBuffer({
  size: 1009,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture355 = device0.createTexture({size: [210, 1, 1], format: 'rg16float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
computePassEncoder10.setBindGroup(3, bindGroup95);
} catch {}
try {
renderPassEncoder46.setScissorRect(0, 0, 4, 2);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer221, 28, 175);
} catch {}
try {
buffer124.unmap();
} catch {}
let bindGroup205 = device0.createBindGroup({layout: bindGroupLayout32, entries: [{binding: 51, resource: textureView168}]});
let buffer260 = device0.createBuffer({
  size: 37336,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let querySet42 = device0.createQuerySet({type: 'occlusion', count: 192});
try {
computePassEncoder96.setBindGroup(2, bindGroup49);
} catch {}
try {
computePassEncoder194.setBindGroup(2, bindGroup170, new Uint32Array(1712), 68, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer63, 1856, new BigUint64Array(1555), 389, 132);
} catch {}
let pipelineLayout26 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer261 = device0.createBuffer({
  label: '\u01b8\ucf7b\u{1fa08}\ufe34\u{1fc9a}',
  size: 2135,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder128.setBindGroup(1, bindGroup17);
} catch {}
try {
computePassEncoder99.setBindGroup(3, bindGroup120, new Uint32Array(3891), 823, 1);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder48.setBindGroup(3, bindGroup190);
} catch {}
try {
renderPassEncoder38.setBindGroup(1, bindGroup15, new Uint32Array(697), 131, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer187, 'uint16', 9_686, 75);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(66).fill(140), /* required buffer size: 66 */
{offset: 66}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture17.label = '\uf652\u{1f906}\u{1fb61}\u414e\uab21\udb42';
} catch {}
let texture356 = device0.createTexture({
  size: [19, 33, 1],
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler220 = device0.createSampler({
  label: '\u9d58\u94b7\u{1fa66}\u3ced',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  lodMinClamp: 23.75,
  lodMaxClamp: 54.26,
  compare: 'less-equal',
});
let externalTexture51 = device0.importExternalTexture({source: videoFrame34});
try {
computePassEncoder5.setBindGroup(0, bindGroup0, new Uint32Array(909), 77, 0);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer1, 'uint32', 8_852, 238);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(3, buffer228, 0, 160);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageData29,
  origin: { x: 7, y: 0 },
  flipY: true,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 5, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 6, depthOrArrayLayers: 0});
} catch {}
let videoFrame64 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt709', transfer: 'bt1361ExtendedColourGamut'} });
let sampler221 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 79.11,
  lodMaxClamp: 93.61,
  maxAnisotropy: 14,
});
try {
computePassEncoder124.setBindGroup(0, bindGroup205, new Uint32Array(1394), 3, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup126, new Uint32Array(882), 7, 0);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle5, renderBundle20]);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer28, 'uint16', 1_224, 8_124);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture56,
  mipLevel: 1,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(158).fill(17), /* required buffer size: 158 */
{offset: 158, bytesPerRow: 118}, {width: 1, height: 7, depthOrArrayLayers: 0});
} catch {}
let bindGroup206 = device0.createBindGroup({
  layout: bindGroupLayout34,
  entries: [
    {binding: 643, resource: textureView291},
    {binding: 101, resource: {buffer: buffer213, offset: 512, size: 22}},
    {binding: 170, resource: textureView47},
    {binding: 167, resource: sampler146},
  ],
});
let textureView347 = texture338.createView({mipLevelCount: 1});
try {
device0.queue.writeBuffer(buffer157, 16, new DataView(new ArrayBuffer(33859)), 762, 64);
} catch {}
let bindGroup207 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 9, resource: textureView59},
    {binding: 453, resource: textureView346},
    {binding: 102, resource: textureView237},
  ],
});
let texture357 = device0.createTexture({size: [19, 33, 1], format: 'rg16float', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder27.setBindGroup(2, bindGroup38, new Uint32Array(816), 4, 0);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle5, renderBundle42, renderBundle7, renderBundle7]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: videoFrame53,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView348 = texture237.createView({});
try {
renderPassEncoder23.setBindGroup(0, bindGroup89, new Uint32Array(370), 21, 0);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle5, renderBundle21, renderBundle17, renderBundle17]);
} catch {}
document.body.append(video0);
try {
computePassEncoder140.setBindGroup(0, bindGroup195);
} catch {}
try {
computePassEncoder84.setBindGroup(2, bindGroup83, new Uint32Array(3012), 18, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle38, renderBundle38]);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer74, 'uint32', 848, 2_008);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(3, buffer240);
} catch {}
try {
device0.queue.writeBuffer(buffer148, 632, new Int16Array(6620), 1601, 524);
} catch {}
let buffer262 = device0.createBuffer({
  size: 30312,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let renderBundleEncoder44 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], stencilReadOnly: true});
try {
computePassEncoder178.setBindGroup(1, bindGroup192, new Uint32Array(4461), 168, 0);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder44.setVertexBuffer(6, buffer87, 0, 13);
} catch {}
let pipeline17 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule3, constants: {8_882: 1}}});
let texture358 = device0.createTexture({
  label: '\u0631\u6bf6\udaa1\u98a5',
  size: {width: 288, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView349 = texture238.createView({dimension: '3d', format: 'r8unorm', mipLevelCount: 1});
let externalTexture52 = device0.importExternalTexture({source: videoFrame54});
try {
renderPassEncoder37.setIndexBuffer(buffer109, 'uint32', 4_856, 9_421);
} catch {}
try {
renderBundleEncoder44.setBindGroup(0, bindGroup13);
} catch {}
try {
renderBundleEncoder44.setIndexBuffer(buffer234, 'uint32', 1_780, 1_221);
} catch {}
let promise49 = shaderModule5.getCompilationInfo();
let bindGroupLayout45 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 31,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 243,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 89,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 52,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let textureView350 = texture188.createView({dimension: '2d-array'});
let renderBundleEncoder45 = device0.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle44 = renderBundleEncoder44.finish();
let sampler222 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 13.16,
  lodMaxClamp: 25.07,
  maxAnisotropy: 2,
});
try {
computePassEncoder31.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(6);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(2, buffer113, 1_452, 3_027);
} catch {}
try {
renderBundleEncoder45.setBindGroup(3, bindGroup14);
} catch {}
let pipeline18 = device0.createComputePipeline({
  label: '\u{1ff7e}\u05ff\u1f4d\u0335\u5c77\ua5d1\u076a\u0e29',
  layout: pipelineLayout14,
  compute: {module: shaderModule14, constants: {}},
});
let buffer263 = device0.createBuffer({
  label: '\u{1fcb8}\ue251\u5168\u0c7f\u8411\u640e\u9376\ud119',
  size: 6076,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let renderBundle45 = renderBundleEncoder45.finish({});
let sampler223 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 95.89,
  lodMaxClamp: 99.52,
  maxAnisotropy: 11,
});
try {
renderPassEncoder45.setBindGroup(1, bindGroup14, new Uint32Array(601), 177, 0);
} catch {}
try {
  await shaderModule10.getCompilationInfo();
} catch {}
try {
device0.queue.submit([]);
} catch {}
let texture359 = device0.createTexture({
  size: {width: 144, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView351 = texture323.createView({aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder62.setBindGroup(2, bindGroup175);
} catch {}
try {
renderPassEncoder46.setBindGroup(1, bindGroup112);
} catch {}
let querySet43 = device0.createQuerySet({type: 'occlusion', count: 1012});
let sampler224 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 25.18,
  lodMaxClamp: 29.53,
  compare: 'less-equal',
  maxAnisotropy: 5,
});
try {
computePassEncoder185.setBindGroup(1, bindGroup116);
} catch {}
let promise50 = shaderModule22.getCompilationInfo();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: videoFrame28,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 2, y: 4, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
canvas10.width = 71;
let videoFrame65 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpteRp431', transfer: 'bt709'} });
let texture360 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
computePassEncoder109.setBindGroup(2, bindGroup17, new Uint32Array(2662), 646, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup40, new Uint32Array(3189), 192, 0);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer118, 968);
} catch {}
let arrayBuffer44 = buffer47.getMappedRange(6376, 0);
try {
  await adapter0.requestAdapterInfo();
} catch {}
let sampler225 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 72.38,
  lodMaxClamp: 79.38,
});
try {
computePassEncoder138.setBindGroup(1, bindGroup192, new Uint32Array(4912), 752, 0);
} catch {}
try {
renderPassEncoder45.beginOcclusionQuery(12);
} catch {}
try {
  await promise49;
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
device0.queue.writeBuffer(buffer35, 820, new Int16Array(47835), 9470, 24);
} catch {}
try {
if (!arrayBuffer21.detached) { new Uint8Array(arrayBuffer21).fill(0x55); };
} catch {}
let textureView352 = texture188.createView({label: '\u9832\u{1fafa}', dimension: '2d-array', aspect: 'all'});
let texture361 = device0.createTexture({
  label: '\u00f6\u88f0\uad18\u80bc\u0e9b\u4228',
  size: [210, 1, 1],
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView353 = texture82.createView({dimension: '2d-array'});
try {
renderPassEncoder48.setBindGroup(0, bindGroup129, new Uint32Array(4431), 856, 0);
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer159, 'uint32', 24, 75);
} catch {}
try {
gpuCanvasContext19.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST, alphaMode: 'opaque'});
} catch {}
let promise51 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 1, depthOrArrayLayers: 136}
*/
{
  source: imageData10,
  origin: { x: 11, y: 5 },
  flipY: true,
}, {
  texture: texture298,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise50;
} catch {}
let video4 = await videoWithData(69);
let sampler226 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 32.43,
  lodMaxClamp: 66.29,
});
let externalTexture53 = device0.importExternalTexture({label: '\u02c6\u391a\u0ebe\ub875', source: videoFrame30});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup143, new Uint32Array(569), 119, 0);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
computePassEncoder105.setBindGroup(0, bindGroup19);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let arrayBuffer45 = buffer0.getMappedRange(4072, 268);
try {
device0.queue.writeBuffer(buffer63, 36, new BigUint64Array(927), 233, 44);
} catch {}
let sampler227 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 11.00,
  lodMaxClamp: 21.41,
  maxAnisotropy: 9,
});
try {
computePassEncoder113.setBindGroup(2, bindGroup9);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer151, 84); };
} catch {}
try {
renderPassEncoder39.setBindGroup(0, bindGroup114, []);
} catch {}
try {
renderPassEncoder44.end();
} catch {}
try {
texture228.destroy();
} catch {}
let texture362 = device0.createTexture({
  size: [144, 48, 754],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture54 = device0.importExternalTexture({source: video0});
try {
renderPassEncoder45.endOcclusionQuery();
} catch {}
try {
renderPassEncoder27.setScissorRect(0, 2, 0, 0);
} catch {}
try {
computePassEncoder14.pushDebugGroup('\u0cc8');
} catch {}
let buffer264 = device0.createBuffer({
  label: '\uf3ec\u{1fa01}\u6966\u{1f754}\ub3a9\u{1f794}\u9d82\u9580\u6e97\u8ce4\u6015',
  size: 29403,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: false,
});
let texture363 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderPassEncoder46.executeBundles([renderBundle21]);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(6, buffer85);
} catch {}
let sampler228 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 87.11,
  lodMaxClamp: 97.80,
});
try {
computePassEncoder162.setPipeline(pipeline16);
} catch {}
let arrayBuffer46 = buffer67.getMappedRange(2624, 60);
try {
  await promise51;
} catch {}
try {
computePassEncoder125.setBindGroup(1, bindGroup72, new Uint32Array(2801), 1_483, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer96, 3236, new DataView(new ArrayBuffer(9339)), 357, 468);
} catch {}
let bindGroup208 = device0.createBindGroup({
  layout: bindGroupLayout38,
  entries: [
    {binding: 131, resource: sampler167},
    {binding: 116, resource: {buffer: buffer36, offset: 7424, size: 4532}},
    {binding: 15, resource: textureView246},
    {binding: 75, resource: textureView92},
    {binding: 222, resource: {buffer: buffer261, offset: 0, size: 2076}},
    {binding: 752, resource: {buffer: buffer70, offset: 1792, size: 1197}},
    {binding: 158, resource: externalTexture6},
    {binding: 208, resource: {buffer: buffer211, offset: 1280, size: 8080}},
    {binding: 209, resource: {buffer: buffer36, offset: 4352}},
    {binding: 166, resource: {buffer: buffer93, offset: 2048, size: 1237}},
    {binding: 396, resource: {buffer: buffer131, offset: 0, size: 1616}},
  ],
});
let renderBundleEncoder46 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint']});
let sampler229 = device0.createSampler({
  label: '\ucb67\u0013\ubac2\u27a4\u5c8b\u{1fbd1}\uaeb9\u031d',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 88.98,
  lodMaxClamp: 98.29,
  maxAnisotropy: 1,
});
try {
renderBundleEncoder46.setBindGroup(1, bindGroup9);
} catch {}
try {
renderBundleEncoder46.setBindGroup(2, bindGroup181, new Uint32Array(323), 68, 0);
} catch {}
try {
renderBundleEncoder46.setVertexBuffer(4, buffer46, 248, 450);
} catch {}
let promise52 = device0.queue.onSubmittedWorkDone();
let textureView354 = texture93.createView({baseArrayLayer: 0});
let renderBundle46 = renderBundleEncoder46.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder122); computePassEncoder122.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup0, new Uint32Array(476), 37, 0);
} catch {}
let promise53 = device0.queue.onSubmittedWorkDone();
let bindGroup209 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 50, resource: textureView98},
    {binding: 408, resource: {buffer: buffer206, offset: 1024, size: 778}},
    {binding: 27, resource: textureView159},
  ],
});
let texture364 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 58},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let texture365 = gpuCanvasContext8.getCurrentTexture();
let sampler230 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.02,
  compare: 'always',
  maxAnisotropy: 2,
});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder30.setBindGroup(1, bindGroup81);
} catch {}
try {
renderPassEncoder34.executeBundles([renderBundle10, renderBundle10, renderBundle20, renderBundle17, renderBundle17]);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer161, 'uint32', 952, 1_340);
} catch {}
let bindGroup210 = device0.createBindGroup({
  layout: bindGroupLayout25,
  entries: [
    {binding: 252, resource: textureView146},
    {binding: 1, resource: textureView59},
    {binding: 129, resource: textureView142},
    {binding: 6, resource: textureView10},
    {binding: 171, resource: textureView176},
  ],
});
try {
computePassEncoder223.setBindGroup(3, bindGroup175);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer145);
} catch {}
let arrayBuffer47 = buffer134.getMappedRange(896, 552);
try {
device0.queue.writeTexture({
  texture: texture112,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(95).fill(162), /* required buffer size: 95 */
{offset: 95, bytesPerRow: 40}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle5, renderBundle38, renderBundle7]);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.append(canvas10);
let sampler231 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 79.36,
  maxAnisotropy: 10,
});
try {
computePassEncoder139.setBindGroup(3, bindGroup180, new Uint32Array(473), 153, 0);
} catch {}
try {
renderPassEncoder14.setBlendConstant({ r: 303.8, g: 43.12, b: -358.1, a: -770.8, });
} catch {}
try {
computePassEncoder14.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer63, 340, new Float32Array(6610), 95, 432);
} catch {}
let promise54 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer32.detached) { new Uint8Array(arrayBuffer32).fill(0x55); };
} catch {}
video3.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let bindGroup211 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [{binding: 228, resource: textureView340}, {binding: 41, resource: textureView326}],
});
let buffer265 = device0.createBuffer({size: 11552, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder30.setBindGroup(1, bindGroup38);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle5, renderBundle5]);
} catch {}
try {
buffer130.destroy();
} catch {}
let promise55 = device0.queue.onSubmittedWorkDone();
let buffer266 = device0.createBuffer({
  size: 799,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let textureView355 = texture325.createView({label: '\u{1fbc1}\u0593\ue82f\u2e08\u0bda\u0ce7\u488c'});
try {
renderPassEncoder34.setBindGroup(2, bindGroup168, new Uint32Array(3204), 804, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer165, 'uint16', 12, 5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture214,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(386).fill(92), /* required buffer size: 386 */
{offset: 386}, {width: 25, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture366 = device0.createTexture({
  size: {width: 19, height: 33, depthOrArrayLayers: 626},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder45.setBindGroup(0, bindGroup87);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup44);
} catch {}
try {
renderPassEncoder29.executeBundles([renderBundle10, renderBundle7]);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer228, 'uint16', 2_700, 32);
} catch {}
try {
device0.queue.writeBuffer(buffer48, 28, new Float32Array(910), 104, 8);
} catch {}
try {
if (!arrayBuffer45.detached) { new Uint8Array(arrayBuffer45).fill(0x55); };
} catch {}
let bindGroupLayout46 = device0.createBindGroupLayout({
  label: '\u4687\ufc6a\u{1f740}\ud6ba\uc648',
  entries: [
    {
      binding: 95,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let texture367 = device0.createTexture({size: [39, 66, 1], mipLevelCount: 4, format: 'r16float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
computePassEncoder102.setBindGroup(1, bindGroup18);
} catch {}
try {
computePassEncoder83.setBindGroup(2, bindGroup100, new Uint32Array(1403), 9, 0);
} catch {}
try {
renderPassEncoder47.setBindGroup(2, bindGroup93);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(0, buffer138, 416, 132);
} catch {}
let pipelineLayout27 = device0.createPipelineLayout({bindGroupLayouts: []});
try {
renderPassEncoder16.setIndexBuffer(buffer79, 'uint16', 2_430, 596);
} catch {}
let canvas13 = document.createElement('canvas');
let textureView356 = texture47.createView({
  label: '\u0878\u0fcd\u060e\u2b27\u5afc\u08af\u0125\u76c6\u4434\u{1fecf}',
  dimension: '2d-array',
  mipLevelCount: 1,
});
try {
computePassEncoder83.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle6, renderBundle0, renderBundle10, renderBundle20]);
} catch {}
try {
querySet5.destroy();
} catch {}
try {
buffer39.unmap();
} catch {}
try {
  await promise53;
} catch {}
let shaderModule24 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 4 max align: 4 */
struct T0 {
  f0: atomic<i32>,
}
/* target size: 4 max align: 4 */
struct T1 {
  f0: vec2h,
}
@id(57031) override override86 : bool;
override override85 : f16;
override override84 : u32 = 109;
@group(1) @binding(170) var tex22: texture_cube<u32>;
@group(1) @binding(167) var sam15: sampler_comparison;
@group(1) @binding(643) var tex23: texture_3d<f32>;
@group(0) @binding(212) var tex21: texture_1d<u32>;
@group(1) @binding(101) var<uniform> buffer267: vec2h;
struct VertexOutput19 {
  @location(2) @interpolate(perspective, centroid) f53: vec2h,
  @builtin(position) f54: vec4f,
  @location(14) @interpolate(perspective, center) f55: vec4f,
  @location(10) f56: f16,
  @location(11) f57: vec3u,
  @location(9) f58: vec3h,
  @location(0) f59: vec3f,
  @location(7) @interpolate(perspective, centroid) f60: vec2f,
  @location(12) @interpolate(flat, sample) f61: vec4h,
  @location(4) f62: vec2h,
  @location(1) @interpolate(linear, centroid) f63: vec4h
}

@vertex
fn vertex0() -> VertexOutput19 {
  var out: VertexOutput19;
  _ = textureLoad(tex23, vec3i(), 0);
  _ = override84;
  out.f60 = vec2f(0.04493, 0.2276);
  if override86 {
    out.f53 = vec2h(-32618.6);
  }
  if override86 {
    out.f63 = vec4h(-38420.6);
  }
  if bool(textureLoad(tex23, vec3i(), 0)[1]) {
    out.f57 = bitcast<vec3u>(textureLoad(tex23, vec3i(), 0).xzw);
  }
  return out;
}
struct FragmentOutput19 {
  @location(0) f0: vec4i,
  @location(6) f1: vec4f,
  @location(1) f2: vec2f,
  @location(2) f3: vec4i
}

@fragment
fn fragment0() -> FragmentOutput19 {
  var out: FragmentOutput19;
  return out;
}

@compute @workgroup_size(2, 1, 1)
fn compute0() {
  _ = override85;
}`,
  sourceMap: {},
  hints: {},
});
let textureView357 = texture74.createView({mipLevelCount: 1});
let sampler232 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  mipmapFilter: 'linear',
  lodMinClamp: 13.37,
  lodMaxClamp: 48.42,
});
try {
renderPassEncoder48.setIndexBuffer(buffer159, 'uint32', 96, 71);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(0, buffer185, 568);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 72, new Int16Array(4389), 789, 20);
} catch {}
let texture368 = device0.createTexture({
  label: '\u1914\u{1f8fa}\u0bc6\u{1ffe0}\u{1f9a5}\u04a2',
  size: [32, 32, 16],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture55 = device0.importExternalTexture({source: videoFrame39});
try {
computePassEncoder207.setBindGroup(3, bindGroup47, new Uint32Array(2414), 636, 0);
} catch {}
try {
renderPassEncoder29.executeBundles([renderBundle38]);
} catch {}
try {
gpuCanvasContext14.unconfigure();
} catch {}
await gc();
let texture369 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler233 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 98.03,
});
try {
computePassEncoder88.setBindGroup(3, bindGroup182);
} catch {}
try {
renderPassEncoder30.setBindGroup(0, bindGroup131);
} catch {}
let imageData42 = new ImageData(4, 64);
let videoFrame66 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpteRp431', transfer: 'iec6196624'} });
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer245, 'uint16', 96, 526);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer134, 996, 5_389);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 1, depthOrArrayLayers: 149}
*/
{
  source: offscreenCanvas7,
  origin: { x: 54, y: 23 },
  flipY: false,
}, {
  texture: texture248,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 21},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
buffer105.unmap();
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let gpuCanvasContext21 = canvas13.getContext('webgpu');
video3.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let texture370 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 5},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder48.setStencilReference(388);
} catch {}
try {
renderPassEncoder14.setViewport(116.82906155653843, 0.6653358666690646, 55.284521865600524, 0.03482511103319395, 0.6355757649574975, 0.7366511133409678);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer104, 'uint32', 1_416, 146);
} catch {}
try {
device0.queue.writeBuffer(buffer151, 744, new Int16Array(7170), 1100, 4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture26,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(305).fill(94), /* required buffer size: 305 */
{offset: 305, bytesPerRow: 37}, {width: 0, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer34.detached) { new Uint8Array(arrayBuffer34).fill(0x55); };
} catch {}
let shaderModule25 = device0.createShaderModule({
  code: `
enable f16;
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  f0: mat2x3h,
}
/* target size: 16 max align: 16 */
struct T1 {
  @align(2) @size(16) f0: array<atomic<u32>>,
}
/* target size: 16 max align: 16 */
struct T2 {
  @align(2) @size(16) f0: vec2f,
}
/* target size: 16 max align: 16 */
struct T3 {
  @align(1) @size(16) f0: array<atomic<i32>, 1>,
}
@id(31091) override override87 : u32;
override override88 : f16;
@group(0) @binding(20) var st5: texture_storage_3d<rg32uint, read>;
@group(0) @binding(74) var sam16: sampler_comparison;
@group(0) @binding(106) var<storage, read_write> buffer268: array<T0, 1>;
struct VertexOutput20 {
  @builtin(position) f64: vec4f,
  @location(6) @interpolate(perspective, centroid) f65: f16
}

@vertex
fn vertex0(@location(7) @interpolate(flat) a0: vec4u, @location(12) a1: vec4i, @location(15) @interpolate(flat, center) a2: i32, @location(1) a3: vec2i, @location(10) @interpolate(linear, centroid) a4: vec2h, @location(8) a5: vec4f) -> VertexOutput20 {
  var out: VertexOutput20;
  _ = a4;
  _ = a3;
  return out;
}
struct VertexOutput21 {
  @builtin(position) f66: vec4f
}

@vertex
fn vertex1() -> VertexOutput21 {
  var out: VertexOutput21;
  return out;
}
struct FragmentOutput20 {
  @location(4) f0: u32,
  @location(0) @interpolate(perspective) f1: vec4f
}

@fragment
fn fragment0() -> FragmentOutput20 {
  var out: FragmentOutput20;
  _ = buffer268[0];
  _ = buffer268[0].f0;
  out.f1 *= vec4f(0.1561, 0.02575, 0.4207, 0.06031);
  return out;
}

@compute @workgroup_size(1, 1, 3)
fn compute0() {
  _ = override88;
  if bool(override87) {
    return;
  }
}

@compute @workgroup_size(1, 1, 1)
fn compute1() {
}`,
  sourceMap: {},
  hints: {},
});
try {
computePassEncoder131.setBindGroup(2, bindGroup137);
} catch {}
try {
computePassEncoder160.setBindGroup(3, bindGroup84, new Uint32Array(5306), 72, 0);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder40.setBindGroup(2, bindGroup149, new Uint32Array(185), 57, 0);
} catch {}
let bindGroup212 = device0.createBindGroup({layout: bindGroupLayout37, entries: [{binding: 63, resource: textureView40}]});
try {
computePassEncoder25.setBindGroup(1, bindGroup108, new Uint32Array(1531), 699, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle7, renderBundle0, renderBundle7, renderBundle21, renderBundle17]);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer213, 'uint32', 424, 1_197);
} catch {}
let pipeline19 = device0.createComputePipeline({layout: pipelineLayout20, compute: {module: shaderModule18, constants: {override81: 1}}});
let buffer269 = device0.createBuffer({size: 11853, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
try {
renderPassEncoder48.setIndexBuffer(buffer78, 'uint16', 3_094, 2_976);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let bindGroup213 = device0.createBindGroup({
  layout: bindGroupLayout34,
  entries: [
    {binding: 643, resource: textureView14},
    {binding: 170, resource: textureView32},
    {binding: 101, resource: {buffer: buffer153, offset: 1024, size: 289}},
    {binding: 167, resource: sampler7},
  ],
});
try {
computePassEncoder9.setBindGroup(2, bindGroup164);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder130); computePassEncoder130.dispatchWorkgroups(1, 1); };
} catch {}
let bindGroup214 = device0.createBindGroup({
  label: '\u22af\u1dc4\u7561\u0d94\u74f6\u4995\u0d98\ufa3e\u0898',
  layout: bindGroupLayout5,
  entries: [{binding: 18, resource: textureView69}],
});
let texture371 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 15},
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderPassEncoder14.setVertexBuffer(3, buffer157, 0, 1_216);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture199,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(346).fill(119), /* required buffer size: 346 */
{offset: 346, rowsPerImage: 11}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise56 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let buffer270 = device0.createBuffer({
  label: '\u30eb\ub697\u7ad3',
  size: 7778,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
renderPassEncoder24.setIndexBuffer(buffer142, 'uint32', 72, 129);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
buffer46.unmap();
} catch {}
try {
externalTexture3.label = '\ud03c\u5ea7';
} catch {}
let bindGroup215 = device0.createBindGroup({
  layout: bindGroupLayout33,
  entries: [{binding: 566, resource: textureView8}, {binding: 834, resource: textureView74}],
});
let buffer271 = device0.createBuffer({
  size: 1746,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let querySet44 = device0.createQuerySet({label: '\uf736\ue87b\u9598\u0450\u27fa\u37ae', type: 'occlusion', count: 848});
let texture372 = device0.createTexture({size: [36], sampleCount: 1, dimension: '1d', format: 'rg16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder194.setBindGroup(1, bindGroup35, new Uint32Array(324), 10, 0);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer60, 'uint32', 1_860, 134);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(2, buffer103, 52);
} catch {}
try {
if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); };
} catch {}
let texture373 = device0.createTexture({
  size: [105],
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler234 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 11.66,
  maxAnisotropy: 3,
});
try {
renderPassEncoder46.setBindGroup(2, bindGroup26);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle3, renderBundle17, renderBundle21]);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(5, buffer69, 0, 1_298);
} catch {}
let arrayBuffer48 = buffer225.getMappedRange(1840);
let canvas14 = document.createElement('canvas');
let bindGroup216 = device0.createBindGroup({
  layout: bindGroupLayout42,
  entries: [
    {binding: 21, resource: sampler82},
    {binding: 12, resource: {buffer: buffer139, offset: 3584, size: 1184}},
  ],
});
try {
renderPassEncoder47.setBindGroup(2, bindGroup90, new Uint32Array(1634), 544, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(6, buffer116, 148, 271);
} catch {}
try {
device0.queue.writeBuffer(buffer142, 20, new BigUint64Array(8847), 239, 48);
} catch {}
document.body.append(video2);
let bindGroup217 = device0.createBindGroup({
  layout: bindGroupLayout12,
  entries: [
    {binding: 20, resource: textureView315},
    {binding: 106, resource: {buffer: buffer59, offset: 0, size: 348}},
    {binding: 74, resource: sampler220},
  ],
});
let sampler235 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 49.50,
  lodMaxClamp: 96.64,
  compare: 'equal',
});
try {
computePassEncoder26.setBindGroup(3, bindGroup46, new Uint32Array(766), 269, 0);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle38]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
window.someLabel = sampler86.label;
} catch {}
let textureView358 = texture332.createView({});
try {
renderPassEncoder27.setVertexBuffer(4, buffer47);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 78, height: 132, depthOrArrayLayers: 1}
*/
{
  source: imageData39,
  origin: { x: 6, y: 0 },
  flipY: true,
}, {
  texture: texture254,
  mipLevel: 0,
  origin: {x: 10, y: 25, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame67 = new VideoFrame(img1, {timestamp: 0});
let buffer272 = device0.createBuffer({size: 15170, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let texture374 = device0.createTexture({
  label: '\u0d87\u2550',
  size: {width: 36},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let textureView359 = texture171.createView({label: '\ue0e3\u01ff\u024e\ub2f2'});
let sampler236 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 90.75,
  lodMaxClamp: 97.33,
  maxAnisotropy: 20,
});
try {
computePassEncoder221.setBindGroup(1, bindGroup175);
} catch {}
try {
computePassEncoder96.setBindGroup(2, bindGroup160, new Uint32Array(515), 116, 0);
} catch {}
try {
renderPassEncoder41.setIndexBuffer(buffer60, 'uint16', 3_532, 3_067);
} catch {}
try {
renderPassEncoder47.setVertexBuffer(0, buffer44, 3_212);
} catch {}
try {
renderPassEncoder15.insertDebugMarker('\u0e41');
} catch {}
let pipeline20 = device0.createComputePipeline({layout: pipelineLayout25, compute: {module: shaderModule22, entryPoint: 'compute0', constants: {}}});
let imageData43 = new ImageData(28, 16);
let bindGroupLayout47 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 210,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer273 = device0.createBuffer({
  size: 18260,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture375 = gpuCanvasContext3.getCurrentTexture();
try {
renderPassEncoder24.setIndexBuffer(buffer159, 'uint16', 448, 18);
} catch {}
let gpuCanvasContext22 = canvas14.getContext('webgpu');
try {
if (!arrayBuffer21.detached) { new Uint8Array(arrayBuffer21).fill(0x55); };
} catch {}
let videoFrame68 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'log'} });
let buffer274 = device0.createBuffer({
  label: '\ubcff\uf6c9\u1e19\u0c9f\u6230',
  size: 1778,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
try {
computePassEncoder161.setBindGroup(1, bindGroup120, [0]);
} catch {}
try {
computePassEncoder217.setBindGroup(3, bindGroup65, new Uint32Array(3536), 21, 0);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup28, new Uint32Array(689), 57, 0);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(6, buffer261, 176, 1_090);
} catch {}
await gc();
let bindGroup218 = device0.createBindGroup({layout: bindGroupLayout28, entries: [{binding: 55, resource: textureView152}]});
let textureView360 = texture274.createView({label: '\ufa83\u{1f9cb}\u5967\u015d\u{1f9e3}\u92cc\u{1fb4e}'});
try {
computePassEncoder76.setBindGroup(0, bindGroup141);
} catch {}
try {
computePassEncoder12.setBindGroup(3, bindGroup32, new Uint32Array(1037), 108, 0);
} catch {}
try {
renderPassEncoder29.beginOcclusionQuery(5);
} catch {}
try {
renderPassEncoder45.setIndexBuffer(buffer60, 'uint32', 800, 1_220);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let buffer275 = device0.createBuffer({
  label: '\u7673\ub4a4\u0efe\u0d31\u{1f668}',
  size: 5060,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: true,
});
try {
computePassEncoder121.setBindGroup(2, bindGroup191);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(2, 1); };
} catch {}
try {
renderPassEncoder19.end();
} catch {}
try {
renderPassEncoder30.beginOcclusionQuery(232);
} catch {}
let bindGroup219 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [{binding: 265, resource: {buffer: buffer185, offset: 4608, size: 504}}],
});
try {
computePassEncoder30.setBindGroup(3, bindGroup175);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer7, 188); };
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer209, 'uint16', 16, 53);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas7,
  origin: { x: 43, y: 17 },
  flipY: false,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder208.setBindGroup(0, bindGroup19, new Uint32Array(2749), 365, 0);
} catch {}
try {
renderPassEncoder34.beginOcclusionQuery(8);
} catch {}
try {
renderPassEncoder30.endOcclusionQuery();
} catch {}
try {
renderPassEncoder27.setVertexBuffer(5, buffer218);
} catch {}
try {
  await buffer23.mapAsync(GPUMapMode.READ, 14744, 56);
} catch {}
let pipeline21 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout25,
  multisample: {mask: 0x29040786},
  fragment: {module: shaderModule22, targets: [{format: 'rg16float'}]},
  vertex: {module: shaderModule22, constants: {}, buffers: []},
});
let texture376 = device0.createTexture({
  size: {width: 210},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba32sint'],
});
let textureView361 = texture325.createView({});
try {
computePassEncoder168.setBindGroup(1, bindGroup207);
} catch {}
try {
computePassEncoder64.dispatchWorkgroupsIndirect(buffer128, 660);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(2, buffer118, 1_080, 551);
} catch {}
try {
computePassEncoder141.insertDebugMarker('\u061d');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap6,
  origin: { x: 15, y: 4 },
  flipY: false,
}, {
  texture: texture92,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let querySet45 = device0.createQuerySet({label: '\ufc4d\u5c08\ue1a6', type: 'occlusion', count: 510});
try {
renderPassEncoder41.setBindGroup(3, bindGroup179);
} catch {}
try {
renderPassEncoder48.setBindGroup(1, bindGroup0, new Uint32Array(2878), 2_449, 0);
} catch {}
try {
renderPassEncoder29.endOcclusionQuery();
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let shaderModule26 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  f0: mat2x2f,
}
override override89 : f16;
@id(59414) override override90 : i32;
@group(0) @binding(74) var sam17: sampler_comparison;
@group(0) @binding(106) var<storage, read_write> buffer276: mat2x4h;
@group(0) @binding(20) var st6: texture_storage_1d<rgba16sint, read>;
struct FragmentOutput21 {
  @location(5) f0: vec2f,
  @location(0) @interpolate(flat) f1: vec4i,
  @location(1) f2: vec3f,
  @location(2) f3: vec4i
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32) -> FragmentOutput21 {
  var out: FragmentOutput21;
  if bool(textureLoad(st6, 0)[2]) {
    discard;
  }
  out.f0 += bitcast<vec2f>(textureLoad(st6, 0).gr);
  return out;
}
struct FragmentOutput22 {
  @location(1) @interpolate(flat, centroid) f0: vec2i,
  @location(2) @interpolate(flat, centroid) f1: vec2f,
  @builtin(sample_mask) f2: u32,
  @location(0) @interpolate(flat) f3: f32
}

@fragment
fn fragment1(@builtin(position) a0: vec4f) -> FragmentOutput22 {
  var out: FragmentOutput22;
  out.f0 = textureLoad(st6, 0).ba;
  if bool(a0[1]) {
    out.f3 /= f32(-0.8585);
  }
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
}`,
});
let buffer277 = device0.createBuffer({
  size: 32026,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView362 = texture159.createView({baseArrayLayer: 0, arrayLayerCount: 1});
try {
computePassEncoder93.setBindGroup(1, bindGroup82, new Uint32Array(1596), 109, 0);
} catch {}
try {
renderPassEncoder46.setBindGroup(0, bindGroup60, new Uint32Array(56), 22, 0);
} catch {}
try {
renderPassEncoder34.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.setViewport(178.92235851169602, 0.4149635913233328, 29.18876349953623, 0.1901575609956288, 0.46090718064439695, 0.8599952544372074);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer162, 'uint16', 496, 76);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer2);
} catch {}
try {
window.someLabel = bindGroup158.label;
} catch {}
try {
computePassEncoder122.setBindGroup(1, bindGroup23);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder139.insertDebugMarker('\u{1f899}');
} catch {}
let buffer278 = device0.createBuffer({size: 10228, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let sampler237 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 94.41,
  lodMaxClamp: 99.41,
  maxAnisotropy: 4,
});
try {
computePassEncoder126.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder34.setBindGroup(3, bindGroup63, new Uint32Array(158), 0, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer37, 'uint32', 1_796, 270);
} catch {}
try {
gpuCanvasContext22.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let promise57 = device0.queue.onSubmittedWorkDone();
try {
gpuCanvasContext18.unconfigure();
} catch {}
try {
  await promise55;
} catch {}
try {
computePassEncoder130.dispatchWorkgroups(2);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle42]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 16}
*/
{
  source: img4,
  origin: { x: 1, y: 5 },
  flipY: false,
}, {
  texture: texture31,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder125.setBindGroup(3, bindGroup118, new Uint32Array(303), 20, 0);
} catch {}
let bindGroup220 = device0.createBindGroup({
  layout: bindGroupLayout15,
  entries: [{binding: 133, resource: textureView33}, {binding: 80, resource: textureView149}],
});
let buffer279 = device0.createBuffer({
  size: 10472,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let buffer280 = device0.createBuffer({
  size: 440,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
try {
computePassEncoder32.setBindGroup(1, bindGroup183);
} catch {}
try {
renderPassEncoder45.beginOcclusionQuery(18);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer147, 'uint32', 1_080, 2_809);
} catch {}
try {
buffer182.unmap();
} catch {}
await gc();
try {
computePassEncoder37.setBindGroup(0, bindGroup144);
} catch {}
try {
computePassEncoder190.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder45.setBindGroup(0, bindGroup202, []);
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup54, new Uint32Array(2130), 1_098, 0);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle21]);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(7, buffer258);
} catch {}
let texture377 = device0.createTexture({size: [39], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_DST});
let textureView363 = texture185.createView({label: '\u63f5\u4f37\u0902\ufb22\u0325\u06ac', dimension: '2d', arrayLayerCount: 1});
try {
renderPassEncoder24.setBindGroup(2, bindGroup53, new Uint32Array(957), 104, 0);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle6, renderBundle23, renderBundle20]);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer141, 'uint16', 302, 3_113);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(0, buffer138, 0, 269);
} catch {}
let sampler238 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.53,
});
let sampler239 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 4.966,
  lodMaxClamp: 51.61,
  maxAnisotropy: 18,
});
try {
renderPassEncoder14.setBindGroup(1, bindGroup162, new Uint32Array(1172), 130, 0);
} catch {}
let arrayBuffer49 = buffer263.getMappedRange(256);
let bindGroup221 = device0.createBindGroup({
  layout: bindGroupLayout20,
  entries: [
    {binding: 61, resource: textureView291},
    {binding: 188, resource: {buffer: buffer279, offset: 768, size: 1356}},
  ],
});
let texture378 = device0.createTexture({
  size: [420, 1, 19],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView364 = texture326.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder188.setBindGroup(0, bindGroup55);
} catch {}
try {
computePassEncoder122.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder22.end();
} catch {}
try {
renderPassEncoder45.executeBundles([renderBundle6]);
} catch {}
await gc();
try {
computePassEncoder74.setBindGroup(2, bindGroup30);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let buffer281 = device0.createBuffer({
  label: '\u0f2b\u{1f7f9}\u08cc\u0df0\u69b3\ua7f6\u0ccd\u0218\uc1bc',
  size: 9361,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: false,
});
let textureView365 = texture120.createView({});
try {
computePassEncoder40.setBindGroup(1, bindGroup24, new Uint32Array(2049), 39, 0);
} catch {}
try {
renderPassEncoder45.endOcclusionQuery();
} catch {}
let textureView366 = texture227.createView({});
let sampler240 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 92.34,
  compare: 'less',
  maxAnisotropy: 11,
});
try {
computePassEncoder126.setBindGroup(3, bindGroup132);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup9);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(9);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer100, 'uint32', 1_304, 82);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
if (!arrayBuffer48.detached) { new Uint8Array(arrayBuffer48).fill(0x55); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroupsIndirect(buffer165, 4); };
} catch {}
try {
renderPassEncoder34.setBindGroup(2, bindGroup202, new Uint32Array(57), 7, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer215, 20920, new DataView(new ArrayBuffer(21259)), 230, 3228);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData30,
  origin: { x: 3, y: 4 },
  flipY: false,
}, {
  texture: texture320,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
let texture379 = device0.createTexture({
  size: [39, 66, 1],
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView367 = texture160.createView({dimension: 'cube', format: 'r8unorm'});
let sampler241 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 60.00,
  lodMaxClamp: 75.89,
  maxAnisotropy: 11,
});
try {
computePassEncoder37.dispatchWorkgroups(1, 1, 1);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 15}
*/
{
  source: imageData16,
  origin: { x: 9, y: 1 },
  flipY: true,
}, {
  texture: texture258,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
let bindGroup222 = device0.createBindGroup({layout: bindGroupLayout35, entries: [{binding: 138, resource: sampler69}]});
let sampler242 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 0.6835,
  lodMaxClamp: 21.88,
});
try {
renderPassEncoder27.setBindGroup(2, bindGroup72, new Uint32Array(822), 0, 0);
} catch {}
try {
renderPassEncoder45.end();
} catch {}
try {
renderPassEncoder39.setBlendConstant({ r: 267.6, g: 660.2, b: -815.6, a: 341.0, });
} catch {}
let bindGroup223 = device0.createBindGroup({
  layout: bindGroupLayout23,
  entries: [{binding: 41, resource: textureView194}, {binding: 228, resource: textureView340}],
});
let buffer282 = device0.createBuffer({
  size: 8206,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler243 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 86.04,
  lodMaxClamp: 96.43,
});
try {
computePassEncoder40.setBindGroup(3, bindGroup96, new Uint32Array(56), 5, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(2, 1, 3); };
} catch {}
try {
computePassEncoder37.dispatchWorkgroupsIndirect(buffer236, 68);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rg32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['stencil8'],
  colorSpace: 'srgb',
});
} catch {}
let sampler244 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 83.13,
  lodMaxClamp: 91.20,
  maxAnisotropy: 15,
});
let textureView368 = texture43.createView({dimension: '2d-array'});
try {
computePassEncoder196.setBindGroup(3, bindGroup8, new Uint32Array(1208), 184, 0);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer258);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let texture380 = device0.createTexture({
  size: [36, 12, 80],
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler245 = device0.createSampler({
  label: '\u0605\u{1fc84}\u06d8\u0e80\u022c\u{1faf9}\u06a5\u9d4f\u{1f79e}\u605e\u0fdf',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 89.24,
  compare: 'never',
  maxAnisotropy: 3,
});
try {
computePassEncoder21.setBindGroup(0, bindGroup105);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup62);
} catch {}
try {
renderPassEncoder37.setBindGroup(1, bindGroup164, new Uint32Array(937), 31, 0);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer12, 'uint32', 1_732, 13_109);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(5, buffer115, 0, 2_354);
} catch {}
try {
device0.queue.writeBuffer(buffer143, 2740, new Float32Array(1049), 253, 288);
} catch {}
try {
  await promise54;
} catch {}
let imageData44 = new ImageData(56, 120);
let externalTexture56 = device0.importExternalTexture({label: '\u{1ff12}\u59f5\ud11e\u10f5\u0508\u0784', source: videoFrame41});
try {
renderPassEncoder34.setIndexBuffer(buffer260, 'uint16', 5_826, 4_386);
} catch {}
try {
gpuCanvasContext15.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
computePassEncoder224.setBindGroup(3, bindGroup63);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer189, 'uint16', 20, 3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 3, y: 0 },
  flipY: false,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); };
} catch {}
let imageData45 = new ImageData(84, 80);
let bindGroup224 = device0.createBindGroup({layout: bindGroupLayout27, entries: [{binding: 313, resource: textureView296}]});
let texture381 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 174},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture57 = device0.importExternalTexture({source: video4});
try {
renderPassEncoder24.setBindGroup(1, bindGroup171, new Uint32Array(7104), 3_922, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas7,
  origin: { x: 19, y: 6 },
  flipY: false,
}, {
  texture: texture225,
  mipLevel: 0,
  origin: {x: 16, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let sampler246 = device0.createSampler({
  label: '\u8f18\u0d92\u00ad\u66bf\ue614\u{1fd04}\u5777\u{1fa1a}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 72.75,
  lodMaxClamp: 88.26,
  compare: 'never',
});
try {
computePassEncoder142.setBindGroup(0, bindGroup19, new Uint32Array(2008), 122, 0);
} catch {}
try {
renderPassEncoder41.setBindGroup(0, bindGroup179);
} catch {}
try {
renderPassEncoder14.end();
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer231, 'uint16', 162, 281);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.append(video0);
let video5 = await videoWithData(82);
let bindGroupLayout48 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 80,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 130,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 79,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let bindGroup225 = device0.createBindGroup({layout: bindGroupLayout46, entries: [{binding: 95, resource: textureView57}]});
try {
renderPassEncoder21.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle5, renderBundle7, renderBundle6, renderBundle5]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder130); computePassEncoder130.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder27.setBindGroup(0, bindGroup142, new Uint32Array(761), 32, 0);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(3, buffer149);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap8,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 30, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture382 = device0.createTexture({
  size: [19, 33, 1],
  mipLevelCount: 2,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder16.setBindGroup(3, bindGroup172);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer249, 'uint16', 202, 530);
} catch {}
try {
gpuCanvasContext13.unconfigure();
} catch {}
try {
  await promise56;
} catch {}
let bindGroup226 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView7}]});
let sampler247 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 76.04,
  lodMaxClamp: 81.20,
  maxAnisotropy: 4,
});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer162, 3_920); };
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer7, 'uint16', 818, 862);
} catch {}
let imageData46 = new ImageData(4, 24);
let shaderModule27 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 26 max align: 2 */
struct T0 {
  @align(2) @size(16) f0: array<vec2u, 1>,
  @align(2) @size(10) f1: array<atomic<u32>>,
}
override override94 : f32;
@id(35343) override override92 : i32;
@id(6489) override override93 : f32;
@id(44458) override override91 : bool = false;
override override96 : f16;
override override95 : f16 = -53684.0;
@id(52143) override override97 : u32 = 438;
@group(0) @binding(191) var tex24: texture_depth_2d;
@group(0) @binding(100) var tex25: texture_3d<i32>;
struct VertexOutput22 {
  @location(9) f67: vec2h,
  @builtin(position) f68: vec4f,
  @location(14) f69: f16
}

@vertex
fn vertex0() -> VertexOutput22 {
  var out: VertexOutput22;
  _ = override94;
  return out;
}
struct S10 {
  @location(1) @interpolate(flat, sample) f0: i32
}

@fragment
fn fragment0(a0: S10) -> @location(200) vec4f {
  var out: vec4f;
  _ = override95;
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
}`,
  sourceMap: {},
  hints: {},
});
let pipelineLayout28 = device0.createPipelineLayout({label: '\u0d0a\u38c1\u40bb', bindGroupLayouts: []});
let texture383 = device0.createTexture({size: [78], dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.STORAGE_BINDING});
let textureView369 = texture322.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
let sampler248 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 99.89});
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer11, 168); };
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let renderBundleEncoder47 = device0.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true, stencilReadOnly: true});
let sampler249 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 25.35,
  lodMaxClamp: 70.30,
  maxAnisotropy: 10,
});
try {
computePassEncoder57.setBindGroup(2, bindGroup105, new Uint32Array(626), 43, 0);
} catch {}
try {
computePassEncoder188.dispatchWorkgroups(3);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer71, 'uint16', 590, 187);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer166, 604);
} catch {}
try {
renderBundleEncoder47.setIndexBuffer(buffer218, 'uint16', 190, 994);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(5, buffer280);
} catch {}
let promise58 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer37.detached) { new Uint8Array(arrayBuffer37).fill(0x55); };
} catch {}
let sampler250 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 97.78,
  lodMaxClamp: 98.44,
});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer234, 'uint16', 1_114, 417);
} catch {}
try {
renderBundleEncoder47.setBindGroup(2, bindGroup202);
} catch {}
try {
renderBundleEncoder47.setIndexBuffer(buffer1, 'uint32', 5_004, 669);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup227 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 15, resource: {buffer: buffer273, offset: 4608}}]});
let textureView370 = texture258.createView({aspect: 'all', format: 'bgra8unorm-srgb', baseArrayLayer: 3, arrayLayerCount: 2});
canvas1.height = 316;
let renderBundle47 = renderBundleEncoder47.finish();
try {
renderPassEncoder46.setBindGroup(0, bindGroup211);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer82, 'uint16', 1_578, 132);
} catch {}
let imageData47 = new ImageData(24, 116);
let bindGroup228 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 110, resource: sampler236},
    {binding: 328, resource: {buffer: buffer282, offset: 768, size: 23}},
    {binding: 145, resource: sampler107},
  ],
});
let buffer283 = device0.createBuffer({
  label: '\u0737\ueec4',
  size: 2029,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture384 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 379},
  mipLevelCount: 6,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView371 = texture148.createView({baseMipLevel: 1, mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle38, renderBundle3]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture152,
  mipLevel: 0,
  origin: {x: 10, y: 3, z: 3},
  aspect: 'all',
}, new Uint8Array(3_829).fill(207), /* required buffer size: 3_829 */
{offset: 113, bytesPerRow: 138, rowsPerImage: 15}, {width: 8, height: 12, depthOrArrayLayers: 2});
} catch {}
let promise59 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let texture385 = device0.createTexture({
  size: [840, 1, 1],
  mipLevelCount: 3,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture386 = gpuCanvasContext7.getCurrentTexture();
try {
computePassEncoder30.setBindGroup(2, bindGroup223);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer109, 'uint32', 12_472, 70);
} catch {}
try {
device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); });
} catch {}
try {
window.someLabel = textureView183.label;
} catch {}
let buffer284 = device0.createBuffer({
  size: 3896,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: true,
});
let texture387 = device0.createTexture({
  size: {width: 650, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'astc-10x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder138.setBindGroup(1, bindGroup172, new Uint32Array(1991), 187, 0);
} catch {}
let sampler251 = device0.createSampler({
  label: '\u4157\u9503\u0c6e\u{1fa57}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 31.37,
  lodMaxClamp: 51.11,
});
try {
computePassEncoder62.setBindGroup(0, bindGroup16, new Uint32Array(4252), 208, 0);
} catch {}
try {
renderPassEncoder47.setBindGroup(3, bindGroup34, new Uint32Array(10000), 4_089, 0);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer100, 'uint32', 116, 41);
} catch {}
let imageData48 = new ImageData(60, 124);
try {
commandEncoder234.label = '\u{1f637}\u0d95';
} catch {}
let bindGroup229 = device0.createBindGroup({layout: bindGroupLayout41, entries: [{binding: 87, resource: textureView331}]});
let sampler252 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 72.27,
  lodMaxClamp: 94.12,
  compare: 'less',
});
try {
computePassEncoder90.setBindGroup(3, bindGroup99, new Uint32Array(3557), 152, 0);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup216);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle17]);
} catch {}
let textureView372 = texture37.createView({aspect: 'all'});
let sampler253 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 36.06,
  lodMaxClamp: 66.90,
  maxAnisotropy: 1,
});
try {
computePassEncoder19.setBindGroup(2, bindGroup168, new Uint32Array(3001), 187, 0);
} catch {}
let bindGroup230 = device0.createBindGroup({
  layout: bindGroupLayout14,
  entries: [
    {binding: 69, resource: textureView273},
    {binding: 4, resource: textureView162},
    {binding: 505, resource: {buffer: buffer151, offset: 0, size: 145}},
    {binding: 23, resource: textureView57},
  ],
});
let texture388 = gpuCanvasContext6.getCurrentTexture();
let sampler254 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 74.43,
  lodMaxClamp: 87.12,
});
try {
computePassEncoder153.setBindGroup(1, bindGroup177);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(5, buffer48, 8, 8);
} catch {}
try {
gpuCanvasContext11.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
let video6 = await videoWithData(47);
let videoFrame69 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt709', transfer: 'hlg'} });
let buffer285 = device0.createBuffer({
  size: 13480,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView373 = texture229.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 9, arrayLayerCount: 7});
try {
computePassEncoder19.setBindGroup(3, bindGroup75, new Uint32Array(611), 46, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer210, 24); };
} catch {}
try {
computePassEncoder114.setPipeline(pipeline17);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture175,
  mipLevel: 1,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(24).fill(186), /* required buffer size: 24 */
{offset: 24, bytesPerRow: 7}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); };
} catch {}
try {
computePassEncoder187.setBindGroup(3, bindGroup47);
} catch {}
try {
computePassEncoder169.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer12, 'uint32', 2_444, 93);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let buffer286 = device0.createBuffer({
  label: '\uccde\u1d66',
  size: 15136,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView374 = texture50.createView({});
let sampler255 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 81.94,
  lodMaxClamp: 84.60,
});
try {
renderPassEncoder21.setVertexBuffer(5, buffer150, 324, 711);
} catch {}
try {
adapter1.label = '\u{1f78a}\uf29c\u{1f624}\u680c\u491b\ucbbe\u0de9\uc057';
} catch {}
let bindGroup231 = device0.createBindGroup({layout: bindGroupLayout35, entries: [{binding: 138, resource: sampler200}]});
let buffer287 = device0.createBuffer({
  size: 17520,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
try {
computePassEncoder58.setBindGroup(2, bindGroup142);
} catch {}
try {
computePassEncoder219.setBindGroup(3, bindGroup184, new Uint32Array(4415), 556, 0);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer245, 'uint16', 128, 303);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(6, buffer184, 1_520, 1_941);
} catch {}
try {
  await promise58;
} catch {}
document.body.prepend(video2);
let sampler256 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 53.35,
  lodMaxClamp: 73.96,
  maxAnisotropy: 18,
});
try {
computePassEncoder10.setBindGroup(0, bindGroup196, new Uint32Array(1060), 317, 0);
} catch {}
try {
computePassEncoder112.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder38.setBindGroup(1, bindGroup231);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer39, 'uint16', 194, 243);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: videoFrame21,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer288 = device0.createBuffer({size: 23644, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture389 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 8,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder48 = device0.createRenderBundleEncoder({colorFormats: ['rg16float']});
let sampler257 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 43.96,
  lodMaxClamp: 49.27,
});
try {
renderPassEncoder37.setIndexBuffer(buffer11, 'uint32', 804, 1_862);
} catch {}
try {
renderBundleEncoder48.setBindGroup(3, bindGroup202);
} catch {}
try {
renderBundleEncoder48.setPipeline(pipeline21);
} catch {}
try {
renderBundleEncoder48.setVertexBuffer(0, buffer145);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let texture390 = device0.createTexture({
  size: [72, 24, 357],
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder64.setBindGroup(3, bindGroup151, []);
} catch {}
try {
renderPassEncoder40.setBindGroup(2, bindGroup81, new Uint32Array(1839), 80, 0);
} catch {}
try {
renderBundleEncoder48.setIndexBuffer(buffer28, 'uint32', 3_920, 623);
} catch {}
try {
renderBundleEncoder48.setVertexBuffer(5, buffer183, 10_644, 0);
} catch {}
try {
buffer250.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture249,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(26).fill(209), /* required buffer size: 26 */
{offset: 26, bytesPerRow: 70}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 150, depthOrArrayLayers: 1}
*/
{
  source: canvas14,
  origin: { x: 120, y: 37 },
  flipY: true,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 15, height: 11, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout49 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 192,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let renderBundle48 = renderBundleEncoder48.finish({});
try {
renderPassEncoder15.setScissorRect(8, 0, 6, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer47, 'uint32', 84, 2_052);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(7, buffer132, 1_900, 0);
} catch {}
let textureView375 = texture339.createView({mipLevelCount: 1});
let sampler258 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 70.25,
  maxAnisotropy: 1,
});
let externalTexture58 = device0.importExternalTexture({source: videoFrame48});
try {
computePassEncoder126.setBindGroup(2, bindGroup47, new Uint32Array(287), 111, 0);
} catch {}
try {
renderPassEncoder30.setBindGroup(1, bindGroup177);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup4, new Uint32Array(660), 131, 0);
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle42, renderBundle21, renderBundle6, renderBundle42, renderBundle21, renderBundle7]);
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer22, 'uint32', 268, 399);
} catch {}
try {
gpuCanvasContext18.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['stencil8'],
});
} catch {}
try {
adapter1.label = '\u349f\u0ecb\u409b\u{1ff6e}\u0ac9\udc78\u035c\u63e3\u881d\u4d5b';
} catch {}
let textureView376 = texture354.createView({arrayLayerCount: 1});
let renderBundleEncoder49 = device0.createRenderBundleEncoder({colorFormats: ['rg16float'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder180.end();
} catch {}
try {
renderPassEncoder41.setVertexBuffer(3, buffer74, 3_456, 882);
} catch {}
try {
renderBundleEncoder49.setBindGroup(0, bindGroup6, new Uint32Array(813), 290, 0);
} catch {}
try {
renderBundleEncoder49.setIndexBuffer(buffer176, 'uint16', 848, 246);
} catch {}
try {
commandEncoder227.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 112 */
  offset: 112,
  bytesPerRow: 256,
  buffer: buffer62,
}, {
  texture: texture322,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder227.copyTextureToTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 185, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture50,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
},
{width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer82, 92, new Float32Array(6258), 1720, 68);
} catch {}
let textureView377 = texture201.createView({label: '\uf8f7\u{1fd95}', dimension: '2d-array', baseArrayLayer: 5, arrayLayerCount: 3});
let computePassEncoder225 = commandEncoder227.beginComputePass({});
try {
computePassEncoder210.setBindGroup(1, bindGroup126, new Uint32Array(7420), 326, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder30.beginOcclusionQuery(11);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(7, buffer118, 504, 1_189);
} catch {}
try {
renderBundleEncoder49.setBindGroup(0, bindGroup127, new Uint32Array(832), 499, 0);
} catch {}
try {
renderBundleEncoder49.setVertexBuffer(1, buffer121);
} catch {}
let imageData49 = new ImageData(4, 68);
let buffer289 = device0.createBuffer({size: 3496, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: true});
try {
renderPassEncoder30.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder49.setIndexBuffer(buffer162, 'uint16', 4_260, 565);
} catch {}
try {
  await promise59;
} catch {}
let promise60 = adapter1.requestAdapterInfo();
let shaderModule28 = device0.createShaderModule({
  code: `
enable f16;
enable f16;
enable f16;
/* target size: 143 max align: 1 */
struct T0 {
  @align(1) f0: f32,
  @align(1) @size(16) f1: atomic<u32>,
  @align(1) @size(8) f2: atomic<u32>,
  @align(1) @size(16) f3: array<array<atomic<u32>, 1>, 1>,
  @align(1) @size(8) f4: atomic<i32>,
  @align(1) @size(43) f5: u32,
  @align(1) f6: array<vec3i, 1>,
  @align(1) @size(16) f7: atomic<i32>,
  @align(1) @size(16) f8: array<atomic<u32>>,
}
/* target size: 143 max align: 1 */
struct T1 {
  @align(1) @size(25) f0: mat3x3h,
  @align(1) @size(58) f1: array<array<array<atomic<u32>, 2>, 5>, 1>,
  @align(1) f2: atomic<u32>,
  @align(1) @size(39) f3: atomic<i32>,
  @align(1) @size(14) f4: atomic<i32>,
  @align(1) @size(3) f5: f16,
}
/* target size: 143 max align: 1 */
struct T2 {
  @align(1) f0: array<vec2h, 1>,
  @align(1) @size(41) f1: array<atomic<u32>, 1>,
  @align(1) @size(98) f2: array<atomic<i32>>,
}
/* target size: 143 max align: 1 */
struct T3 {
  @align(1) @size(109) f0: array<u32, 27>,
  @align(1) @size(34) f1: array<array<atomic<i32>, 1>>,
}
@id(17196) override override101 : f16 = -55808.2;
@id(2464) override override99 : f32;
@id(39364) override override104 : f32;
override override98 : f32;
@id(64452) override override103 : f16 = -48016.6;
@id(14789) override override102 : bool = true;
@id(45937) override override100 : f16;
@group(0) @binding(228) var<storage, read_write> buffer290: array<T1>;
@group(0) @binding(172) var sam18: sampler;
@group(1) @binding(18) var tex26: texture_2d<f32>;
struct VertexOutput23 {
  @builtin(position) f70: vec4f
}

@vertex
fn vertex0(@location(11) @interpolate(flat) a0: vec4i, @location(12) a1: vec2h, @location(3) a2: i32, @location(0) a3: vec4u, @location(4) a4: f32) -> VertexOutput23 {
  var out: VertexOutput23;
  return out;
}
struct FragmentOutput23 {
  @location(1) @interpolate(flat) f0: vec4i,
  @location(0) @interpolate(perspective, center) f1: vec4f
}

@fragment
fn fragment0(@builtin(front_facing) a0: bool) -> FragmentOutput23 {
  var out: FragmentOutput23;
  _ = atomicLoad(&buffer290[arrayLength(&buffer290)].f2);
  _ = textureSampleLevel(tex26, sam18, vec2f(), 0.0, vec2i());
  _ = override104;
  _ = buffer290[arrayLength(&buffer290)].f1;
  _ = buffer290[arrayLength(&buffer290)].f3;
  _ = buffer290[arrayLength(&buffer290)].f1[0];
  _ = buffer290[arrayLength(&buffer290)].f4;
  return out;
}
struct S11 {
  @builtin(sample_index) f0: u32,
  @builtin(front_facing) f1: bool
}
struct FragmentOutput24 {
  @location(2) f0: vec4i,
  @location(0) f1: vec4i,
  @location(1) f2: vec4f
}

@fragment
fn fragment1(@location(6) a0: f16, a1: S11) -> FragmentOutput24 {
  var out: FragmentOutput24;
  _ = buffer290[arrayLength(&buffer290)].f1[0][4];
  _ = buffer290[arrayLength(&buffer290)].f0;
  _ = buffer290;
  _ = textureLoad(tex26, vec2i(), 0);
  _ = buffer290[arrayLength(&buffer290)].f0;
  _ = buffer290[arrayLength(&buffer290)];
  _ = textureGather(2, tex26, sam18, vec2f());
  _ = textureSampleGrad(tex26, sam18, vec2f(), vec2f(), vec2f());
  _ = atomicExchange(&buffer290[arrayLength(&buffer290)].f1[0][4][1], 15);
  _ = arrayLength(&buffer290);
  _ = buffer290[arrayLength(&buffer290)].f1[0][4];
  _ = a0;
  return out;
}

@compute @workgroup_size(3, 1, 1)
fn compute0(@builtin(num_workgroups) a0: vec3u) {
  _ = override104;
}

@compute @workgroup_size(1, 1, 1)
fn compute1(@builtin(num_workgroups) a0: vec3u) {
}`,
  sourceMap: {},
  hints: {},
});
let texture391 = device0.createTexture({
  size: [210, 1, 1],
  mipLevelCount: 1,
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder94.setBindGroup(0, bindGroup39, new Uint32Array(152), 33, 0);
} catch {}
try {
computePassEncoder15.end();
} catch {}
try {
computePassEncoder225.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer109, 'uint32', 72, 15_758);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer170);
} catch {}
let texture392 = device0.createTexture({
  size: {width: 72, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  sampleCount: 4,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView378 = texture339.createView({label: '\u{1f68b}\u9065\u071a\u0b60', dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder226 = commandEncoder19.beginComputePass({});
let sampler259 = device0.createSampler({
  label: '\u3f59\ufe6e\u7d84\u0718\uf1f5\ufd0a\u09be\u0133\u2ef1\u4c51\ucfa3',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 93.62,
});
try {
computePassEncoder88.setPipeline(pipeline20);
} catch {}
try {
computePassEncoder226.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder27.setBindGroup(2, bindGroup156, new Uint32Array(1191), 180, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(3, buffer262, 0, 149);
} catch {}
try {
renderBundleEncoder49.setBindGroup(2, bindGroup164);
} catch {}
try {
renderBundleEncoder49.setBindGroup(3, bindGroup24, new Uint32Array(1295), 201, 0);
} catch {}
try {
buffer237.unmap();
} catch {}
let imageData50 = new ImageData(44, 80);
let textureView379 = texture312.createView({label: '\u{1f6eb}\ub7b2\u7e6a\ufd01\u4d71\uaa10\u0301\uaca7\u078a', aspect: 'all'});
try {
computePassEncoder159.setBindGroup(2, bindGroup120, [0]);
} catch {}
try {
renderPassEncoder34.executeBundles([renderBundle42, renderBundle6]);
} catch {}
try {
renderBundleEncoder49.setBindGroup(3, bindGroup94);
} catch {}
let arrayBuffer50 = buffer45.getMappedRange(40, 12);
try {
device0.queue.writeTexture({
  texture: texture272,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(23).fill(44), /* required buffer size: 23 */
{offset: 23}, {width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData51 = new ImageData(24, 56);
let renderBundle49 = renderBundleEncoder49.finish({});
try {
computePassEncoder189.setBindGroup(0, bindGroup28, new Uint32Array(937), 108, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroupsIndirect(buffer273, 1_524); };
} catch {}
try {
renderPassEncoder39.setVertexBuffer(5, buffer161, 16_392);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let sampler260 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 34.31,
  lodMaxClamp: 45.05,
  compare: 'less-equal',
});
try {
computePassEncoder141.setBindGroup(0, bindGroup196);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle10]);
} catch {}
let arrayBuffer51 = buffer263.getMappedRange(32, 72);
let buffer291 = device0.createBuffer({size: 2951, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView380 = texture261.createView({});
try {
renderPassEncoder27.setIndexBuffer(buffer5, 'uint16', 12, 138);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(7, buffer252, 0, 1_402);
} catch {}
try {
buffer95.unmap();
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'astc-6x5-unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['stencil8'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let videoFrame70 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'log'} });
let bindGroup232 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer71, offset: 1024, size: 616}}],
});
try {
computePassEncoder95.setBindGroup(3, bindGroup199);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup25, new Uint32Array(158), 9, 0);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer169, 'uint32', 176, 960);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(6, buffer210, 0);
} catch {}
try {
  await promise57;
} catch {}
let bindGroup233 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 65, resource: textureView7}]});
let buffer292 = device0.createBuffer({size: 2700, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true});
let renderBundleEncoder50 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true});
let renderBundle50 = renderBundleEncoder50.finish({label: '\uc8ca\u{1fcbc}\u05b6\u278e\ud4e6\u0d69\u2bd6\u056c\u{1f887}\ue9e0\u{1fb49}'});
let sampler261 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 78.32,
  maxAnisotropy: 12,
});
try {
computePassEncoder212.setBindGroup(1, bindGroup49);
} catch {}
try {
computePassEncoder122.setBindGroup(3, bindGroup95, new Uint32Array(2994), 204, 0);
} catch {}
try {
renderPassEncoder37.setBindGroup(0, bindGroup144);
} catch {}
let texture393 = device0.createTexture({size: [32, 32, 16], format: 'r8unorm', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder23.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(7, buffer149);
} catch {}
try {
computePassEncoder93.setBindGroup(0, bindGroup202);
} catch {}
try {
computePassEncoder86.setBindGroup(3, bindGroup113, new Uint32Array(10000), 1_099, 0);
} catch {}
try {
renderPassEncoder41.setVertexBuffer(0, buffer214, 72);
} catch {}
let promise61 = device0.queue.onSubmittedWorkDone();
let querySet46 = device0.createQuerySet({type: 'occlusion', count: 246});
let sampler262 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 95.04,
  lodMaxClamp: 95.05,
});
try {
computePassEncoder32.setBindGroup(3, bindGroup233, new Uint32Array(1456), 4, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroupsIndirect(buffer166, 960); };
} catch {}
let textureView381 = texture239.createView({baseMipLevel: 2, mipLevelCount: 1});
let sampler263 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 81.32,
  lodMaxClamp: 89.35,
  maxAnisotropy: 16,
});
try {
renderPassEncoder16.setIndexBuffer(buffer157, 'uint16', 114, 291);
} catch {}
let texture394 = device0.createTexture({
  size: [39, 66, 1],
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler264 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 30.45,
  lodMaxClamp: 34.82,
  maxAnisotropy: 19,
});
try {
computePassEncoder36.insertDebugMarker('\u7e01');
} catch {}
let imageData52 = new ImageData(68, 92);
let texture395 = device0.createTexture({
  size: {width: 19, height: 33, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler265 = device0.createSampler({
  label: '\u{1f97b}\u{1fa75}\uadb5\u042f\u751b\ud26a\uf2cf\u0096',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  minFilter: 'nearest',
  lodMinClamp: 47.15,
  lodMaxClamp: 51.50,
  maxAnisotropy: 1,
});
try {
renderPassEncoder34.setBindGroup(0, bindGroup229, new Uint32Array(1184), 437, 0);
} catch {}
try {
renderPassEncoder46.setVertexBuffer(5, buffer121);
} catch {}
let promise62 = device0.queue.onSubmittedWorkDone();
try {
  await promise52;
} catch {}
let externalTexture59 = device0.importExternalTexture({source: video5});
try {
renderPassEncoder27.setScissorRect(0, 0, 1, 2);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer109, 'uint32', 5_860, 2_184);
} catch {}
try {
renderPassEncoder41.setVertexBuffer(2, buffer156, 18_136);
} catch {}
try {
  await promise60;
} catch {}
let bindGroupLayout50 = device0.createBindGroupLayout({
  label: '\u{1f9cb}\u0860\u0e38\u{1f7be}\u{1f973}\uaa2b\u89f5\u07c6',
  entries: [
    {
      binding: 209,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
try {
computePassEncoder11.setBindGroup(2, bindGroup5, new Uint32Array(1029), 33, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroupsIndirect(buffer161, 572); };
} catch {}
try {
computePassEncoder202.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer246, 0, 10);
} catch {}
let videoFrame71 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte432', transfer: 'smpteSt4281'} });
let bindGroupLayout51 = device0.createBindGroupLayout({
  label: '\u4bdb\uac40\u5fb3\ub63a',
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
    {binding: 24, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
  ],
});
let texture396 = device0.createTexture({
  size: {width: 840},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder51 = device0.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder29.setIndexBuffer(buffer285, 'uint32', 4_088, 961);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(5, buffer157);
} catch {}
try {
renderBundleEncoder51.setPipeline(pipeline11);
} catch {}
try {
computePassEncoder176.pushDebugGroup('\u0683');
} catch {}
try {
renderBundleEncoder51.insertDebugMarker('\u5b3e');
} catch {}
try {
device0.queue.writeBuffer(buffer182, 10572, new Int16Array(4236), 546, 412);
} catch {}
let promise63 = device0.queue.onSubmittedWorkDone();
let img8 = await imageWithData(2, 15, '#10101010', '#20202020');
let imageData53 = new ImageData(32, 8);
let pipelineLayout29 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView382 = texture54.createView({});
try {
computePassEncoder130.setBindGroup(1, bindGroup114);
} catch {}
try {
computePassEncoder156.setBindGroup(0, bindGroup36, new Uint32Array(129), 9, 0);
} catch {}
try {
renderBundleEncoder51.setBindGroup(0, bindGroup181, new Uint32Array(1453), 272, 0);
} catch {}
try {
renderBundleEncoder51.setIndexBuffer(buffer161, 'uint16', 15_440, 7_402);
} catch {}
try {
device0.queue.writeBuffer(buffer281, 96, new BigUint64Array(3690), 129, 32);
} catch {}
video0.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let textureView383 = texture331.createView({});
try {
computePassEncoder161.setBindGroup(0, bindGroup142);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer70, 4); };
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup145, []);
} catch {}
try {
renderPassEncoder41.setBindGroup(1, bindGroup228, new Uint32Array(2578), 1_173, 0);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle38]);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer75, 'uint32', 728, 124);
} catch {}
try {
renderBundleEncoder51.setBindGroup(1, bindGroup84, new Uint32Array(2175), 139, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture344,
  mipLevel: 0,
  origin: {x: 29, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(133).fill(237), /* required buffer size: 133 */
{offset: 133, bytesPerRow: 59, rowsPerImage: 29}, {width: 7, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let buffer293 = device0.createBuffer({size: 6980, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture397 = device0.createTexture({
  label: '\u0222\u{1f6f9}\u3a5d',
  size: [19, 33, 1],
  mipLevelCount: 5,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder46.executeBundles([renderBundle50]);
} catch {}
try {
renderPassEncoder48.setVertexBuffer(3, buffer134, 2_012, 1_996);
} catch {}
try {
renderBundleEncoder51.setIndexBuffer(buffer208, 'uint16', 6_084, 5_735);
} catch {}
try {
renderBundleEncoder51.setVertexBuffer(7, buffer132, 0, 124);
} catch {}
try {
if (!arrayBuffer20.detached) { new Uint8Array(arrayBuffer20).fill(0x55); };
} catch {}
try {
  await promise62;
} catch {}
let imageData54 = new ImageData(24, 36);
let bindGroup234 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 9, resource: textureView27},
    {binding: 453, resource: textureView12},
    {binding: 102, resource: textureView361},
  ],
});
let textureView384 = texture262.createView({dimension: '3d', aspect: 'all', mipLevelCount: 1});
let renderBundle51 = renderBundleEncoder51.finish({});
let sampler266 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 10.92,
  lodMaxClamp: 63.87,
});
try {
renderPassEncoder21.setIndexBuffer(buffer154, 'uint16', 364, 207);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(video2);
let texture398 = device0.createTexture({
  label: '\ufd78\u7937\uc8d6\ufdb8\u7822\u29d6\u5ad3',
  size: {width: 32, height: 32, depthOrArrayLayers: 58},
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['r16float'],
});
try {
computePassEncoder208.setBindGroup(2, bindGroup185, new Uint32Array(763), 47, 0);
} catch {}
try {
renderPassEncoder48.setBindGroup(2, bindGroup51, new Uint32Array(457), 110, 0);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer211, 'uint32', 292, 2_535);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(5, buffer223, 268);
} catch {}
let querySet47 = device0.createQuerySet({type: 'occlusion', count: 2061});
try {
buffer129.unmap();
} catch {}
try {
computePassEncoder176.popDebugGroup();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame72 = new VideoFrame(videoFrame12, {timestamp: 0});
let buffer294 = device0.createBuffer({
  size: 247,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture399 = device0.createTexture({
  size: {width: 19},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let arrayBuffer52 = buffer104.getMappedRange(4872, 384);
try {
device0.queue.writeBuffer(buffer17, 936, new DataView(new ArrayBuffer(778)), 32, 84);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: videoFrame10,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture225,
  mipLevel: 0,
  origin: {x: 13, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline22 = device0.createRenderPipeline({
  layout: pipelineLayout22,
  fragment: {
  module: shaderModule24,
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rg32float', writeMask: GPUColorWrite.RED}, {format: 'rgba16sint', writeMask: 0}],
},
  vertex: {module: shaderModule24, constants: {override84: 1, 57_031: 1, override85: 1}, buffers: []},
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
let buffer295 = device0.createBuffer({
  size: 14435,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture400 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler267 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 49.18,
  lodMaxClamp: 66.32,
  compare: 'equal',
  maxAnisotropy: 16,
});
try {
renderPassEncoder15.setVertexBuffer(5, buffer256, 0, 1_891);
} catch {}
let arrayBuffer53 = buffer262.getMappedRange(1408, 8516);
try {
  await promise61;
} catch {}
document.body.prepend(img5);
try {
computePassEncoder25.setBindGroup(1, bindGroup32, new Uint32Array(0), 0, 0);
} catch {}
try {
renderPassEncoder29.setBindGroup(0, bindGroup138, new Uint32Array(1339), 243, 0);
} catch {}
try {
  await buffer127.mapAsync(GPUMapMode.READ, 0, 8);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: imageData41,
  origin: { x: 3, y: 3 },
  flipY: true,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
buffer181.label = '\u05f2\u6b69\ude4d\ud2e0\u70fd\u0942';
} catch {}
let buffer296 = device0.createBuffer({
  size: 12991,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder204.setBindGroup(0, bindGroup144);
} catch {}
try {
renderPassEncoder37.setBindGroup(1, bindGroup190, new Uint32Array(1936), 31, 0);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle38]);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(4, buffer78, 0, 1_000);
} catch {}
try {
buffer105.unmap();
} catch {}
let querySet48 = device0.createQuerySet({type: 'occlusion', count: 525});
let texture401 = device0.createTexture({
  label: '\ub261\uddb7\u284b\u{1fe43}\u{1fdd2}\u{1f728}',
  size: [9, 16, 350],
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder64.setBindGroup(3, bindGroup187);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle17, renderBundle50]);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer29, 'uint16', 8_998, 7_435);
} catch {}
try {
buffer129.unmap();
} catch {}
try {
computePassEncoder159.insertDebugMarker('\u02a1');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame18,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture11,
  mipLevel: 1,
  origin: {x: 22, y: 14, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline23 = await promise47;
let buffer297 = device0.createBuffer({
  label: '\u9d42\u9c5c\ue167\uda09\u03a5\u1b83\u04d8\u00a5\u0b29',
  size: 24392,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture402 = device0.createTexture({
  size: {width: 840, height: 1, depthOrArrayLayers: 37},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder31.setBindGroup(2, bindGroup148, new Uint32Array(1223), 155, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(3); };
} catch {}
try {
renderPassEncoder48.setBindGroup(3, bindGroup195);
} catch {}
try {
renderPassEncoder41.executeBundles([renderBundle21]);
} catch {}
let videoFrame73 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte170m', transfer: 'linear'} });
try {
renderPassEncoder30.setBindGroup(2, bindGroup104);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, buffer279, 0, 200);
} catch {}
let textureView385 = texture286.createView({format: 'rg32float', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer295, 892); };
} catch {}
try {
renderPassEncoder47.setBindGroup(3, bindGroup147);
} catch {}
let buffer298 = device0.createBuffer({
  label: '\u0f7c\u073d\u77f8\u126d\u1360\u1754\u9c8c',
  size: 552,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture403 = device0.createTexture({size: [39, 66, 1], format: 'rg16sint', usage: GPUTextureUsage.COPY_DST});
let textureView386 = texture136.createView({});
let sampler268 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 67.94,
  lodMaxClamp: 76.45,
});
try {
computePassEncoder77.setBindGroup(2, bindGroup232);
} catch {}
try {
computePassEncoder162.insertDebugMarker('\u6658');
} catch {}
let bindGroupLayout52 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 386,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let buffer299 = device0.createBuffer({size: 2818, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
computePassEncoder5.setBindGroup(0, bindGroup49, new Uint32Array(2986), 35, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder54.setPipeline(pipeline20);
} catch {}
try {
device0.queue.writeBuffer(buffer56, 80, new Float32Array(5908), 911, 0);
} catch {}
let videoFrame74 = new VideoFrame(imageBitmap9, {timestamp: 0});
let textureView387 = texture391.createView({
  label: '\u2f7e\u{1f77e}\u{1f992}\u755d\u0f49\u3bcb\u1c2a\u{1fd0e}\udbe8',
  dimension: '2d-array',
  arrayLayerCount: 1,
});
try {
computePassEncoder215.setBindGroup(1, bindGroup159, new Uint32Array(798), 6, 0);
} catch {}
let bindGroup235 = device0.createBindGroup({layout: bindGroupLayout11, entries: [{binding: 212, resource: textureView61}]});
let texture404 = device0.createTexture({
  size: {width: 78, height: 132, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView388 = texture254.createView({dimension: '2d-array'});
try {
computePassEncoder47.setBindGroup(2, bindGroup46, new Uint32Array(4337), 1_968, 0);
} catch {}
try {
computePassEncoder4.setPipeline(pipeline17);
} catch {}
let texture405 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  dimension: '2d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder178.end();
} catch {}
video3.width = 194;
let imageBitmap13 = await createImageBitmap(imageData54);
let bindGroup236 = device0.createBindGroup({
  label: '\u00ae\ucfbc\ub166\u0632\u0738\u7414\u0afe\ua979\u{1fbb6}',
  layout: bindGroupLayout20,
  entries: [
    {binding: 61, resource: textureView241},
    {binding: 188, resource: {buffer: buffer201, offset: 2048, size: 1084}},
  ],
});
let pipelineLayout30 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer300 = device0.createBuffer({size: 8021, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let sampler269 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.99,
  maxAnisotropy: 10,
});
try {
computePassEncoder26.setBindGroup(3, bindGroup44, new Uint32Array(2138), 599, 0);
} catch {}
try {
renderPassEncoder46.setBindGroup(3, bindGroup118, []);
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle5, renderBundle0]);
} catch {}
let computePassEncoder227 = commandEncoder225.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder188); computePassEncoder188.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder227.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder38.end();
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer231, 'uint16', 70, 134);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline24 = device0.createRenderPipeline({
  layout: pipelineLayout20,
  multisample: {mask: 0x8b913c0},
  fragment: {
  module: shaderModule23,
  targets: [{format: 'r16float', writeMask: 0}, {format: 'rg16sint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule20,
    constants: {},
    buffers: [
      {
        arrayStride: 284,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 40, shaderLocation: 15},
          {format: 'unorm8x2', offset: 32, shaderLocation: 2},
          {format: 'uint8x2', offset: 8, shaderLocation: 7},
          {format: 'sint16x4', offset: 44, shaderLocation: 4},
          {format: 'float32x2', offset: 136, shaderLocation: 5},
          {format: 'uint32x4', offset: 8, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw'},
});
try {
  await promise63;
} catch {}
let sampler270 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 23.55,
  lodMaxClamp: 93.11,
});
try {
computePassEncoder95.setBindGroup(2, bindGroup168);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder27.setScissorRect(0, 6, 0, 0);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer42, 'uint32', 1_620, 583);
} catch {}
let pipelineLayout31 = device0.createPipelineLayout({bindGroupLayouts: []});
let renderBundleEncoder52 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true});
try {
computePassEncoder42.setBindGroup(2, bindGroup3);
} catch {}
try {
computePassEncoder103.setBindGroup(1, bindGroup185, new Uint32Array(475), 60, 0);
} catch {}
try {
renderBundleEncoder52.setBindGroup(3, bindGroup166);
} catch {}
try {
renderBundleEncoder52.setVertexBuffer(4, buffer240, 0);
} catch {}
document.body.prepend(video2);
let querySet49 = device0.createQuerySet({type: 'occlusion', count: 116});
try {
computePassEncoder70.setBindGroup(2, bindGroup96);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroups(1, 2); };
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup204);
} catch {}
try {
renderBundleEncoder52.setBindGroup(1, bindGroup43, new Uint32Array(89), 14, 0);
} catch {}
try {
renderBundleEncoder52.setIndexBuffer(buffer280, 'uint16', 16, 84);
} catch {}
let imageData55 = new ImageData(20, 16);
let bindGroup237 = device0.createBindGroup({layout: bindGroupLayout39, entries: [{binding: 512, resource: textureView10}]});
let texture406 = device0.createTexture({
  label: '\u{1fca4}\u9def\u8cf8\u{1f837}\u8dcf\u2651\u0405\u061b\u{1f7ed}\u7a15',
  size: {width: 144},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView389 = texture360.createView({dimension: 'cube', aspect: 'all', baseArrayLayer: 1});
try {
{ clearResourceUsages(device0, computePassEncoder130); computePassEncoder130.dispatchWorkgroupsIndirect(buffer117, 4); };
} catch {}
try {
renderBundleEncoder52.setBindGroup(0, bindGroup17, new Uint32Array(8535), 1_499, 0);
} catch {}
try {
renderBundleEncoder52.setIndexBuffer(buffer294, 'uint32', 16, 53);
} catch {}
try {
renderBundleEncoder52.setVertexBuffer(4_294_967_294, undefined, 1_457_735_874);
} catch {}
document.body.prepend(img5);
let renderBundleEncoder53 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: false});
let sampler271 = device0.createSampler({
  label: '\ua5bb\u0d08',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 46.79,
  lodMaxClamp: 49.16,
});
try {
computePassEncoder72.setBindGroup(2, bindGroup119, new Uint32Array(4206), 203, 0);
} catch {}
try {
renderBundleEncoder52.setBindGroup(3, bindGroup45, new Uint32Array(3262), 122, 0);
} catch {}
try {
renderBundleEncoder53.setVertexBuffer(7, buffer241, 0, 380);
} catch {}
let bindGroup238 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 25, resource: {buffer: buffer78, offset: 5120, size: 2792}}],
});
let texture407 = device0.createTexture({
  size: [9, 16, 1],
  sampleCount: 4,
  dimension: '2d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder150.setBindGroup(0, bindGroup229);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer149, 468); };
} catch {}
try {
renderPassEncoder23.setVertexBuffer(3, buffer218, 1_972, 208);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
let sampler272 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 29.66,
  compare: 'less-equal',
});
try {
renderPassEncoder40.setBindGroup(3, bindGroup43, new Uint32Array(2317), 589, 0);
} catch {}
try {
renderPassEncoder29.end();
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer285, 'uint16', 1_248, 90);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let texture408 = device0.createTexture({
  label: '\u0eab\u{1fc95}\u95a2\ufbe9',
  size: [19, 33, 1],
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle52 = renderBundleEncoder53.finish();
let sampler273 = device0.createSampler({
  label: '\u0ec3\u5ab3\u6644\ud21d',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 45.08,
  lodMaxClamp: 93.56,
  compare: 'always',
});
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer93, 0); };
} catch {}
try {
renderPassEncoder41.end();
} catch {}
try {
computePassEncoder105.setBindGroup(3, bindGroup104, new Uint32Array(1612), 111, 0);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(38);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder37.setVertexBuffer(6, buffer223);
} catch {}
let querySet50 = device0.createQuerySet({type: 'occlusion', count: 64});
let renderBundle53 = renderBundleEncoder52.finish({});
let sampler274 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 77.14,
  maxAnisotropy: 15,
});
try {
renderPassEncoder24.setBindGroup(3, bindGroup114, []);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture190,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(238_510).fill(83), /* required buffer size: 238_510 */
{offset: 174, bytesPerRow: 266, rowsPerImage: 32}, {width: 31, height: 0, depthOrArrayLayers: 29});
} catch {}
let buffer301 = device0.createBuffer({
  size: 9761,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let renderBundleEncoder54 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], stencilReadOnly: true});
let sampler275 = device0.createSampler({
  label: '\u{1f9d3}\uf160\ufbc8\ue547',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 52.25,
  lodMaxClamp: 54.92,
});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer280, 68); };
} catch {}
try {
renderBundleEncoder54.setBindGroup(2, bindGroup165);
} catch {}
try {
renderBundleEncoder54.setBindGroup(3, bindGroup90, new Uint32Array(243), 1, 0);
} catch {}
try {
renderBundleEncoder54.setPipeline(pipeline15);
} catch {}
let buffer302 = device0.createBuffer({
  size: 3124,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let textureView390 = texture240.createView({dimension: '2d-array'});
let renderBundleEncoder55 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], stencilReadOnly: true});
try {
renderPassEncoder33.setBindGroup(2, bindGroup126);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
offscreenCanvas2.width = 526;
let bindGroup239 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [{binding: 289, resource: textureView71}, {binding: 116, resource: textureView69}],
});
let texture409 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 23},
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder23.setIndexBuffer(buffer141, 'uint32', 20, 453);
} catch {}
try {
renderBundleEncoder55.setVertexBuffer(0, buffer298);
} catch {}
let bindGroup240 = device0.createBindGroup({
  layout: bindGroupLayout51,
  entries: [
    {binding: 24, resource: {buffer: buffer169, offset: 1280, size: 1146}},
    {binding: 3, resource: textureView35},
  ],
});
try {
computePassEncoder170.setBindGroup(1, bindGroup5, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer37, 648); };
} catch {}
try {
renderPassEncoder46.end();
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle50]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture110,
  mipLevel: 0,
  origin: {x: 5, y: 2, z: 2},
  aspect: 'all',
}, new Uint8Array(10_892).fill(37), /* required buffer size: 10_892 */
{offset: 700, bytesPerRow: 128, rowsPerImage: 15}, {width: 10, height: 5, depthOrArrayLayers: 6});
} catch {}
let canvas15 = document.createElement('canvas');
let imageData56 = new ImageData(8, 16);
let bindGroup241 = device0.createBindGroup({
  layout: bindGroupLayout51,
  entries: [
    {binding: 24, resource: {buffer: buffer191, offset: 256, size: 7147}},
    {binding: 3, resource: textureView47},
  ],
});
let buffer303 = device0.createBuffer({
  label: '\u7da5\u9828\uc112',
  size: 7740,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: true,
});
let textureView391 = texture211.createView({label: '\u09cb\u181e\u3777\u041b\u{1fbcb}\u{1f6ec}\u229d\u068d\u635c', format: 'r16float'});
let renderBundle54 = renderBundleEncoder55.finish({});
try {
computePassEncoder149.setBindGroup(1, bindGroup225, new Uint32Array(741), 3, 0);
} catch {}
try {
renderPassEncoder27.setBindGroup(3, bindGroup46);
} catch {}
try {
renderPassEncoder39.setBlendConstant({ r: -692.6, g: 643.1, b: 584.1, a: -833.6, });
} catch {}
try {
renderBundleEncoder54.setPipeline(pipeline2);
} catch {}
let bindGroup242 = device0.createBindGroup({
  layout: bindGroupLayout18,
  entries: [
    {binding: 150, resource: textureView69},
    {binding: 55, resource: sampler145},
    {binding: 225, resource: sampler87},
    {binding: 15, resource: textureView186},
    {binding: 90, resource: {buffer: buffer106, offset: 1024, size: 10}},
    {binding: 308, resource: externalTexture13},
    {binding: 249, resource: sampler250},
    {binding: 142, resource: textureView172},
    {binding: 8, resource: textureView164},
    {binding: 152, resource: {buffer: buffer97, offset: 11264, size: 7245}},
    {binding: 27, resource: {buffer: buffer279, offset: 256}},
    {binding: 50, resource: {buffer: buffer176, offset: 0, size: 718}},
    {binding: 380, resource: textureView92},
    {binding: 125, resource: sampler84},
    {binding: 598, resource: {buffer: buffer291, offset: 0, size: 20}},
    {binding: 56, resource: {buffer: buffer18, offset: 2816, size: 621}},
    {binding: 192, resource: textureView69},
    {binding: 62, resource: {buffer: buffer291, offset: 0, size: 712}},
    {binding: 77, resource: externalTexture19},
    {binding: 65, resource: textureView228},
    {binding: 301, resource: {buffer: buffer82, offset: 256, size: 68}},
    {binding: 91, resource: {buffer: buffer188, offset: 7424, size: 205}},
    {binding: 6, resource: {buffer: buffer206, offset: 1792, size: 592}},
    {binding: 119, resource: {buffer: buffer82, offset: 512, size: 2452}},
    {binding: 114, resource: textureView143},
    {binding: 386, resource: sampler242},
    {binding: 296, resource: textureView359},
    {binding: 220, resource: sampler5},
    {binding: 52, resource: sampler141},
    {binding: 810, resource: {buffer: buffer291, offset: 512, size: 533}},
    {binding: 209, resource: textureView9},
    {binding: 66, resource: textureView299},
    {binding: 203, resource: textureView128},
    {binding: 566, resource: {buffer: buffer106, offset: 256, size: 208}},
    {binding: 839, resource: {buffer: buffer78, offset: 0, size: 7541}},
    {binding: 28, resource: textureView70},
    {binding: 277, resource: textureView57},
    {binding: 58, resource: sampler138},
    {binding: 82, resource: {buffer: buffer86, offset: 3072, size: 857}},
    {binding: 113, resource: textureView69},
    {binding: 178, resource: sampler243},
    {binding: 99, resource: textureView156},
    {binding: 698, resource: textureView296},
    {binding: 171, resource: textureView334},
    {binding: 7, resource: sampler78},
    {binding: 0, resource: externalTexture12},
    {binding: 196, resource: {buffer: buffer87, offset: 0}},
    {binding: 132, resource: {buffer: buffer259, offset: 0, size: 54}},
    {binding: 102, resource: {buffer: buffer283, offset: 0, size: 68}},
    {binding: 32, resource: textureView160},
    {binding: 245, resource: textureView12},
    {binding: 304, resource: externalTexture28},
  ],
});
let textureView392 = texture152.createView({
  label: '\ua7d7\u{1f976}\ubd45\u{1f613}\ud984\u895f\ue658\u018e\u{1fbea}\u0dbf',
  aspect: 'all',
  baseArrayLayer: 3,
  arrayLayerCount: 3,
});
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle42, renderBundle5, renderBundle5]);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer11, 'uint16', 54, 3_064);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(1, buffer209);
} catch {}
let pipeline25 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  multisample: {mask: 0x5d0b4a5b},
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule7,
    constants: {override40: 1},
    buffers: [
      {
        arrayStride: 12,
        attributes: [
          {format: 'snorm8x4', offset: 0, shaderLocation: 15},
          {format: 'float32', offset: 0, shaderLocation: 2},
          {format: 'uint32', offset: 0, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'},
});
let gpuCanvasContext23 = canvas15.getContext('webgpu');
let shaderModule29 = device0.createShaderModule({
  code: `
enable f16;
enable f16;
/* target size: 143 max align: 1 */
struct T0 {
  @align(1) @size(8) f0: array<atomic<i32>, 1>,
  @align(1) @size(88) f1: atomic<u32>,
  @align(1) @size(47) f2: array<u32>,
}
override override108 : f16;
@id(40990) override override106 : u32 = 227;
override override105 : u32;
@id(16794) override override107 : i32;
@group(0) @binding(172) var sam19: sampler;
@group(1) @binding(18) var tex27: texture_depth_2d;
@group(0) @binding(228) var<storage, read_write> buffer304: T0;
struct VertexOutput24 {
  @builtin(position) @invariant f71: vec4f,
  @location(15) @interpolate(perspective, center) f72: vec3f,
  @location(0) f73: i32
}

@vertex
fn vertex0() -> VertexOutput24 {
  var out: VertexOutput24;
  _ = override105;
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
  _ = override107;
}`,
  sourceMap: {},
});
let buffer305 = device0.createBuffer({size: 17128, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: true});
try {
renderPassEncoder30.setIndexBuffer(buffer122, 'uint16', 806, 2_200);
} catch {}
try {
renderBundleEncoder54.setBindGroup(0, bindGroup19, new Uint32Array(2261), 333, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let canvas16 = document.createElement('canvas');
try {
computePassEncoder176.setBindGroup(1, bindGroup1);
} catch {}
try {
renderPassEncoder48.setBindGroup(2, bindGroup237);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder54.setBindGroup(2, bindGroup109);
} catch {}
try {
renderBundleEncoder54.setIndexBuffer(buffer154, 'uint32', 340, 707);
} catch {}
try {
device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); });
} catch {}
let texture410 = device0.createTexture({
  label: '\u5b6d\ucda2\ucbae\u69bd\u073d\ue714\uf6d3',
  size: {width: 144, height: 48, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView393 = texture176.createView({});
try {
computePassEncoder63.setBindGroup(0, bindGroup87, new Uint32Array(38), 1, 0);
} catch {}
try {
computePassEncoder20.setPipeline(pipeline13);
} catch {}
let promise64 = shaderModule1.getCompilationInfo();
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas4,
  origin: { x: 12, y: 2 },
  flipY: false,
}, {
  texture: texture400,
  mipLevel: 0,
  origin: {x: 1, y: 8, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext14.unconfigure();
} catch {}
try {
  await promise64;
} catch {}
document.body.append(video5);
let bindGroup243 = device0.createBindGroup({layout: bindGroupLayout22, entries: [{binding: 4, resource: textureView125}]});
try {
renderBundleEncoder54.setBindGroup(1, bindGroup213);
} catch {}
try {
renderBundleEncoder54.setIndexBuffer(buffer109, 'uint16', 124, 3_658);
} catch {}
try {
renderBundleEncoder54.setVertexBuffer(6, buffer114);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let arrayBuffer54 = buffer160.getMappedRange();
let gpuCanvasContext24 = canvas16.getContext('webgpu');
try {
gpuCanvasContext18.unconfigure();
} catch {}
try {
computePassEncoder153.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(176);
} catch {}
try {
renderBundleEncoder54.setBindGroup(3, bindGroup66, new Uint32Array(664), 75, 0);
} catch {}
try {
renderBundleEncoder54.setIndexBuffer(buffer104, 'uint16', 918, 1_699);
} catch {}
try {
renderBundleEncoder54.setVertexBuffer(4, buffer240, 9_560, 2_452);
} catch {}
let imageBitmap14 = await createImageBitmap(imageData36);
let buffer306 = device0.createBuffer({
  size: 1896,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
let renderBundle55 = renderBundleEncoder54.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder188); computePassEncoder188.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer22, 'uint32', 76, 148);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(3, buffer55, 264, 1_458);
} catch {}
let bindGroup244 = device0.createBindGroup({
  layout: bindGroupLayout17,
  entries: [
    {binding: 408, resource: {buffer: buffer156, offset: 17664}},
    {binding: 27, resource: textureView275},
    {binding: 50, resource: textureView355},
  ],
});
let buffer307 = device0.createBuffer({size: 896, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let querySet51 = device0.createQuerySet({type: 'occlusion', count: 1120});
let texture411 = device0.createTexture({
  size: [144],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let querySet52 = device0.createQuerySet({label: '\u510d\u0089\ufeeb', type: 'occlusion', count: 98});
let textureView394 = texture232.createView({dimension: '2d-array', format: 'bgra8unorm-srgb', baseArrayLayer: 0});
try {
computePassEncoder142.setBindGroup(1, bindGroup59, new Uint32Array(452), 43, 0);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline25);
} catch {}
let bindGroup245 = device0.createBindGroup({layout: bindGroupLayout24, entries: [{binding: 425, resource: textureView197}]});
try {
renderPassEncoder34.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder37.setBindGroup(0, bindGroup191, new Uint32Array(394), 21, 0);
} catch {}
try {
renderPassEncoder34.beginOcclusionQuery(207);
} catch {}
try {
renderPassEncoder47.setViewport(24.80720385518251, 9.804612741033594, 8.46093294576279, 0.05039144552270221, 0.027289047552269907, 0.046020625487734924);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer97, 'uint32', 20_884, 1_214);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer301, 312);
} catch {}
try {
if (!arrayBuffer49.detached) { new Uint8Array(arrayBuffer49).fill(0x55); };
} catch {}
document.body.append(video2);
try {
computePassEncoder63.setBindGroup(0, bindGroup39, new Uint32Array(1216), 329, 0);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle42, renderBundle0]);
} catch {}
try {
buffer20.unmap();
} catch {}
let textureView395 = texture5.createView({dimension: '2d-array', aspect: 'stencil-only'});
try {
computePassEncoder36.setBindGroup(1, bindGroup87);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle20, renderBundle42]);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 384, new BigUint64Array(6585), 108, 32);
} catch {}
let buffer308 = device0.createBuffer({size: 884, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let texture412 = device0.createTexture({
  size: {width: 32},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder25.setBindGroup(3, bindGroup44, new Uint32Array(1813), 45, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup240, new Uint32Array(507), 32, 0);
} catch {}
try {
computePassEncoder172.insertDebugMarker('\u212f');
} catch {}
try {
window.someLabel = externalTexture9.label;
} catch {}
let texture413 = device0.createTexture({
  size: {width: 420, height: 1, depthOrArrayLayers: 16},
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView396 = texture59.createView({dimension: '2d-array'});
let renderBundleEncoder56 = device0.createRenderBundleEncoder({label: '\u{1f724}\u{1f846}\u305d', colorFormats: ['rg16float']});
let sampler276 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.61,
  maxAnisotropy: 17,
});
try {
computePassEncoder88.setBindGroup(1, bindGroup57, new Uint32Array(776), 26, 0);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder56.setIndexBuffer(buffer142, 'uint32', 104, 47);
} catch {}
let videoFrame75 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt709', transfer: 'hlg'} });
let buffer309 = device0.createBuffer({size: 4080, usage: GPUBufferUsage.MAP_WRITE});
let renderBundleEncoder57 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], sampleCount: 1, depthReadOnly: true});
try {
renderPassEncoder40.setIndexBuffer(buffer301, 'uint16', 4_654, 1_204);
} catch {}
let buffer310 = device0.createBuffer({
  size: 3089,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView397 = texture340.createView({baseArrayLayer: 4, arrayLayerCount: 1});
try {
computePassEncoder155.setBindGroup(2, bindGroup141, []);
} catch {}
try {
renderPassEncoder30.setBindGroup(3, bindGroup169);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer240, 'uint32', 240, 7_284);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder56.setIndexBuffer(buffer60, 'uint32', 476, 1_480);
} catch {}
try {
renderBundleEncoder56.setPipeline(pipeline23);
} catch {}
try {
gpuCanvasContext20.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let buffer311 = device0.createBuffer({
  label: '\u{1ff4d}\u8d34\uf82f\uea89\u0dbe\u4818\u6587\udf6b\u0c6e\uf9d1\u8e25',
  size: 35864,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: true,
});
try {
renderBundleEncoder56.setBindGroup(2, bindGroup197, new Uint32Array(2357), 386, 0);
} catch {}
let buffer312 = device0.createBuffer({
  size: 17319,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let querySet53 = device0.createQuerySet({type: 'occlusion', count: 227});
try {
computePassEncoder137.setBindGroup(1, bindGroup215);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup54);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder40.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder56.setBindGroup(3, bindGroup171, new Uint32Array(1554), 50, 0);
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture324,
  mipLevel: 0,
  origin: {x: 30, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(394).fill(137), /* required buffer size: 394 */
{offset: 394, bytesPerRow: 40}, {width: 0, height: 19, depthOrArrayLayers: 0});
} catch {}
let textureView398 = texture48.createView({
  label: '\u0b84\u71ed\u821c\uafed\u084c',
  dimension: 'cube-array',
  baseArrayLayer: 1,
  arrayLayerCount: 6,
});
let texture414 = device0.createTexture({
  size: [78, 132, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView399 = texture202.createView({dimension: '1d'});
try {
computePassEncoder80.setBindGroup(2, bindGroup170);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(2, buffer167);
} catch {}
try {
renderBundleEncoder56.setBindGroup(0, bindGroup163);
} catch {}
try {
renderBundleEncoder56.setPipeline(pipeline21);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let texture415 = device0.createTexture({
  size: [420, 1, 10],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder132.setBindGroup(2, bindGroup214, new Uint32Array(3053), 1_735, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(0, bindGroup207, new Uint32Array(3972), 1_170, 0);
} catch {}
try {
renderBundleEncoder57.setBindGroup(2, bindGroup216);
} catch {}
try {
renderBundleEncoder57.setPipeline(pipeline15);
} catch {}
try {
buffer159.unmap();
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
gpuCanvasContext11.unconfigure();
} catch {}
let buffer313 = device0.createBuffer({size: 8099, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView400 = texture188.createView({aspect: 'all'});
let textureView401 = texture285.createView({});
let renderBundle56 = renderBundleEncoder57.finish({});
try {
computePassEncoder5.setBindGroup(1, bindGroup218, []);
} catch {}
try {
computePassEncoder100.setBindGroup(2, bindGroup221, new Uint32Array(2981), 177, 0);
} catch {}
try {
renderPassEncoder47.setBindGroup(3, bindGroup199);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer285, 'uint16', 1_294, 668);
} catch {}
try {
renderBundleEncoder56.setVertexBuffer(5, buffer86, 548, 2_944);
} catch {}
let buffer314 = device0.createBuffer({
  size: 20777,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture416 = device0.createTexture({
  label: '\u{1fad6}\u0ef0\ub643\u91d3',
  size: {width: 9},
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView402 = texture316.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder27.setBindGroup(1, bindGroup166);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer78, 'uint32', 4_468, 584);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(5, buffer64, 5_740, 1_731);
} catch {}
try {
renderBundleEncoder56.setVertexBuffer(5, buffer41, 0, 4_110);
} catch {}
try {
buffer74.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture206,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(120).fill(100), /* required buffer size: 120 */
{offset: 120}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame76 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt709', transfer: 'pq'} });
let renderBundle57 = renderBundleEncoder56.finish();
try {
renderPassEncoder21.setBlendConstant({ r: -402.7, g: 690.2, b: -597.9, a: 348.0, });
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer231, 'uint16', 46, 1_296);
} catch {}
let imageData57 = new ImageData(84, 44);
let texture417 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 76},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler277 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 40.63,
  lodMaxClamp: 78.65,
});
try {
computePassEncoder188.dispatchWorkgroupsIndirect(buffer286, 2_012);
} catch {}
let arrayBuffer55 = buffer66.getMappedRange(7032, 100);
try {
computePassEncoder67.insertDebugMarker('\uad43');
} catch {}
let texture418 = device0.createTexture({
  size: [420, 1, 12],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let externalTexture60 = device0.importExternalTexture({label: '\u{1fc63}\u96e6\u0c1d\ub94c\u0bf2\uf1c0', source: video5});
try {
renderPassEncoder23.setBindGroup(0, bindGroup75, new Uint32Array(1919), 291, 0);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(2, buffer40, 0, 5_613);
} catch {}
try {
buffer278.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer2, 792, new Int16Array(2526));
} catch {}
let buffer315 = device0.createBuffer({
  label: '\u0f91\u{1fc26}\u70d6\u03e4',
  size: 15141,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView403 = texture256.createView({
  label: '\ua3c4\u{1f6e5}\uc849\u{1fa2d}\u0fe8\u70b2\u0748',
  dimension: '2d-array',
  baseMipLevel: 0,
  mipLevelCount: 1,
});
let sampler278 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 75.51,
  lodMaxClamp: 77.51,
});
try {
renderPassEncoder23.setPipeline(pipeline25);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let sampler279 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMinClamp: 56.28,
  lodMaxClamp: 74.20,
  compare: 'equal',
});
try {
renderPassEncoder15.executeBundles([renderBundle20, renderBundle42]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture84,
  mipLevel: 0,
  origin: {x: 38, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(14).fill(28), /* required buffer size: 14 */
{offset: 14}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder184.setBindGroup(2, bindGroup81, new Uint32Array(335), 159, 0);
} catch {}
try {
computePassEncoder19.end();
} catch {}
try {
renderPassEncoder16.setBindGroup(1, bindGroup216, new Uint32Array(3017), 671, 0);
} catch {}
try {
renderPassEncoder34.endOcclusionQuery();
} catch {}
let bindGroup246 = device0.createBindGroup({
  layout: bindGroupLayout50,
  entries: [{binding: 209, resource: {buffer: buffer218, offset: 768, size: 80}}],
});
let buffer316 = device0.createBuffer({
  label: '\u{1fd39}\ua5c3\ufd86\ubc46',
  size: 36791,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
let textureView404 = texture204.createView({});
let computePassEncoder228 = commandEncoder24.beginComputePass();
try {
computePassEncoder34.setBindGroup(0, bindGroup223);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup215, new Uint32Array(1169), 323, 0);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline25);
} catch {}
try {
device0.queue.writeBuffer(buffer175, 2012, new Float32Array(14071), 987, 56);
} catch {}
let bindGroup247 = device0.createBindGroup({
  layout: bindGroupLayout38,
  entries: [
    {binding: 158, resource: externalTexture35},
    {binding: 752, resource: {buffer: buffer263, offset: 0, size: 597}},
    {binding: 166, resource: {buffer: buffer188, offset: 2304, size: 1769}},
    {binding: 396, resource: {buffer: buffer291, offset: 0, size: 56}},
    {binding: 116, resource: {buffer: buffer110, offset: 256, size: 352}},
    {binding: 209, resource: {buffer: buffer187, offset: 7680, size: 1448}},
    {binding: 75, resource: textureView77},
    {binding: 208, resource: {buffer: buffer208, offset: 2816, size: 548}},
    {binding: 131, resource: sampler4},
    {binding: 15, resource: textureView346},
    {binding: 222, resource: {buffer: buffer237, offset: 5376, size: 2164}},
  ],
});
let sampler280 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 4.903,
});
try {
computePassEncoder188.setBindGroup(2, bindGroup25, new Uint32Array(3460), 642, 0);
} catch {}
try {
computePassEncoder84.end();
} catch {}
try {
renderPassEncoder34.setBindGroup(3, bindGroup57);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 476, new Float32Array(16284), 3375, 240);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData55,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture320,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
let textureView405 = texture184.createView({dimension: '2d-array', arrayLayerCount: 1});
let renderPassEncoder49 = commandEncoder103.beginRenderPass({
  colorAttachments: [{
  view: textureView336,
  clearValue: { r: 184.5, g: 687.4, b: 979.9, a: 519.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet34,
});
try {
computePassEncoder228.setPipeline(pipeline18);
} catch {}
try {
gpuCanvasContext18.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture185,
  mipLevel: 0,
  origin: {x: 56, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(84).fill(222), /* required buffer size: 84 */
{offset: 84}, {width: 86, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup248 = device0.createBindGroup({layout: bindGroupLayout41, entries: [{binding: 87, resource: textureView355}]});
let buffer317 = device0.createBuffer({
  label: '\u48f9\u7b85\u82f0',
  size: 2988,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: true,
});
try {
computePassEncoder25.setBindGroup(3, bindGroup193);
} catch {}
try {
renderPassEncoder37.setBindGroup(3, bindGroup200);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer48, 'uint32', 12, 17);
} catch {}
let buffer318 = device0.createBuffer({size: 15540, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: true});
try {
computePassEncoder8.setBindGroup(2, bindGroup171, new Uint32Array(642), 107, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder148); computePassEncoder148.dispatchWorkgroups(3); };
} catch {}
try {
renderPassEncoder39.setBlendConstant({ r: -707.3, g: -85.48, b: 302.4, a: 717.9, });
} catch {}
try {
gpuCanvasContext4.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, alphaMode: 'opaque'});
} catch {}
await gc();
let bindGroup249 = device0.createBindGroup({
  layout: bindGroupLayout38,
  entries: [
    {binding: 222, resource: {buffer: buffer206, offset: 512, size: 1380}},
    {binding: 116, resource: {buffer: buffer203, offset: 12800, size: 528}},
    {binding: 209, resource: {buffer: buffer92, offset: 512}},
    {binding: 752, resource: {buffer: buffer37, offset: 768, size: 226}},
    {binding: 166, resource: {buffer: buffer310, offset: 256, size: 461}},
    {binding: 158, resource: externalTexture8},
    {binding: 131, resource: sampler70},
    {binding: 208, resource: {buffer: buffer234, offset: 768, size: 236}},
    {binding: 75, resource: textureView77},
    {binding: 396, resource: {buffer: buffer92, offset: 0, size: 120}},
    {binding: 15, resource: textureView260},
  ],
});
let querySet54 = device0.createQuerySet({label: '\ub9a9\u5233\u08a2\u{1fd95}\u{1f8df}\u090b\u0aac\u75e1', type: 'occlusion', count: 356});
try {
renderPassEncoder15.setBindGroup(1, bindGroup223, new Uint32Array(1592), 278, 0);
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
video1.requestVideoFrameCallback((now, metadata) => { metadata.length = now; });
let buffer319 = device0.createBuffer({size: 828, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX, mappedAtCreation: true});
let textureView406 = texture359.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundleEncoder58 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], stencilReadOnly: true});
try {
computePassEncoder142.setBindGroup(2, bindGroup105, new Uint32Array(2119), 234, 0);
} catch {}
try {
computePassEncoder195.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder49.executeBundles([renderBundle5, renderBundle50, renderBundle17, renderBundle20]);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder58.setIndexBuffer(buffer249, 'uint16', 1_328, 233);
} catch {}
try {
renderBundleEncoder58.setPipeline(pipeline25);
} catch {}
try {
device0.queue.writeBuffer(buffer272, 2356, new DataView(new ArrayBuffer(7324)), 461, 236);
} catch {}
let textureView407 = texture343.createView({});
let renderBundle58 = renderBundleEncoder58.finish({});
try {
renderPassEncoder48.setBindGroup(3, bindGroup22, new Uint32Array(1693), 260, 0);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle6, renderBundle38, renderBundle50]);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer42, 'uint32', 7_060, 4_192);
} catch {}
let bindGroupLayout53 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 211,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
try {
buffer135.unmap();
} catch {}
document.body.append(video6);
try {
computePassEncoder148.dispatchWorkgroupsIndirect(buffer210, 1_328);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle7, renderBundle0, renderBundle38, renderBundle42]);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer246, 52, 26);
} catch {}
try {
device0.queue.writeBuffer(buffer76, 364, new DataView(new ArrayBuffer(8034)), 608, 408);
} catch {}
try {
computePassEncoder151.setBindGroup(0, bindGroup76, []);
} catch {}
try {
renderPassEncoder34.setStencilReference(108);
} catch {}
try {
computePassEncoder63.insertDebugMarker('\uf656');
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let texture419 = device0.createTexture({size: [36, 12, 29], dimension: '3d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.TEXTURE_BINDING});
let sampler281 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 54.02,
  lodMaxClamp: 94.47,
});
try {
computePassEncoder175.setBindGroup(2, bindGroup125);
} catch {}
try {
computePassEncoder93.setBindGroup(0, bindGroup210, new Uint32Array(2653), 105, 0);
} catch {}
try {
computePassEncoder179.end();
} catch {}
try {
renderPassEncoder37.setViewport(5.81571159330064, 12.031649505683193, 0.2283279772967255, 1.469187100378178, 0.2388069387268812, 0.8412183175701868);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer211, 'uint16', 508, 1_713);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(0, buffer185, 2_836, 239);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData28,
  origin: { x: 4, y: 0 },
  flipY: true,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 5, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 13, height: 1, depthOrArrayLayers: 0});
} catch {}
await gc();
let videoFrame77 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpteRp431', transfer: 'bt1361ExtendedColourGamut'} });
let texture420 = device0.createTexture({
  size: {width: 144},
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder229 = commandEncoder226.beginComputePass();
try {
computePassEncoder143.setBindGroup(1, bindGroup106, new Uint32Array(4854), 2_272, 0);
} catch {}
try {
computePassEncoder226.setPipeline(pipeline12);
} catch {}
try {
computePassEncoder229.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder30.setBindGroup(1, bindGroup98);
} catch {}
try {
renderPassEncoder30.beginOcclusionQuery(0);
} catch {}
document.body.append(img2);
let buffer320 = device0.createBuffer({
  size: 9904,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView408 = texture252.createView({aspect: 'all', arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup75);
} catch {}
let querySet55 = device0.createQuerySet({type: 'occlusion', count: 653});
let textureView409 = texture272.createView({
  label: '\u0eff\ude2b\u{1fa86}\u{1f87a}\u5c8d\u09eb\u0767\uc197\u0138\uff3f\u0f88',
  dimension: '2d-array',
});
let sampler282 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 87.01,
  lodMaxClamp: 90.78,
  maxAnisotropy: 19,
});
let externalTexture61 = device0.importExternalTexture({label: '\uec9b\u8593\u{1f9a5}\u8a37\u1ff8\u03a1\u6864\ub0de\u0a45', source: video1});
try {
renderPassEncoder39.setBindGroup(3, bindGroup20);
} catch {}
try {
renderPassEncoder27.setViewport(6.964001870897192, 15.762349333360962, 1.3506611539448046, 0.0641738293389748, 0.8478960413750606, 0.9785641867031332);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer230, 'uint16', 5_562, 2_481);
} catch {}
let texture421 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView410 = texture219.createView({});
try {
computePassEncoder137.setBindGroup(3, bindGroup211);
} catch {}
try {
computePassEncoder156.setBindGroup(1, bindGroup9, new Uint32Array(551), 103, 0);
} catch {}
try {
renderPassEncoder39.setBindGroup(3, bindGroup59);
} catch {}
try {
renderPassEncoder30.endOcclusionQuery();
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(3, buffer58);
} catch {}
let arrayBuffer56 = buffer289.getMappedRange(0, 440);
try {
computePassEncoder136.setBindGroup(1, bindGroup149, new Uint32Array(1090), 207, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer175, 1268, new Float32Array(7955), 209, 304);
} catch {}
let renderBundleEncoder59 = device0.createRenderBundleEncoder({colorFormats: ['r16float', 'rg16sint'], depthReadOnly: true});
try {
computePassEncoder152.setBindGroup(0, bindGroup134);
} catch {}
try {
computePassEncoder129.setBindGroup(0, bindGroup210, new Uint32Array(59), 15, 0);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup231);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(6, buffer258, 3_116);
} catch {}
try {
renderBundleEncoder59.setBindGroup(2, bindGroup205, new Uint32Array(932), 367, 0);
} catch {}
let imageData58 = new ImageData(32, 16);
let buffer321 = device0.createBuffer({
  size: 8001,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let renderBundleEncoder60 = device0.createRenderBundleEncoder({
  label: '\ubf8f\u59fc\u0364\u0c3b\uafd1\u0ac2\u288f\u58f5',
  colorFormats: ['rg16float'],
  stencilReadOnly: true,
});
try {
renderPassEncoder34.setBindGroup(2, bindGroup146);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(6, buffer11);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(3, buffer184, 332);
} catch {}
let videoFrame78 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'bt2020_12bit'} });
let bindGroup250 = device0.createBindGroup({
  label: '\uba63\ud5cc',
  layout: bindGroupLayout1,
  entries: [
    {binding: 102, resource: textureView318},
    {binding: 9, resource: textureView4},
    {binding: 453, resource: textureView36},
  ],
});
let sampler283 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 6.502,
  lodMaxClamp: 66.46,
  compare: 'less-equal',
  maxAnisotropy: 1,
});
try {
computePassEncoder149.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder23.setBlendConstant({ r: -717.6, g: -211.1, b: 198.9, a: -172.5, });
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(2, buffer48, 0, 105);
} catch {}
try {
renderBundleEncoder60.setBindGroup(2, bindGroup29, new Uint32Array(196), 19, 0);
} catch {}
try {
renderBundleEncoder59.setPipeline(pipeline10);
} catch {}
let sampler284 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 44.65,
  lodMaxClamp: 46.61,
});
let externalTexture62 = device0.importExternalTexture({source: videoFrame62, colorSpace: 'srgb'});
try {
computePassEncoder171.setBindGroup(0, bindGroup156);
} catch {}
try {
computePassEncoder164.setBindGroup(0, bindGroup42, new Uint32Array(852), 98, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer79, 2_244); };
} catch {}
try {
renderPassEncoder48.setViewport(20.443099490677966, 3.907876865439729, 12.812686188307413, 6.984261010918858, 0.8419338940474972, 0.9829129283789746);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(7, buffer105, 1_672, 678);
} catch {}
try {
renderBundleEncoder60.setBindGroup(2, bindGroup68);
} catch {}
try {
renderBundleEncoder59.setIndexBuffer(buffer26, 'uint32', 1_092, 75);
} catch {}
try {
renderBundleEncoder60.setPipeline(pipeline21);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let imageData59 = new ImageData(4, 44);
let texture422 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 50},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler285 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 68.98,
  lodMaxClamp: 94.95,
});
try {
renderPassEncoder40.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder48.setVertexBuffer(5, buffer227, 0);
} catch {}
let shaderModule30 = device0.createShaderModule({
  code: `
enable f16;
/* target size: 16 max align: 16 */
struct T0 {
  @size(16) f0: atomic<u32>,
}
/* target size: 15 max align: 1 */
struct T1 {
  @align(1) @size(15) f0: vec2u,
}
/* target size: 15 max align: 1 */
struct T2 {
  @align(1) f0: f16,
  @align(1) @size(13) f1: array<atomic<u32>, 1>,
}
@group(0) @binding(159) var<storage, read> buffer325: array<array<f32, 1>, 2>;
@group(0) @binding(33) var<uniform> buffer324: array<array<array<f16, 1>, 7>, 2>;
@group(1) @binding(643) var tex33: texture_2d<i32>;
@group(0) @binding(103) var tex30: texture_cube<i32>;
@group(0) @binding(286) var sam21: sampler;
@group(0) @binding(528) var sam20: sampler;
@group(1) @binding(101) var<uniform> buffer327: i32;
@group(0) @binding(238) var sam22: sampler;
@group(0) @binding(21) var tex28: texture_cube_array<u32>;
@group(0) @binding(56) var tex29: texture_2d_array<f32>;
@group(1) @binding(170) var tex32: texture_2d<f32>;
@group(0) @binding(57) var st7: texture_storage_2d<bgra8unorm, write>;
@group(0) @binding(388) var<uniform> buffer323: array<f16, 29>;
@group(0) @binding(151) var<uniform> buffer326: T1;
@group(0) @binding(313) var<storage, read> buffer322: vec2i;
@group(1) @binding(167) var sam23: sampler_comparison;
@group(0) @binding(309) var tex31: texture_3d<f32>;
struct VertexOutput25 {
  @builtin(position) f74: vec4f
}

@vertex
fn vertex0() -> VertexOutput25 {
  var out: VertexOutput25;
  _ = buffer324[1][6][0];
  _ = buffer324[1];
  _ = buffer323;
  _ = buffer326.f0;
  return out;
}
struct VertexOutput26 {
  @location(0) @interpolate(flat, center) f75: vec4u,
  @location(2) @interpolate(flat, centroid) f76: i32,
  @builtin(position) f77: vec4f,
  @location(7) f78: vec2f,
  @location(15) @interpolate(perspective, sample) f79: f16,
  @location(5) @interpolate(linear) f80: f16
}

@vertex @must_use
fn vertex1(@location(14) @interpolate(perspective, centroid) a0: vec4h, @location(4) a1: vec4h) -> VertexOutput26 {
  var out: VertexOutput26;
  _ = buffer325[1];
  _ = buffer325[1][0];
  _ = textureGather(0, tex32, sam21, vec2f(), vec2i());
  _ = buffer324[1][6];
  _ = buffer326;
  _ = buffer326.f0;
  _ = buffer324[1][0];
  _ = textureSampleBaseClampToEdge(tex32, sam21, vec2f());
  _ = buffer324[1][6][0];
  out.f79 = f16(-44058.7);
  return out;
}
struct VertexOutput27 {
  @builtin(position) @invariant f81: vec4f,
  @location(3) f82: vec3h,
  @location(1) f83: f32
}

@vertex
fn vertex2() -> VertexOutput27 {
  var out: VertexOutput27;
  _ = textureSampleGrad(tex32, sam21, vec2f(), vec2f(), vec2f(), vec2i());
  _ = buffer325[1][0];
  _ = textureGather(3, tex32, sam21, vec2f());
  _ = buffer324[0];
  _ = textureSampleLevel(tex32, sam21, vec2f(), 0.0);
  _ = textureGather(1, tex33, sam21, vec2f(), vec2i());
  _ = buffer324[1][0];
  if bool(textureLoad(tex29, vec2i(), 0, 0)[3]) {
    var v: vec4f;
  }
  return out;
}
struct FragmentOutput25 {
  @location(0) f0: vec2f,
  @location(1) @interpolate(flat, sample) f1: vec4i,
  @location(2) @interpolate(flat, centroid) f2: vec2u
}

@fragment
fn fragment0() -> FragmentOutput25 {
  var out: FragmentOutput25;
  _ = textureGather(0, tex30, sam22, vec3f());
  _ = textureSampleLevel(tex32, sam22, vec2f(), 0.0, vec2i());
  _ = textureGather(0, tex30, sam21, vec3f());
  _ = textureLoad(tex32, vec2i(), 0);
  _ = textureSampleBias(tex32, sam22, vec2f(), 0.0);
  out.f2 %= bitcast<vec2u>(textureSampleGrad(tex32, sam22, vec2f(), vec2f(), vec2f()).rb);
  textureStore(st7, vec2i(), vec4f(0.01632, 0.00499, 0.1902, 0.01871));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(workgroup_id) a0: vec3u) {
  _ = buffer325[1];
  _ = buffer324[1][6];
  _ = buffer325;
}`,
  sourceMap: {},
  hints: {},
});
let texture423 = device0.createTexture({
  size: [210, 1, 116],
  mipLevelCount: 5,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder31.setBindGroup(0, bindGroup90);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroupsIndirect(buffer224, 4_784); };
} catch {}
try {
renderBundleEncoder60.setBindGroup(0, bindGroup34, new Uint32Array(5729), 2_292, 0);
} catch {}
let arrayBuffer57 = buffer144.getMappedRange(0, 1636);
try {
renderPassEncoder15.insertDebugMarker('\uf012');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture298,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 29},
  aspect: 'all',
}, new Uint8Array(20_589).fill(199), /* required buffer size: 20_589 */
{offset: 121, bytesPerRow: 86, rowsPerImage: 14}, {width: 23, height: 0, depthOrArrayLayers: 18});
} catch {}
let bindGroup251 = device0.createBindGroup({layout: bindGroupLayout41, entries: [{binding: 87, resource: textureView355}]});
let sampler286 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 75.77,
  lodMaxClamp: 81.78,
});
try {
computePassEncoder54.setBindGroup(1, bindGroup107);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer221, 128); };
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup33);
} catch {}
try {
renderPassEncoder40.setBlendConstant({ r: -990.5, g: -886.8, b: -453.8, a: 135.0, });
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(5, buffer172, 0, 2_573);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'display-p3',
});
} catch {}
try {
if (!arrayBuffer40.detached) { new Uint8Array(arrayBuffer40).fill(0x55); };
} catch {}
document.body.prepend(img8);
let buffer328 = device0.createBuffer({
  label: '\ue593\u{1f7d7}\u058e\u{1fef1}\u77fb\udd3f\u95b3',
  size: 8001,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture424 = device0.createTexture({
  size: {width: 32},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView411 = texture129.createView({format: 'depth16unorm', baseArrayLayer: 0});
let renderBundle59 = renderBundleEncoder60.finish({});
try {
renderPassEncoder37.setIndexBuffer(buffer12, 'uint32', 2_896, 4_353);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(6, buffer209, 52);
} catch {}
try {
renderBundleEncoder59.setBindGroup(3, bindGroup83, new Uint32Array(1676), 128, 0);
} catch {}
try {
renderBundleEncoder59.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder59.setVertexBuffer(2, buffer105, 632);
} catch {}
let pipelineLayout32 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture425 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder47.setBindGroup(3, bindGroup171, []);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder49.setVertexBuffer(3, buffer280, 12, 40);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let bindGroup252 = device0.createBindGroup({layout: bindGroupLayout47, entries: [{binding: 210, resource: textureView398}]});
try {
computePassEncoder160.setBindGroup(2, bindGroup189, new Uint32Array(1338), 129, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder37.setBindGroup(3, bindGroup137, new Uint32Array(370), 92, 0);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(0, buffer234, 0);
} catch {}
let textureView412 = texture247.createView({dimension: '2d-array'});
let externalTexture63 = device0.importExternalTexture({label: '\ue42a\ub8b5\u{1faec}\ub0cd\uaf60\u7a9d\u{1fdf0}\u49db', source: videoFrame73});
try {
renderPassEncoder24.setBindGroup(1, bindGroup226, new Uint32Array(135), 26, 0);
} catch {}
try {
renderPassEncoder37.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder59.setBindGroup(3, bindGroup203);
} catch {}
try {
renderBundleEncoder59.setBindGroup(2, bindGroup239, new Uint32Array(1714), 200, 0);
} catch {}
try {
renderBundleEncoder59.setVertexBuffer(1, buffer191, 712, 221);
} catch {}
let bindGroup253 = device0.createBindGroup({
  layout: bindGroupLayout19,
  entries: [{binding: 25, resource: {buffer: buffer79, offset: 1024, size: 1564}}],
});
let textureView413 = texture149.createView({dimension: 'cube'});
try {
renderPassEncoder39.setBindGroup(1, bindGroup229);
} catch {}
try {
renderPassEncoder34.beginOcclusionQuery(42);
} catch {}
try {
renderPassEncoder34.endOcclusionQuery();
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder59.setBindGroup(2, bindGroup182, new Uint32Array(1802), 201, 0);
} catch {}
try {
renderBundleEncoder59.setIndexBuffer(buffer7, 'uint32', 296, 496);
} catch {}
try {
renderBundleEncoder59.setVertexBuffer(4_294_967_295, undefined, 0, 426_956_693);
} catch {}
try {
renderBundleEncoder59.setBindGroup(0, bindGroup25, new Uint32Array(462), 99, 0);
} catch {}
try {
  await shaderModule2.getCompilationInfo();
} catch {}
try {
if (!arrayBuffer24.detached) { new Uint8Array(arrayBuffer24).fill(0x55); };
} catch {}
let renderBundle60 = renderBundleEncoder59.finish();
try {
renderPassEncoder40.setBindGroup(0, bindGroup221, new Uint32Array(65), 34, 0);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(0, buffer106, 0, 0);
} catch {}
try {
querySet34.destroy();
} catch {}
let promise65 = device0.queue.onSubmittedWorkDone();
let bindGroupLayout54 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 172,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 55,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 26,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 190,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup254 = device0.createBindGroup({
  layout: bindGroupLayout31,
  entries: [{binding: 80, resource: textureView229}, {binding: 9, resource: textureView69}],
});
try {
renderPassEncoder24.setBindGroup(1, bindGroup101);
} catch {}
try {
renderPassEncoder49.setPipeline(pipeline25);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture99,
  mipLevel: 0,
  origin: {x: 216, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(115).fill(158), /* required buffer size: 115 */
{offset: 115}, {width: 51, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture426 = device0.createTexture({
  size: {width: 288, height: 96, depthOrArrayLayers: 14},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView414 = texture136.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer312, 3_032); };
} catch {}
try {
renderPassEncoder34.setBindGroup(1, bindGroup220);
} catch {}
try {
gpuCanvasContext24.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let sampler287 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMinClamp: 11.60,
});
try {
renderPassEncoder16.setBindGroup(0, bindGroup145, new Uint32Array(3285), 254, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 15}
*/
{
  source: videoFrame42,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture258,
  mipLevel: 0,
  origin: {x: 157, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let bindGroupLayout55 = device0.createBindGroupLayout({
  label: '\u{1fa71}\u{1facb}\u07a5\u7952\u9f15\uac6d',
  entries: [
    {
      binding: 439,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
  ],
});
try {
renderPassEncoder37.setBindGroup(0, bindGroup222, []);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle20]);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer238, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture145,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(507).fill(253), /* required buffer size: 507 */
{offset: 507}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer329 = device0.createBuffer({
  size: 3744,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let renderBundleEncoder61 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], stencilReadOnly: true});
let renderBundle61 = renderBundleEncoder61.finish({label: '\uc22c\u03dd\ub2ea\ue62d\u2452\u{1f625}\ub485\u06ff'});
try {
renderPassEncoder23.executeBundles([renderBundle0, renderBundle10]);
} catch {}
try {
computePassEncoder1.pushDebugGroup('\u{1ff44}');
} catch {}
try {
gpuCanvasContext14.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let videoFrame79 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte170m', transfer: 'bt2020_12bit'} });
let texture427 = device0.createTexture({
  size: {width: 32, height: 32, depthOrArrayLayers: 16},
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderPassEncoder30.setIndexBuffer(buffer204, 'uint32', 16, 67);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise65;
} catch {}
let bindGroupLayout56 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 68,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 184,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 77,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 845,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 441,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 160,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 111,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let sampler288 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 28.88,
  lodMaxClamp: 98.23,
  compare: 'not-equal',
});
try {
computePassEncoder104.setBindGroup(3, bindGroup170, new Uint32Array(806), 444, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup237, []);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer161, 'uint32', 1_960, 4_647);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(1, buffer280);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder102.setBindGroup(3, bindGroup109, new Uint32Array(1134), 203, 0);
} catch {}
try {
renderPassEncoder49.setBindGroup(2, bindGroup42);
} catch {}
try {
renderPassEncoder39.setBindGroup(2, bindGroup182, new Uint32Array(4150), 1_583, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer234, 'uint16', 134, 367);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline25);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroup255 = device0.createBindGroup({
  layout: bindGroupLayout34,
  entries: [
    {binding: 643, resource: textureView6},
    {binding: 167, resource: sampler164},
    {binding: 101, resource: {buffer: buffer37, offset: 256}},
    {binding: 170, resource: textureView47},
  ],
});
let textureView415 = texture57.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder62 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true, stencilReadOnly: true});
let sampler289 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 23.37,
  lodMaxClamp: 68.37,
});
try {
computePassEncoder22.setBindGroup(3, bindGroup113);
} catch {}
try {
renderPassEncoder34.beginOcclusionQuery(442);
} catch {}
try {
renderPassEncoder34.endOcclusionQuery();
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle0, renderBundle17, renderBundle50, renderBundle3]);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer230, 'uint16', 16_494, 5_329);
} catch {}
try {
renderBundleEncoder62.setBindGroup(2, bindGroup125);
} catch {}
try {
renderBundleEncoder62.setPipeline(pipeline25);
} catch {}
let sampler290 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 97.15,
});
try {
computePassEncoder128.setBindGroup(0, bindGroup253);
} catch {}
try {
computePassEncoder216.setBindGroup(0, bindGroup30, new Uint32Array(1188), 116, 0);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle38]);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer316, 'uint32', 9_072, 2_320);
} catch {}
try {
renderBundleEncoder62.setBindGroup(1, bindGroup143, []);
} catch {}
try {
renderBundleEncoder62.setBindGroup(1, bindGroup55, new Uint32Array(3646), 147, 0);
} catch {}
try {
renderBundleEncoder62.setIndexBuffer(buffer177, 'uint16', 224, 1_748);
} catch {}
try {
renderBundleEncoder62.setPipeline(pipeline25);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture249,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(220).fill(92), /* required buffer size: 220 */
{offset: 220, rowsPerImage: 63}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup256 = device0.createBindGroup({
  label: '\u03a7\u03de\uc748\u204d',
  layout: bindGroupLayout43,
  entries: [{binding: 192, resource: externalTexture24}],
});
let textureView416 = texture142.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundle62 = renderBundleEncoder62.finish({});
try {
renderPassEncoder34.setBindGroup(2, bindGroup123);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer266, 'uint16', 458, 233);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(0, undefined);
} catch {}
let img9 = await imageWithData(25, 52, '#10101010', '#20202020');
try {
computePassEncoder5.setBindGroup(1, bindGroup160, new Uint32Array(1683), 17, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup100, new Uint32Array(2284), 817, 0);
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle21]);
} catch {}
try {
renderPassEncoder48.setIndexBuffer(buffer82, 'uint16', 782, 215);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(5, buffer262, 0, 269);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let textureView417 = texture195.createView({label: '\ue39d\u02bf\u{1f998}\u2f9d\ue53c\u807d\u014d\u9af3', arrayLayerCount: 4});
try {
computePassEncoder166.setBindGroup(3, bindGroup197);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer185, 'uint16', 48, 373);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline25);
} catch {}
let canvas17 = document.createElement('canvas');
let buffer330 = device0.createBuffer({
  size: 17560,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let querySet56 = device0.createQuerySet({type: 'occlusion', count: 174});
try {
renderPassEncoder23.setViewport(11.618334016233565, 28.30065114714252, 127.8317604476429, 21.021731319659175, 0.4895065684233114, 0.77322833062148);
} catch {}
try {
renderPassEncoder33.setPipeline(pipeline25);
} catch {}
try {
texture209.destroy();
} catch {}
let gpuCanvasContext25 = canvas17.getContext('webgpu');
let textureView418 = texture240.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder47.executeBundles([renderBundle58, renderBundle21]);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(7, buffer193, 200);
} catch {}
let pipeline26 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule26}});
try {
computePassEncoder193.setBindGroup(3, bindGroup32, []);
} catch {}
let textureView419 = texture167.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 6});
try {
computePassEncoder141.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder33.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer259, 264, 105);
} catch {}
try {
gpuCanvasContext13.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
try {
gpuCanvasContext22.unconfigure();
} catch {}
try {
window.someLabel = externalTexture49.label;
} catch {}
let bindGroup257 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 18, resource: textureView57}]});
let buffer331 = device0.createBuffer({size: 715, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let querySet57 = device0.createQuerySet({type: 'occlusion', count: 1424});
try {
computePassEncoder93.setBindGroup(0, bindGroup215, new Uint32Array(1246), 185, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer307, 32); };
} catch {}
try {
renderPassEncoder33.executeBundles([renderBundle53, renderBundle42, renderBundle21, renderBundle50]);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(4, buffer246, 0);
} catch {}
try {
computePassEncoder24.insertDebugMarker('\u{1fece}');
} catch {}
try {
device0.queue.writeBuffer(buffer145, 2844, new BigUint64Array(1499), 169, 40);
} catch {}
let sampler291 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 78.02,
  lodMaxClamp: 82.26,
});
try {
computePassEncoder191.setBindGroup(1, bindGroup257, new Uint32Array(1342), 154, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer134, 1_572);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 24, depthOrArrayLayers: 1}
*/
{
  source: videoFrame60,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture225,
  mipLevel: 0,
  origin: {x: 49, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer332 = device0.createBuffer({
  size: 9440,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: true,
});
try {
computePassEncoder210.setBindGroup(0, bindGroup56, new Uint32Array(189), 30, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup94, new Uint32Array(713), 392, 0);
} catch {}
let bindGroup258 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [{binding: 97, resource: textureView361}, {binding: 123, resource: textureView132}],
});
try {
computePassEncoder62.setBindGroup(0, bindGroup6, new Uint32Array(3053), 329, 0);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(7, undefined, 1_697_873_752, 509_023_996);
} catch {}
try {
device0.queue.writeBuffer(buffer285, 1196, new DataView(new ArrayBuffer(844)), 155, 132);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
externalTexture30.label = '\uf721\u{1f901}\u2f3c\u4abd\ua806\u4771\u03ca\u0eef\u0006\u0bca\u{1fe44}';
} catch {}
try {
window.someLabel = commandEncoder152.label;
} catch {}
try {
computePassEncoder37.setBindGroup(3, bindGroup68, new Uint32Array(1374), 372, 0);
} catch {}
try {
computePassEncoder169.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer245, 'uint32', 112, 552);
} catch {}
await gc();
let canvas18 = document.createElement('canvas');
let bindGroup259 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 15, resource: {buffer: buffer24, offset: 256, size: 884}}],
});
let buffer333 = device0.createBuffer({
  size: 9346,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder40.setPipeline(pipeline25);
} catch {}
try {
gpuCanvasContext21.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb'],
  alphaMode: 'premultiplied',
});
} catch {}
let videoFrame80 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'bt2020_12bit'} });
let bindGroup260 = device0.createBindGroup({
  layout: bindGroupLayout25,
  entries: [
    {binding: 129, resource: textureView388},
    {binding: 6, resource: textureView57},
    {binding: 1, resource: textureView418},
    {binding: 171, resource: textureView168},
    {binding: 252, resource: textureView331},
  ],
});
let sampler292 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMaxClamp: 94.48,
});
try {
renderPassEncoder24.setBindGroup(2, bindGroup154, new Uint32Array(2801), 691, 0);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle38, renderBundle6]);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer42, 'uint32', 4_116, 5_863);
} catch {}
video1.height = 72;
let buffer334 = device0.createBuffer({
  label: '\u0cb7\u04f1\u0ca8\u{1ff9b}\u46fd\u0186\u069f',
  size: 8020,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView420 = texture377.createView({});
try {
computePassEncoder184.setBindGroup(2, bindGroup94, new Uint32Array(1053), 219, 0);
} catch {}
let externalTexture64 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'});
try {
computePassEncoder172.setBindGroup(3, bindGroup87, new Uint32Array(993), 337, 0);
} catch {}
try {
computePassEncoder176.end();
} catch {}
try {
renderPassEncoder16.setViewport(170.28775377504329, 0.8231141355273268, 31.331783876776544, 0.04433526081674753, 0.6009432505205774, 0.6889078520026096);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer84, 0, 412);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 19, y: 9, z: 0},
  aspect: 'all',
}, new Uint8Array(642).fill(148), /* required buffer size: 642 */
{offset: 642, bytesPerRow: 267}, {width: 62, height: 19, depthOrArrayLayers: 0});
} catch {}
let texture428 = device0.createTexture({
  size: [39],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder50 = commandEncoder222.beginRenderPass({
  colorAttachments: [{
  view: textureView349,
  depthSlice: 297,
  clearValue: { r: -998.5, g: -996.6, b: -410.0, a: -437.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet29,
});
try {
computePassEncoder60.setBindGroup(2, bindGroup159, new Uint32Array(2723), 515, 0);
} catch {}
try {
renderPassEncoder50.setIndexBuffer(buffer277, 'uint16', 13_662, 1_123);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder34.insertDebugMarker('\u{1f664}');
} catch {}
try {
gpuCanvasContext6.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
} catch {}
let bindGroup261 = device0.createBindGroup({
  layout: bindGroupLayout38,
  entries: [
    {binding: 222, resource: {buffer: buffer189, offset: 0, size: 4}},
    {binding: 396, resource: {buffer: buffer48, offset: 0, size: 76}},
    {binding: 116, resource: {buffer: buffer263, offset: 256}},
    {binding: 75, resource: textureView77},
    {binding: 208, resource: {buffer: buffer62, offset: 4096, size: 100}},
    {binding: 209, resource: {buffer: buffer79, offset: 1024, size: 404}},
    {binding: 15, resource: textureView260},
    {binding: 158, resource: externalTexture9},
    {binding: 166, resource: {buffer: buffer231, offset: 2816, size: 633}},
    {binding: 131, resource: sampler255},
    {binding: 752, resource: {buffer: buffer315, offset: 2304, size: 537}},
  ],
});
let textureView421 = texture82.createView({dimension: '2d-array', format: 'astc-5x5-unorm'});
try {
computePassEncoder229.setBindGroup(0, bindGroup2);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroupsIndirect(buffer26, 1_232); };
} catch {}
try {
renderPassEncoder27.setBindGroup(2, bindGroup209, new Uint32Array(1195), 565, 0);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer58, 'uint16', 62, 55);
} catch {}
try {
querySet51.destroy();
} catch {}
try {
computePassEncoder1.popDebugGroup();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 12, depthOrArrayLayers: 26}
*/
{
  source: videoFrame53,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture321,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
window.someLabel = texture281.label;
} catch {}
let buffer335 = device0.createBuffer({
  size: 1722,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
{ clearResourceUsages(device0, computePassEncoder188); computePassEncoder188.dispatchWorkgroups(1, 2, 1); };
} catch {}
try {
computePassEncoder42.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup35, new Uint32Array(4346), 896, 0);
} catch {}
try {
renderPassEncoder21.setViewport(405.70299207031564, 0.9314435379098245, 160.85514742210572, 0.00933480286050311, 0.2641955814258702, 0.68610285669333);
} catch {}
document.body.prepend(video2);
let buffer336 = device0.createBuffer({size: 2089, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView422 = texture4.createView({label: '\u0c6a\u0bc0\u3bc3\ub6af\u6449\u004b\ueb9d\u0ec0', aspect: 'all'});
let renderBundleEncoder63 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder144.setBindGroup(3, bindGroup209);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup112);
} catch {}
try {
renderPassEncoder39.setBindGroup(1, bindGroup53, new Uint32Array(2558), 404, 0);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle5]);
} catch {}
try {
renderBundleEncoder63.setIndexBuffer(buffer307, 'uint16', 68, 55);
} catch {}
try {
renderBundleEncoder63.setVertexBuffer(5, buffer277, 1_012, 1_035);
} catch {}
try {
device0.queue.writeBuffer(buffer92, 96, new Int16Array(3789), 152, 156);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 47, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(462).fill(46), /* required buffer size: 462 */
{offset: 462}, {width: 153, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext26 = canvas18.getContext('webgpu');
try {
computePassEncoder31.setBindGroup(0, bindGroup205);
} catch {}
try {
computePassEncoder198.setBindGroup(2, bindGroup183, new Uint32Array(397), 38, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer116, 76); };
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(34);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder63.setIndexBuffer(buffer298, 'uint32', 80, 20);
} catch {}
let textureView423 = texture23.createView({});
let renderBundleEncoder64 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true});
let sampler293 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 8.352,
  lodMaxClamp: 95.17,
  maxAnisotropy: 1,
});
try {
computePassEncoder200.setBindGroup(2, bindGroup49, new Uint32Array(534), 36, 0);
} catch {}
try {
renderPassEncoder34.setBindGroup(1, bindGroup54);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup177, new Uint32Array(368), 20, 0);
} catch {}
try {
renderBundleEncoder64.setBindGroup(3, bindGroup146, new Uint32Array(3616), 238, 0);
} catch {}
let pipeline27 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule8,
  constants: {},
  targets: [{format: 'r16float', writeMask: 0}, {format: 'rg16sint'}],
},
  vertex: {
    module: shaderModule19,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 92,
        attributes: [
          {format: 'uint32x3', offset: 40, shaderLocation: 15},
          {format: 'sint32x3', offset: 28, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32'},
});
let buffer337 = device0.createBuffer({
  label: '\u8f72\u9cc9\u0163\ue0ba\u{1fa66}\uab54\u8e5b\u{1f605}',
  size: 1754,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let querySet58 = device0.createQuerySet({type: 'occlusion', count: 465});
let textureView424 = texture360.createView({dimension: 'cube', baseArrayLayer: 3});
let renderBundle63 = renderBundleEncoder64.finish({});
try {
computePassEncoder203.setBindGroup(0, bindGroup127, new Uint32Array(144), 25, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder48.setViewport(30.865266974061846, 7.270945594359871, 2.4559059857979264, 1.362886489214767, 0.2818592744878585, 0.6042652996436145);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder63.setIndexBuffer(buffer302, 'uint32', 32, 80);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
document.body.append(img7);
let buffer338 = device0.createBuffer({
  size: 3076,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture429 = device0.createTexture({
  label: '\u09cf\u056c\uaca7\u084c\u{1f8ef}\ufdb5\u1127\ufc27\u6c14\u4dbd',
  size: [9],
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder13.setBindGroup(1, bindGroup78, new Uint32Array(362), 29, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer51, 964); };
} catch {}
try {
renderBundleEncoder63.setBindGroup(3, bindGroup29, new Uint32Array(505), 66, 0);
} catch {}
try {
renderBundleEncoder63.setIndexBuffer(buffer104, 'uint32', 64, 413);
} catch {}
try {
renderBundleEncoder63.setVertexBuffer(7, buffer79);
} catch {}
let arrayBuffer58 = buffer81.getMappedRange(0, 12);
let promise66 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas12);
let buffer339 = device0.createBuffer({size: 3129, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let textureView425 = texture11.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder39.setBindGroup(0, bindGroup37, new Uint32Array(212), 24, 0);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer160, 'uint16', 2_446, 1_647);
} catch {}
try {
buffer200.unmap();
} catch {}
try {
computePassEncoder156.pushDebugGroup('\u{1f867}');
} catch {}
document.body.append(img9);
let buffer340 = device0.createBuffer({size: 4308, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true});
let sampler294 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 49.69,
  lodMaxClamp: 66.74,
  maxAnisotropy: 10,
});
try {
computePassEncoder181.setBindGroup(0, bindGroup164, new Uint32Array(2043), 55, 0);
} catch {}
try {
renderPassEncoder39.executeBundles([renderBundle5, renderBundle42, renderBundle23, renderBundle58, renderBundle23, renderBundle6, renderBundle6, renderBundle17, renderBundle0]);
} catch {}
try {
renderPassEncoder39.setScissorRect(28, 0, 60, 0);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder63.setBindGroup(0, bindGroup10, new Uint32Array(647), 19, 0);
} catch {}
try {
computePassEncoder85.setBindGroup(3, bindGroup29);
} catch {}
try {
renderPassEncoder47.setBindGroup(2, bindGroup98, new Uint32Array(3089), 494, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer83, 5360, new BigUint64Array(44535), 1653, 64);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture123,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(105).fill(242), /* required buffer size: 105 */
{offset: 105, bytesPerRow: 191}, {width: 73, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer54.detached) { new Uint8Array(arrayBuffer54).fill(0x55); };
} catch {}
await gc();
let bindGroup262 = device0.createBindGroup({layout: bindGroupLayout24, entries: [{binding: 425, resource: textureView196}]});
let renderBundleEncoder65 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'rg32float', 'rgba16sint'], stencilReadOnly: true});
let renderBundle64 = renderBundleEncoder65.finish({});
let sampler295 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 51.26,
  maxAnisotropy: 11,
});
try {
renderPassEncoder15.setBindGroup(2, bindGroup70);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer211, 'uint32', 208, 97);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 48}
*/
{
  source: videoFrame32,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture220,
  mipLevel: 0,
  origin: {x: 9, y: 1, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup263 = device0.createBindGroup({
  layout: bindGroupLayout44,
  entries: [
    {binding: 27, resource: {buffer: buffer86, offset: 1280, size: 1542}},
    {binding: 116, resource: textureView115},
  ],
});
try {
renderPassEncoder30.setBindGroup(1, bindGroup243);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(7, buffer138);
} catch {}
try {
renderBundleEncoder63.setBindGroup(1, bindGroup134);
} catch {}
try {
renderBundleEncoder63.setVertexBuffer(4, buffer238, 1_428, 684);
} catch {}
try {
gpuCanvasContext18.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let renderBundle65 = renderBundleEncoder63.finish({});
try {
computePassEncoder40.setBindGroup(3, bindGroup218);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer167, 1_340); };
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup116, new Uint32Array(205), 29, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 16}
*/
{
  source: videoFrame22,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer97, 8_392); };
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle0, renderBundle58, renderBundle50, renderBundle42]);
} catch {}
try {
renderPassEncoder33.setPipeline(pipeline25);
} catch {}
let buffer341 = device0.createBuffer({
  label: '\u71f0\u50af\u0ed1\u0954\u50f3\u86a6\u0754\u{1f9a0}\u791d\u36bd\u610e',
  size: 5487,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let sampler296 = device0.createSampler({
  label: '\u{1fa7f}\u0ac5\ucb4a\u8c41\u0c45\u{1fd0d}\u{1f621}\u9556\u0df4\u{1f7e6}',
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 28.24,
  lodMaxClamp: 90.40,
});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 78, height: 132, depthOrArrayLayers: 31}
*/
{
  source: imageBitmap0,
  origin: { x: 8, y: 24 },
  flipY: true,
}, {
  texture: texture93,
  mipLevel: 0,
  origin: {x: 0, y: 10, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 42, height: 5, depthOrArrayLayers: 0});
} catch {}
let imageData60 = new ImageData(40, 4);
let bindGroupLayout57 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 112,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
  ],
});
let texture430 = device0.createTexture({
  size: {width: 72},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder57.setBindGroup(3, bindGroup223, new Uint32Array(766), 285, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup57);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer144, 'uint16', 1_708, 30);
} catch {}
try {
computePassEncoder156.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer109, 3224, new Int16Array(2455), 236, 1080);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 9, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageData57,
  origin: { x: 16, y: 2 },
  flipY: true,
}, {
  texture: texture405,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 4, depthOrArrayLayers: 0});
} catch {}
let textureView426 = texture430.createView({label: '\ud117\u2b57\u{1fa02}'});
let textureView427 = texture358.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder66 = device0.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true});
try {
computePassEncoder32.setBindGroup(0, bindGroup25, new Uint32Array(1342), 310, 0);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle17, renderBundle17, renderBundle42]);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder66.setBindGroup(2, bindGroup19);
} catch {}
try {
renderBundleEncoder66.setPipeline(pipeline23);
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture420,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(131).fill(161), /* required buffer size: 131 */
{offset: 131}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
video0.width = 16;
let pipelineLayout33 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView428 = texture118.createView({label: '\u8e38\u{1fe64}\ueecc'});
let renderBundle66 = renderBundleEncoder66.finish({});
let sampler297 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 66.60,
  lodMaxClamp: 78.63,
});
try {
computePassEncoder74.setBindGroup(3, bindGroup197, new Uint32Array(222), 83, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer94, 200); };
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup128);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline25);
} catch {}
try {
computePassEncoder153.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder40.setBindGroup(1, bindGroup60, new Uint32Array(434), 27, 0);
} catch {}
try {
renderPassEncoder50.setIndexBuffer(buffer321, 'uint32', 588, 612);
} catch {}
document.body.append(canvas6);
try {
  await adapter0.requestAdapterInfo();
} catch {}
try {
renderPassEncoder49.setBindGroup(1, bindGroup254);
} catch {}
try {
renderPassEncoder24.end();
} catch {}
try {
renderPassEncoder47.setVertexBuffer(2, buffer282);
} catch {}
let bindGroup264 = device0.createBindGroup({
  label: '\u2bd6\u503d\u0c9f\u7ff4\u0564\u04de\u0054\u009a\u11ae\u5da7',
  layout: bindGroupLayout55,
  entries: [{binding: 439, resource: textureView287}],
});
let textureView429 = texture410.createView({dimension: '2d-array'});
let sampler298 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 74.20,
  lodMaxClamp: 84.97,
  maxAnisotropy: 17,
});
try {
renderPassEncoder30.setBindGroup(0, bindGroup47, []);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
gpuCanvasContext17.unconfigure();
} catch {}
let texture431 = device0.createTexture({
  size: {width: 144, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder54.setBindGroup(0, bindGroup132);
} catch {}
try {
computePassEncoder20.setBindGroup(2, bindGroup23, new Uint32Array(2713), 469, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(2, bindGroup71);
} catch {}
try {
renderPassEncoder37.setViewport(1.9166444764421122, 13.43781842789095, 6.975730633409823, 0.08025165178233944, 0.5692221503056938, 0.7464282097769444);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame70,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture123,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData61 = new ImageData(60, 84);
try {
{ clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroups(3); };
} catch {}
try {
renderPassEncoder27.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder40.setBindGroup(1, bindGroup71, new Uint32Array(532), 90, 0);
} catch {}
document.body.append(img6);
try {
computePassEncoder156.setBindGroup(2, bindGroup199, new Uint32Array(2653), 627, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder130); computePassEncoder130.dispatchWorkgroups(2, 1); };
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline25);
} catch {}
let bindGroup265 = device0.createBindGroup({
  layout: bindGroupLayout50,
  entries: [{binding: 209, resource: {buffer: buffer259, offset: 0, size: 132}}],
});
let textureView430 = texture404.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder34.setBindGroup(0, bindGroup59, new Uint32Array(1921), 161, 0);
} catch {}
try {
renderPassEncoder48.executeBundles([renderBundle7, renderBundle5, renderBundle38, renderBundle6, renderBundle10, renderBundle38]);
} catch {}
let arrayBuffer59 = buffer104.getMappedRange(6024, 736);
try {
gpuCanvasContext24.unconfigure();
} catch {}
try {
  await promise66;
} catch {}
document.body.append(img6);
let bindGroup266 = device0.createBindGroup({
  label: '\ud6df\uc254\u9f46\ua7c0\u4294\u93be\u{1fe1d}',
  layout: bindGroupLayout40,
  entries: [
    {binding: 25, resource: textureView162},
    {binding: 263, resource: {buffer: buffer139, offset: 512, size: 1312}},
    {binding: 16, resource: {buffer: buffer57, offset: 0, size: 204}},
    {binding: 94, resource: {buffer: buffer279, offset: 1536}},
  ],
});
let textureView431 = texture430.createView({baseArrayLayer: 0});
try {
computePassEncoder10.setBindGroup(3, bindGroup70);
} catch {}
try {
renderPassEncoder47.setBindGroup(3, bindGroup82, new Uint32Array(317), 47, 0);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer218, 'uint32', 336, 1_240);
} catch {}
try {
gpuCanvasContext23.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let promise67 = adapter0.requestAdapterInfo();
let buffer342 = device0.createBuffer({
  size: 10943,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture432 = device0.createTexture({
  size: {width: 78, height: 132, depthOrArrayLayers: 132},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView432 = texture243.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder102.setBindGroup(2, bindGroup59, new Uint32Array(2459), 235, 0);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(3, buffer191);
} catch {}
let arrayBuffer60 = buffer47.getMappedRange(1008, 5368);
let promise68 = device0.queue.onSubmittedWorkDone();
document.body.append(canvas7);
let bindGroup267 = device0.createBindGroup({layout: bindGroupLayout41, entries: [{binding: 87, resource: textureView323}]});
let textureView433 = texture242.createView({mipLevelCount: 1, baseArrayLayer: 15, arrayLayerCount: 3});
try {
computePassEncoder57.setBindGroup(0, bindGroup202, new Uint32Array(3569), 116, 0);
} catch {}
let arrayBuffer61 = buffer136.getMappedRange();
try {
renderPassEncoder49.insertDebugMarker('\u{1fec4}');
} catch {}
try {
device0.queue.writeBuffer(buffer279, 140, new BigUint64Array(16321), 1099, 344);
} catch {}
await gc();
let textureView434 = texture281.createView({dimension: '1d', baseArrayLayer: 0, arrayLayerCount: 1});
try {
computePassEncoder149.setBindGroup(2, bindGroup14);
} catch {}
try {
renderPassEncoder48.setBindGroup(0, bindGroup257);
} catch {}
try {
renderPassEncoder39.executeBundles([renderBundle17]);
} catch {}
try {
buffer145.unmap();
} catch {}
try {
gpuCanvasContext19.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture335,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(148).fill(139), /* required buffer size: 148 */
{offset: 148}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise69 = device0.queue.onSubmittedWorkDone();
let imageData62 = new ImageData(92, 68);
let texture433 = device0.createTexture({
  size: [39],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder114.setBindGroup(0, bindGroup127);
} catch {}
try {
renderPassEncoder49.setVertexBuffer(6, buffer256, 0, 1_253);
} catch {}
try {
computePassEncoder174.pushDebugGroup('\uf8f5');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 420, height: 1, depthOrArrayLayers: 3}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture173,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
try {
computePassEncoder9.setBindGroup(2, bindGroup267, new Uint32Array(4714), 452, 0);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder48.setVertexBuffer(7, buffer12, 9_056, 5_677);
} catch {}
try {
device0.queue.writeBuffer(buffer151, 100, new DataView(new ArrayBuffer(9311)), 2066, 104);
} catch {}
try {
adapter0.label = '\u{1fcab}\u{1f71e}';
} catch {}
let sampler299 = device0.createSampler({
  label: '\ueb6c\u62ec\u39fe\u590e\uea76\ue9ff\u8c6e\u{1fe4a}\uc367\u0d23',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 70.61,
  lodMaxClamp: 78.91,
});
try {
renderPassEncoder30.executeBundles([renderBundle20, renderBundle50]);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline25);
} catch {}
try {
device0.queue.writeBuffer(buffer271, 832, new Int16Array(512), 141, 20);
} catch {}
let sampler300 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 97.35,
  compare: 'less-equal',
  maxAnisotropy: 1,
});
try {
computePassEncoder90.setBindGroup(3, bindGroup267, new Uint32Array(4477), 881, 0);
} catch {}
try {
renderPassEncoder39.setBindGroup(2, bindGroup220, new Uint32Array(4403), 453, 0);
} catch {}
try {
renderPassEncoder49.setVertexBuffer(0, undefined, 251_611_550);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let bindGroupLayout58 = pipeline12.getBindGroupLayout(0);
let texture434 = device0.createTexture({
  size: [78],
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView435 = texture247.createView({label: '\uc735\u0105\u481b\u287e', dimension: '2d-array'});
try {
{ clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer341, 2_480); };
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer60, 'uint32', 1_508, 232);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer64, 2264, new Int16Array(12150), 1256, 1692);
} catch {}
let sampler301 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 16.46,
  lodMaxClamp: 99.67,
});
try {
renderPassEncoder39.setIndexBuffer(buffer333, 'uint16', 250, 488);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline25);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let sampler302 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 17.98,
  maxAnisotropy: 14,
});
let externalTexture65 = device0.importExternalTexture({source: videoFrame18});
try {
renderPassEncoder30.setVertexBuffer(5, buffer115, 0);
} catch {}
let buffer343 = device0.createBuffer({size: 19476, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let texture435 = device0.createTexture({
  size: {width: 9, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let sampler303 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 7.757,
  lodMaxClamp: 99.43,
});
try {
computePassEncoder111.setBindGroup(2, bindGroup190);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup221);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle50, renderBundle38]);
} catch {}
try {
buffer241.unmap();
} catch {}
try {
computePassEncoder174.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer19, 48, new DataView(new ArrayBuffer(3329)), 1385, 12);
} catch {}
document.body.prepend(canvas15);
let sampler304 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 69.38,
  lodMaxClamp: 92.19,
});
try {
renderPassEncoder23.setBlendConstant({ r: 171.3, g: 352.7, b: -588.8, a: -133.8, });
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer42, 'uint32', 3_040, 3_648);
} catch {}
let promise70 = device0.queue.onSubmittedWorkDone();
let buffer344 = device0.createBuffer({size: 11272, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder192.setBindGroup(3, bindGroup250);
} catch {}
try {
computePassEncoder91.setBindGroup(1, bindGroup124, new Uint32Array(3519), 194, 0);
} catch {}
try {
renderPassEncoder49.setBindGroup(0, bindGroup113);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer109, 'uint32', 2_180, 1_002);
} catch {}
try {
renderPassEncoder49.setPipeline(pipeline25);
} catch {}
let promise71 = device0.queue.onSubmittedWorkDone();
let buffer345 = device0.createBuffer({size: 65536, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture436 = device0.createTexture({size: [288], dimension: '1d', format: 'rg16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder172.setBindGroup(1, bindGroup57, new Uint32Array(6944), 83, 0);
} catch {}
try {
renderPassEncoder37.end();
} catch {}
await gc();
let buffer346 = device0.createBuffer({
  size: 2408,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture437 = device0.createTexture({
  size: {width: 78, height: 132, depthOrArrayLayers: 162},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler305 = device0.createSampler({addressModeW: 'clamp-to-edge', magFilter: 'nearest', lodMinClamp: 66.66, lodMaxClamp: 91.22});
try {
{ clearResourceUsages(device0, computePassEncoder130); computePassEncoder130.dispatchWorkgroupsIndirect(buffer57, 556); };
} catch {}
let buffer347 = device0.createBuffer({
  size: 2010,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let texture438 = device0.createTexture({
  size: [39, 66, 1],
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler306 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMinClamp: 93.09,
  lodMaxClamp: 94.33,
  maxAnisotropy: 1,
});
try {
renderPassEncoder27.setBindGroup(3, bindGroup254);
} catch {}
try {
gpuCanvasContext12.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroupLayout59 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 26,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {binding: 324, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 65,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 57,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer348 = device0.createBuffer({
  size: 14684,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let textureView436 = texture198.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let texture439 = device0.createTexture({
  size: [420, 1, 1],
  mipLevelCount: 5,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder48.setBindGroup(0, bindGroup178);
} catch {}
try {
renderPassEncoder49.setViewport(172.5449699645294, 88.48659751980489, 24.68798879400727, 0.9507800960154914, 0.19943491997226015, 0.4528216190923229);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(1, undefined);
} catch {}
try {
renderPassEncoder50.insertDebugMarker('\u16da');
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroup268 = device0.createBindGroup({
  layout: bindGroupLayout18,
  entries: [
    {binding: 178, resource: sampler142},
    {binding: 209, resource: textureView10},
    {binding: 8, resource: textureView227},
    {binding: 58, resource: sampler281},
    {binding: 386, resource: sampler281},
    {binding: 301, resource: {buffer: buffer347, offset: 0, size: 156}},
    {binding: 245, resource: textureView287},
    {binding: 52, resource: sampler80},
    {binding: 839, resource: {buffer: buffer35, offset: 0, size: 604}},
    {binding: 142, resource: textureView172},
    {binding: 27, resource: {buffer: buffer171, offset: 4864, size: 496}},
    {binding: 6, resource: {buffer: buffer174, offset: 1792}},
    {binding: 296, resource: textureView14},
    {binding: 32, resource: textureView160},
    {binding: 304, resource: externalTexture55},
    {binding: 698, resource: textureView330},
    {binding: 192, resource: textureView69},
    {binding: 7, resource: sampler125},
    {binding: 55, resource: sampler43},
    {binding: 65, resource: textureView115},
    {binding: 99, resource: textureView422},
    {binding: 119, resource: {buffer: buffer221, offset: 0, size: 300}},
    {binding: 82, resource: {buffer: buffer40, offset: 1280}},
    {binding: 28, resource: textureView398},
    {binding: 810, resource: {buffer: buffer179, offset: 3072, size: 401}},
    {binding: 150, resource: textureView84},
    {binding: 225, resource: sampler150},
    {binding: 125, resource: sampler162},
    {binding: 380, resource: textureView92},
    {binding: 77, resource: externalTexture26},
    {binding: 102, resource: {buffer: buffer258, offset: 3328}},
    {binding: 598, resource: {buffer: buffer288, offset: 0, size: 628}},
    {binding: 171, resource: textureView141},
    {binding: 90, resource: {buffer: buffer315, offset: 1280, size: 3505}},
    {binding: 56, resource: {buffer: buffer291, offset: 0, size: 124}},
    {binding: 220, resource: sampler224},
    {binding: 0, resource: externalTexture5},
    {binding: 15, resource: textureView186},
    {binding: 277, resource: textureView196},
    {binding: 113, resource: textureView9},
    {binding: 132, resource: {buffer: buffer206, offset: 768, size: 5357}},
    {binding: 308, resource: externalTexture24},
    {binding: 196, resource: {buffer: buffer26, offset: 768, size: 636}},
    {binding: 152, resource: {buffer: buffer128, offset: 2816, size: 56}},
    {binding: 62, resource: {buffer: buffer271, offset: 256, size: 688}},
    {binding: 91, resource: {buffer: buffer162, offset: 512, size: 1717}},
    {binding: 114, resource: textureView288},
    {binding: 203, resource: textureView128},
    {binding: 566, resource: {buffer: buffer57, offset: 0}},
    {binding: 249, resource: sampler143},
    {binding: 50, resource: {buffer: buffer191, offset: 1024, size: 199}},
    {binding: 66, resource: textureView299},
  ],
});
let buffer349 = device0.createBuffer({size: 16510, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
try {
renderPassEncoder23.setBindGroup(2, bindGroup213);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline25);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture347,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 10},
  aspect: 'all',
}, new Uint8Array(3_472).fill(204), /* required buffer size: 3_472 */
{offset: 31, bytesPerRow: 37, rowsPerImage: 18}, {width: 0, height: 4, depthOrArrayLayers: 6});
} catch {}
videoFrame0.close();
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame5.close();
videoFrame6.close();
videoFrame7.close();
videoFrame8.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
videoFrame18.close();
videoFrame20.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
videoFrame27.close();
videoFrame29.close();
videoFrame30.close();
videoFrame31.close();
videoFrame32.close();
videoFrame34.close();
videoFrame35.close();
videoFrame36.close();
videoFrame37.close();
videoFrame38.close();
videoFrame40.close();
videoFrame41.close();
videoFrame42.close();
videoFrame44.close();
videoFrame45.close();
videoFrame46.close();
videoFrame47.close();
videoFrame48.close();
videoFrame49.close();
videoFrame50.close();
videoFrame51.close();
videoFrame52.close();
videoFrame53.close();
videoFrame54.close();
videoFrame55.close();
videoFrame56.close();
videoFrame57.close();
videoFrame59.close();
videoFrame60.close();
videoFrame61.close();
videoFrame62.close();
videoFrame63.close();
videoFrame64.close();
videoFrame65.close();
videoFrame66.close();
videoFrame68.close();
videoFrame69.close();
videoFrame70.close();
videoFrame71.close();
videoFrame72.close();
videoFrame74.close();
videoFrame75.close();
videoFrame76.close();
videoFrame77.close();
videoFrame78.close();
videoFrame79.close();
videoFrame80.close();
  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>