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

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

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

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

const videoUrls = [

];

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

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

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

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

<script>
globalThis.testRunner?.dumpAsText();
globalThis.testRunner?.waitUntilDone();


async function window0() {
let promise0 = navigator.gpu.requestAdapter({});
let adapter0 = await promise0;
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth32float-stencil8',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'bgra8unorm-storage',
    'float32-blendable',
    'timestamp-query',
  ],
  requiredLimits: {
    maxColorAttachmentBytesPerSample: 32,
    maxVertexBufferArrayStride: 2048,
    maxUniformBufferBindingSize: 16486917,
    maxStorageBufferBindingSize: 158762234,
  },
});
let commandEncoder0 = device0.createCommandEncoder({});
let computePassEncoder0 = commandEncoder0.beginComputePass();
let imageData0 = new ImageData(8, 8);
let buffer0 = device0.createBuffer({size: 44, usage: GPUBufferUsage.INDEX});
let sampler0 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat'});
let buffer1 = device0.createBuffer({size: 232, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE, mappedAtCreation: false});
let texture0 = device0.createTexture({
  size: [142, 16, 66],
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 28, y: 5, z: 3},
  aspect: 'all',
}, new Uint8Array(6_509).fill(137), /* required buffer size: 6_509 */
{offset: 47, bytesPerRow: 218, rowsPerImage: 26}, {width: 35, height: 4, depthOrArrayLayers: 2});
} catch {}
let sampler1 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'clamp-to-edge', lodMaxClamp: 99.85});
let textureView0 = texture0.createView({dimension: '2d', baseArrayLayer: 13});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({
  colorFormats: ['rgba32float'],
  depthStencilFormat: 'depth32float',
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle0 = renderBundleEncoder0.finish({});
let promise1 = device0.queue.onSubmittedWorkDone();
let img0 = await imageWithData(34, 17, '#10101010', '#20202020');
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'bt470bg', transfer: 'hlg'} });
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let textureView1 = texture0.createView({dimension: '2d', baseArrayLayer: 17});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let bindGroup0 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture0}]});
let texture1 = device0.createTexture({
  size: {width: 1360, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'astc-8x6-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setBindGroup(1, bindGroup0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32uint', access: 'write-only', viewDimension: '2d' },
    },
    {binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 17, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 33,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 47,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 54,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 55,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 65,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 140,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 189,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 211, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 244,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 247,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 277,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 286, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 394,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 426,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let bindGroup1 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture0}]});
let texture2 = device0.createTexture({
  size: {width: 1020, height: 428, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture3 = device0.createTexture({
  size: [280, 1, 71],
  mipLevelCount: 5,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView2 = texture0.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 14});
try {
computePassEncoder0.setBindGroup(2, bindGroup0);
} catch {}
await gc();
let imageData1 = new ImageData(28, 72);
let texture4 = device0.createTexture({
  size: [71],
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  label: '\u718d\u0e9f\u2881\u4a3e\u01df\u0ec5\u005b\u{1ff2b}',
  entries: [
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let texture5 = device0.createTexture({
  size: [2240, 1, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let querySet0 = device0.createQuerySet({type: 'timestamp', count: 298});
let textureView3 = texture1.createView({format: 'astc-8x6-unorm', mipLevelCount: 1});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({
  colorFormats: ['rgba32float'],
  depthStencilFormat: 'depth32float',
  sampleCount: 4,
  depthReadOnly: false,
  stencilReadOnly: true,
});
let renderBundle1 = renderBundleEncoder1.finish({});
try {
computePassEncoder0.setBindGroup(1, bindGroup1);
} catch {}
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let buffer2 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 522});
let textureView4 = texture2.createView({});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthStencilFormat: 'depth32float', sampleCount: 4});
let sampler2 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  lodMaxClamp: 90.89,
  compare: 'never',
});
try {
computePassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(892), 126, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer0, 'uint16', 6, 2);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(3, buffer2, 0, 4);
} catch {}
let bindGroup2 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture0}]});
let buffer3 = device0.createBuffer({size: 444, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let textureView5 = texture4.createView({baseArrayLayer: 0});
try {
computePassEncoder0.setBindGroup(0, bindGroup1);
} catch {}
try {
renderBundleEncoder2.setBindGroup(3, bindGroup1, []);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise1;
} catch {}
try {
adapter0.label = '\u48c5\u9656\u0497\u022d\u0ede\u{1f905}\u5552\ubf32\u{1f6a5}';
} catch {}
let buffer4 = device0.createBuffer({
  label: '\uce00\u3cf3\u0fe9\ud5e1\u3f75',
  size: 8,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
});
let commandEncoder1 = device0.createCommandEncoder({});
let texture6 = device0.createTexture({
  size: [1020, 428, 24],
  sampleCount: 1,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView6 = texture2.createView({});
let computePassEncoder1 = commandEncoder1.beginComputePass();
try {
computePassEncoder0.setBindGroup(3, bindGroup1);
} catch {}
let texture7 = device0.createTexture({
  size: [2240],
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView7 = texture5.createView({});
let renderBundle2 = renderBundleEncoder2.finish({});
try {
computePassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder1.setBindGroup(3, bindGroup2, new Uint32Array(170), 10, 0);
} catch {}
let commandEncoder2 = device0.createCommandEncoder();
let textureView8 = texture6.createView({arrayLayerCount: 1});
let computePassEncoder2 = commandEncoder2.beginComputePass({timestampWrites: {querySet: querySet0}});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]});
let commandEncoder3 = device0.createCommandEncoder({});
let texture8 = device0.createTexture({
  size: {width: 127},
  dimension: '1d',
  format: 'rg8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler3 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
globalThis.someLabel = texture7.label;
} catch {}
let texture9 = device0.createTexture({
  size: [256],
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture10 = device0.createTexture({size: [35, 4, 10], dimension: '2d', format: 'depth32float', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView9 = texture6.createView({mipLevelCount: 1});
let sampler4 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', lodMinClamp: 69.13, lodMaxClamp: 86.52});
try {
device0.label = '\u4ba3\ucb39\u09ef\u0d53\u0342';
} catch {}
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let buffer5 = device0.createBuffer({size: 280, usage: GPUBufferUsage.STORAGE, mappedAtCreation: false});
let textureView10 = texture8.createView({});
let texture11 = device0.createTexture({
  size: [510, 214, 1],
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
commandEncoder3.insertDebugMarker('\u9edd');
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let querySet2 = device0.createQuerySet({type: 'timestamp', count: 644});
let textureView11 = texture7.createView({baseMipLevel: 0});
try {
computePassEncoder1.setBindGroup(2, bindGroup0);
} catch {}
let buffer6 = device0.createBuffer({size: 470, usage: GPUBufferUsage.COPY_SRC});
let texture12 = device0.createTexture({
  size: {width: 71},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture13 = device0.createTexture({
  size: {width: 560, height: 1, depthOrArrayLayers: 53},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView12 = texture13.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 11});
await gc();
let texture14 = device0.createTexture({
  size: [2240],
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView13 = texture0.createView({baseArrayLayer: 8, arrayLayerCount: 16});
document.body.append(img0);
try {
globalThis.someLabel = computePassEncoder0.label;
} catch {}
let bindGroup3 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 5, resource: externalTexture0}]});
let commandEncoder4 = device0.createCommandEncoder({});
let textureView14 = texture12.createView({mipLevelCount: 1});
let texture15 = device0.createTexture({
  size: [560, 1, 488],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder2.setBindGroup(0, bindGroup2, new Uint32Array(9904), 771, 0);
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
try {
adapter0.label = '\u6133\ufd8d\u{1fb31}\u{1ff68}\u83e2\u4e5e\ua0fc\u9969\ub712';
} catch {}
let bindGroup4 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture0}]});
let commandEncoder5 = device0.createCommandEncoder({});
let texture16 = device0.createTexture({
  size: [280, 1, 1],
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder1.setBindGroup(2, bindGroup0, new Uint32Array(360), 26, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 19},
  aspect: 'all',
}, new Uint8Array(15_350).fill(99), /* required buffer size: 15_350 */
{offset: 102, bytesPerRow: 953, rowsPerImage: 4}, {width: 56, height: 0, depthOrArrayLayers: 5});
} catch {}
let commandEncoder6 = device0.createCommandEncoder({});
let textureView15 = texture7.createView({});
let sampler5 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat'});
let imageData2 = new ImageData(64, 64);
let commandEncoder7 = device0.createCommandEncoder({});
try {
buffer1.unmap();
} catch {}
try {
  await promise2;
} catch {}
let textureView16 = texture4.createView({});
let textureView17 = texture16.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder3 = commandEncoder3.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 110, endOfPassWriteIndex: 80}});
let querySet3 = device0.createQuerySet({type: 'timestamp', count: 1089});
let texture17 = device0.createTexture({
  size: {width: 71},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture18 = device0.createTexture({
  size: [2240, 1, 17],
  mipLevelCount: 5,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder4 = commandEncoder5.beginComputePass();
try {
computePassEncoder4.setBindGroup(2, bindGroup0);
} catch {}
document.body.prepend(img0);
let commandEncoder8 = device0.createCommandEncoder({});
let texture19 = device0.createTexture({
  size: {width: 127},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder4.setBindGroup(2, bindGroup0);
} catch {}
let bindGroup5 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture0}]});
let textureView18 = texture5.createView({});
try {
computePassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
try {
  await promise3;
} catch {}
let buffer7 = device0.createBuffer({size: 529, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandBuffer0 = commandEncoder8.finish({});
let texture20 = device0.createTexture({
  size: [256],
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder5 = commandEncoder4.beginComputePass();
try {
commandEncoder6.resolveQuerySet(querySet2, 128, 0, buffer7, 0);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'smpte240m'} });
try {
globalThis.someLabel = externalTexture0.label;
} catch {}
let bindGroup6 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture0}]});
let commandEncoder9 = device0.createCommandEncoder({});
let texture21 = device0.createTexture({
  size: {width: 17},
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder6 = commandEncoder6.beginComputePass();
try {
computePassEncoder2.setBindGroup(2, bindGroup5, new Uint32Array(626), 174, 0);
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '1d' },
    },
  ],
});
let bindGroup7 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 5, resource: externalTexture0}]});
let commandEncoder10 = device0.createCommandEncoder({label: '\u9d1d\u{1ff55}\u9372\ua726\uc3f1\u55a5\u4db3'});
let textureView19 = texture0.createView({aspect: 'all', baseArrayLayer: 5, arrayLayerCount: 1});
let textureView20 = texture2.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder0.setBindGroup(3, bindGroup1, new Uint32Array(3687), 385, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 0,
  origin: {x: 161, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(35).fill(248), /* required buffer size: 35 */
{offset: 35}, {width: 33, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture22 = device0.createTexture({
  size: {width: 2240},
  dimension: '1d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder7 = commandEncoder9.beginComputePass();
try {
computePassEncoder6.setBindGroup(1, bindGroup1, new Uint32Array(1210), 451, 0);
} catch {}
let buffer8 = device0.createBuffer({size: 785, usage: GPUBufferUsage.COPY_SRC});
let textureView21 = texture10.createView({dimension: '2d'});
let texture23 = device0.createTexture({
  size: [280, 1, 5],
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let sampler6 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 94.44});
try {
computePassEncoder5.setBindGroup(0, bindGroup3, new Uint32Array(200), 46, 0);
} catch {}
let buffer9 = device0.createBuffer({label: '\u08e4\u4245', size: 15456, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let textureView22 = texture10.createView({dimension: '2d'});
let texture24 = device0.createTexture({
  size: [2240, 1, 96],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView23 = texture16.createView({mipLevelCount: 1});
let computePassEncoder8 = commandEncoder7.beginComputePass();
let sampler7 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 93.67,
});
try {
computePassEncoder8.setBindGroup(0, bindGroup4, []);
} catch {}
try {
  await promise4;
} catch {}
let textureView24 = texture22.createView({});
let computePassEncoder9 = commandEncoder10.beginComputePass();
try {
computePassEncoder8.setBindGroup(2, bindGroup6, new Uint32Array(1050), 272, 0);
} catch {}
try {
buffer9.unmap();
} catch {}
let buffer10 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_DST});
let textureView25 = texture0.createView({aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 2});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 280, height: 1, depthOrArrayLayers: 5}
*/
{
  source: imageData1,
  origin: { x: 10, y: 2 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup8 = device0.createBindGroup({
  label: '\u5822\u{1fd04}',
  layout: veryExplicitBindGroupLayout3,
  entries: [{binding: 0, resource: textureView16}],
});
let commandEncoder11 = device0.createCommandEncoder({});
let textureView26 = texture3.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 28});
let computePassEncoder10 = commandEncoder11.beginComputePass();
try {
computePassEncoder9.setBindGroup(3, bindGroup2, new Uint32Array(329), 8, 0);
} catch {}
document.body.append(img0);
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 370,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let bindGroup9 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 0, resource: textureView16}]});
let texture25 = device0.createTexture({
  size: [255, 107, 1],
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView27 = texture21.createView({});
let externalTexture1 = device0.importExternalTexture({label: '\u7e69\u2bcb\u{1fa66}\u0db7\u40d8\u0a82', source: videoFrame1});
try {
computePassEncoder1.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder8.setBindGroup(2, bindGroup9, new Uint32Array(1115), 831, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let texture26 = device0.createTexture({
  size: {width: 142, height: 16, depthOrArrayLayers: 12},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let sampler8 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMinClamp: 92.01, lodMaxClamp: 93.44});
try {
computePassEncoder1.setBindGroup(3, bindGroup9);
} catch {}
try {
computePassEncoder7.setBindGroup(1, bindGroup9, new Uint32Array(699), 85, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 280, height: 1, depthOrArrayLayers: 5}
*/
{
  source: imageData2,
  origin: { x: 2, y: 4 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer11 = device0.createBuffer({size: 44, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let texture27 = device0.createTexture({
  size: {width: 35, height: 4, depthOrArrayLayers: 36},
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder2.end();
} catch {}
try {
commandEncoder2.copyTextureToTexture({
  texture: texture20,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup10 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture1}]});
let computePassEncoder11 = commandEncoder2.beginComputePass();
try {
computePassEncoder6.setBindGroup(2, bindGroup2, new Uint32Array(1714), 1_171, 0);
} catch {}
try {
buffer7.unmap();
} catch {}
document.body.append(img0);
let buffer12 = device0.createBuffer({size: 73, usage: GPUBufferUsage.INDEX});
let textureView28 = texture18.createView({aspect: 'all', baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 5});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
  await promise5;
} catch {}
let querySet4 = device0.createQuerySet({type: 'timestamp', count: 922});
let bindGroup11 = device0.createBindGroup({layout: veryExplicitBindGroupLayout4, entries: [{binding: 370, resource: textureView24}]});
let buffer13 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder12 = device0.createCommandEncoder({});
let texture28 = device0.createTexture({
  size: {width: 510, height: 214, depthOrArrayLayers: 1},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder12 = commandEncoder12.beginComputePass();
try {
computePassEncoder1.setBindGroup(3, bindGroup0, []);
} catch {}
document.body.prepend(img0);
let bindGroup12 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 5, resource: externalTexture0}]});
let commandEncoder13 = device0.createCommandEncoder({});
let texture29 = device0.createTexture({
  size: {width: 71, height: 8, depthOrArrayLayers: 18},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView29 = texture29.createView({mipLevelCount: 1, arrayLayerCount: 5});
let computePassEncoder13 = commandEncoder13.beginComputePass();
try {
computePassEncoder5.setBindGroup(2, bindGroup11, new Uint32Array(264), 78, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'bt1361ExtendedColourGamut'} });
let bindGroup13 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture1}]});
let commandEncoder14 = device0.createCommandEncoder();
let sampler9 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 94.59});
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 44, new Uint32Array(10785), 2837, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup14 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 5, resource: externalTexture1}]});
let commandEncoder15 = device0.createCommandEncoder();
let computePassEncoder14 = commandEncoder15.beginComputePass({timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 680, endOfPassWriteIndex: 530}});
try {
computePassEncoder1.setBindGroup(2, bindGroup2);
} catch {}
await gc();
try {
computePassEncoder10.setBindGroup(3, bindGroup8, new Uint32Array(1268), 140, 0);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
commandEncoder14.copyBufferToBuffer(buffer13, 8, buffer10, 24, 56);
} catch {}
let textureView30 = texture14.createView({dimension: '1d'});
let computePassEncoder15 = commandEncoder14.beginComputePass();
try {
computePassEncoder9.setBindGroup(3, bindGroup6, new Uint32Array(1294), 78, 0);
} catch {}
document.body.prepend(img0);
let texture30 = device0.createTexture({
  size: {width: 255, height: 107, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView31 = texture3.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 2});
let sampler10 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.07,
  compare: 'greater-equal',
  maxAnisotropy: 2,
});
try {
computePassEncoder7.setBindGroup(3, bindGroup11, new Uint32Array(6022), 712, 0);
} catch {}
try {
computePassEncoder13.end();
} catch {}
let commandEncoder16 = device0.createCommandEncoder();
let computePassEncoder16 = commandEncoder16.beginComputePass();
try {
computePassEncoder15.setBindGroup(3, bindGroup9);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let computePassEncoder17 = commandEncoder13.beginComputePass();
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 283, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(31).fill(212), /* required buffer size: 31 */
{offset: 31, rowsPerImage: 92}, {width: 91, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u9d60\uba8d\uc626\u{1f9bc}\u0c31';
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '1d' },
    },
  ],
});
let commandEncoder18 = device0.createCommandEncoder({});
let computePassEncoder18 = commandEncoder17.beginComputePass();
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 1,
  origin: {x: 54, y: 0, z: 23},
  aspect: 'all',
}, new Uint8Array(38_617).fill(224), /* required buffer size: 38_617 */
{offset: 97, bytesPerRow: 642, rowsPerImage: 12}, {width: 38, height: 0, depthOrArrayLayers: 6});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer14 = device0.createBuffer({size: 224, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder19 = device0.createCommandEncoder({});
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 1640});
let textureView32 = texture17.createView({});
try {
computePassEncoder17.setBindGroup(1, bindGroup9, new Uint32Array(1068), 61, 0);
} catch {}
let commandBuffer1 = commandEncoder19.finish();
let computePassEncoder19 = commandEncoder18.beginComputePass();
try {
computePassEncoder9.setBindGroup(0, bindGroup1, new Uint32Array(43), 3, 0);
} catch {}
let bindGroup15 = device0.createBindGroup({layout: veryExplicitBindGroupLayout4, entries: [{binding: 370, resource: textureView27}]});
let texture31 = device0.createTexture({
  size: {width: 1020, height: 428, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView33 = texture19.createView({baseArrayLayer: 0});
await gc();
let offscreenCanvas0 = new OffscreenCanvas(372, 89);
try {
device0.queue.submit([commandBuffer1]);
} catch {}
let imageData3 = new ImageData(24, 24);
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt709', transfer: 'bt709'} });
try {
globalThis.someLabel = device0.queue.label;
} catch {}
let commandEncoder20 = device0.createCommandEncoder();
let computePassEncoder20 = commandEncoder20.beginComputePass();
let sampler11 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'clamp-to-edge', lodMaxClamp: 58.43});
let externalTexture2 = device0.importExternalTexture({label: '\u1ed5\u{1f6d9}\ue86f\ud079\u078d', source: videoFrame2});
try {
computePassEncoder19.setBindGroup(3, bindGroup1);
} catch {}
document.body.prepend(img0);
let buffer15 = device0.createBuffer({size: 224, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: true});
let sampler12 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.94,
  compare: 'greater-equal',
  maxAnisotropy: 12,
});
try {
computePassEncoder15.setBindGroup(0, bindGroup1);
} catch {}
try {
buffer7.unmap();
} catch {}
let commandEncoder21 = device0.createCommandEncoder({});
let texture32 = device0.createTexture({
  size: {width: 17},
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture33 = device0.createTexture({
  size: [127, 53, 1],
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder21 = commandEncoder21.beginComputePass({timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 4294967295}});
try {
computePassEncoder20.setBindGroup(1, bindGroup15, new Uint32Array(1082), 351, 0);
} catch {}
try {
computePassEncoder5.pushDebugGroup('\u5cc8');
} catch {}
document.body.append(img0);
let buffer16 = device0.createBuffer({size: 267, usage: GPUBufferUsage.INDIRECT});
let commandEncoder22 = device0.createCommandEncoder({});
let externalTexture3 = device0.importExternalTexture({source: videoFrame0});
let bindGroup16 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 5, resource: externalTexture3}]});
let commandEncoder23 = device0.createCommandEncoder();
let sampler13 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 92.65,
  lodMaxClamp: 93.69,
});
try {
computePassEncoder17.setBindGroup(1, bindGroup16, new Uint32Array(4640), 1_270, 0);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
let buffer17 = device0.createBuffer({size: 4, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder24 = device0.createCommandEncoder({});
try {
commandEncoder24.clearBuffer(buffer10);
} catch {}
document.body.append(img0);
let texture34 = device0.createTexture({
  size: [1020, 428, 1],
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({
  colorFormats: ['rgba32float'],
  depthStencilFormat: 'depth32float',
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder3.setBindGroup(0, bindGroup1, new Uint32Array(2003), 240, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer4, 'uint32', 0, 3);
} catch {}
let buffer18 = device0.createBuffer({size: 276, usage: GPUBufferUsage.INDIRECT});
let texture35 = device0.createTexture({
  size: {width: 510, height: 214, depthOrArrayLayers: 1},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder22 = commandEncoder22.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 94}});
try {
computePassEncoder12.setBindGroup(3, bindGroup10);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup5);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(0, buffer14, 0, 10);
} catch {}
try {
commandEncoder23.copyTextureToTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 13, y: 1, z: 8},
  aspect: 'all',
},
{
  texture: texture17,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder24.resolveQuerySet(querySet3, 266, 1, buffer7, 0);
} catch {}
try {
  await promise6;
} catch {}
try {
computePassEncoder7.setBindGroup(2, bindGroup13, new Uint32Array(864), 92, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup1);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(0, buffer3, 0);
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 296 */
  offset: 296,
  buffer: buffer6,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte170m', transfer: 'smpte240m'} });
let textureView34 = texture2.createView({});
let sampler14 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.31,
  maxAnisotropy: 20,
});
try {
renderBundleEncoder3.setIndexBuffer(buffer0, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(7, buffer3, 0, 39);
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer8, 248, buffer10, 0, 12);
} catch {}
let buffer19 = device0.createBuffer({size: 368, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let texture36 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 12},
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder23 = commandEncoder24.beginComputePass();
let renderBundle3 = renderBundleEncoder3.finish({});
let imageData4 = new ImageData(4, 24);
let commandEncoder25 = device0.createCommandEncoder({});
let computePassEncoder24 = commandEncoder25.beginComputePass({timestampWrites: {querySet: querySet4}});
let computePassEncoder25 = commandEncoder23.beginComputePass({timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 7}});
try {
computePassEncoder22.setBindGroup(3, bindGroup3);
} catch {}
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
try {
computePassEncoder25.setBindGroup(1, bindGroup12, new Uint32Array(1153), 19, 0);
} catch {}
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3]});
let commandEncoder26 = device0.createCommandEncoder({});
let textureView35 = texture15.createView({mipLevelCount: 1});
try {
buffer2.unmap();
} catch {}
try {
commandEncoder26.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 236 */
  offset: 236,
  bytesPerRow: 8704,
  buffer: buffer6,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: img0,
  origin: { x: 1, y: 3 },
  flipY: true,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup17 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 5, resource: externalTexture1}]});
let texture37 = gpuCanvasContext0.getCurrentTexture();
let textureView36 = texture36.createView({aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder26 = commandEncoder26.beginComputePass();
try {
computePassEncoder23.setBindGroup(0, bindGroup15, new Uint32Array(308), 13, 0);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 5, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(6).fill(104), /* required buffer size: 6 */
{offset: 6}, {width: 34, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
offscreenCanvas0.height = 165;
let imageData5 = new ImageData(16, 40);
let buffer20 = device0.createBuffer({size: 196, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView37 = texture14.createView({});
let promise7 = device0.queue.onSubmittedWorkDone();
let bindGroup18 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 0, resource: textureView16}]});
let commandEncoder27 = device0.createCommandEncoder({});
let texture38 = device0.createTexture({
  size: [142, 16, 1],
  sampleCount: 1,
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
commandEncoder27.resolveQuerySet(querySet2, 150, 21, buffer19, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 12, new Uint32Array(19533), 5498, 4);
} catch {}
let bindGroup19 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture0}]});
let computePassEncoder27 = commandEncoder27.beginComputePass();
try {
computePassEncoder12.setBindGroup(0, bindGroup18, []);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder28 = device0.createCommandEncoder({});
let textureView38 = texture2.createView({label: '\u64b7\u{1fb99}\u5564\u0ca7', dimension: '2d-array'});
let textureView39 = texture8.createView({baseMipLevel: 0, arrayLayerCount: 1});
let computePassEncoder28 = commandEncoder28.beginComputePass();
let externalTexture4 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder15.setBindGroup(2, bindGroup12, new Uint32Array(707), 68, 0);
} catch {}
try {
computePassEncoder20.pushDebugGroup('\u{1fdf8}');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpte240m', transfer: 'smpte170m'} });
let buffer21 = device0.createBuffer({size: 0, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let commandEncoder29 = device0.createCommandEncoder({});
let textureView40 = texture38.createView({dimension: '2d-array', aspect: 'all'});
let computePassEncoder29 = commandEncoder29.beginComputePass();
try {
computePassEncoder20.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer10, 40, new Uint32Array(3467), 1389, 4);
} catch {}
let imageData6 = new ImageData(76, 32);
let bindGroup20 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 0, resource: textureView16}]});
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 116});
try {
device0.queue.writeBuffer(buffer21, 0, new DataView(new ArrayBuffer(9045)), 1203, 0);
} catch {}
let buffer22 = device0.createBuffer({size: 44, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, mappedAtCreation: false});
let texture39 = device0.createTexture({
  size: {width: 510, height: 214, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView41 = texture21.createView({aspect: 'all'});
let buffer23 = device0.createBuffer({size: 88, usage: GPUBufferUsage.INDEX});
let bindGroup21 = device0.createBindGroup({layout: veryExplicitBindGroupLayout5, entries: [{binding: 0, resource: textureView16}]});
let buffer24 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture40 = device0.createTexture({size: [560, 1, 144], dimension: '3d', format: 'rgba32float', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup22 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture2}]});
let buffer25 = device0.createBuffer({size: 101, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder30 = device0.createCommandEncoder({});
let textureView42 = texture12.createView({});
let computePassEncoder30 = commandEncoder30.beginComputePass();
try {
computePassEncoder3.setBindGroup(2, bindGroup13, new Uint32Array(85), 15, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 96, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(0).fill(74), /* required buffer size: 0 */
{offset: 0}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer26 = device0.createBuffer({size: 7163, usage: GPUBufferUsage.UNIFORM});
let texture41 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 12},
  mipLevelCount: 1,
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler15 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 59.82, compare: 'greater-equal'});
try {
computePassEncoder6.setBindGroup(0, bindGroup11);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 5},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let textureView43 = texture24.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 47, arrayLayerCount: 1});
try {
buffer15.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 19},
  aspect: 'all',
}, new Uint8Array(44_693).fill(183), /* required buffer size: 44_693 */
{offset: 229, bytesPerRow: 226, rowsPerImage: 14}, {width: 42, height: 1, depthOrArrayLayers: 15});
} catch {}
let commandEncoder31 = device0.createCommandEncoder({});
let textureView44 = texture27.createView({});
let computePassEncoder31 = commandEncoder31.beginComputePass();
let sampler16 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'clamp-to-edge'});
try {
computePassEncoder3.setBindGroup(3, bindGroup8, new Uint32Array(3176), 780, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(8).fill(160), /* required buffer size: 8 */
{offset: 8}, {width: 249, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'jedecP22Phosphors', transfer: 'gamma28curve'} });
let buffer27 = device0.createBuffer({size: 188, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder32 = device0.createCommandEncoder({});
let computePassEncoder32 = commandEncoder32.beginComputePass({timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 1033}});
let sampler17 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', lodMaxClamp: 80.83});
let bindGroup23 = device0.createBindGroup({layout: veryExplicitBindGroupLayout4, entries: [{binding: 370, resource: textureView24}]});
let texture42 = gpuCanvasContext0.getCurrentTexture();
let sampler18 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 17,
});
try {
device0.queue.writeBuffer(buffer10, 104, new DataView(new ArrayBuffer(161)), 79, 4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 468, y: 0, z: 12},
  aspect: 'all',
}, new Uint8Array(178).fill(185), /* required buffer size: 178 */
{offset: 178, rowsPerImage: 132}, {width: 405, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup24 = device0.createBindGroup({layout: veryExplicitBindGroupLayout4, entries: [{binding: 370, resource: textureView27}]});
let buffer28 = device0.createBuffer({
  size: 120,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture43 = device0.createTexture({
  size: [255, 107, 110],
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture44 = device0.createTexture({
  size: {width: 71},
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let sampler19 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'nearest'});
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'film', transfer: 'log'} });
let buffer29 = device0.createBuffer({size: 344, usage: GPUBufferUsage.INDIRECT});
let commandEncoder33 = device0.createCommandEncoder({});
try {
computePassEncoder5.popDebugGroup();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
requires packed_4x8_integer_dot_product;

enable f16;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

var<workgroup> vw2: f16;

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

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

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

/* zero global variables used */
fn fn0() -> vec2h {
  var out: vec2h;
  var vf0: vec3f = fma(vec3f(unconst_f32(0.3933e0), unconst_f32(0.3557), unconst_f32(-0.01195e-1)), vec3f(unconst_f32(-0.1249), unconst_f32(0.1440e33), unconst_f32(0.3241)), vec3f(unconst_f32(0.1029), unconst_f32(0.2344), unconst_f32(0.02369e-20)));
  vf0 = smoothstep(vec3f(unconst_f32(0.3887e-35), unconst_f32(0.04641), unconst_f32(0.04452e20)), vec3f(unconst_f32(0.09017e29), unconst_f32(0.06401e-16), unconst_f32(0.6510e-10)), vec3f(unconst_f32(0.07824e-23), unconst_f32(0.1386e-28), unconst_f32(-0.1760e10)));
  let vf1: vec3h = radians(vec3h(unconst_f16(5440.3), unconst_f16(22124.2), unconst_f16(8283.2)));
  if bool(pack4xU8Clamp((vec4u(unconst_u32(162813452), unconst_u32(839659684), unconst_u32(24605060), unconst_u32(179293361)) ^ vec4u(unconst_u32(454378602), unconst_u32(513376072), unconst_u32(69271498), unconst_u32(678403749))))) {
  var vf2: vec4u = unpack4xU8(unconst_u32(587528971));
  while any(select(vec2<bool>(unconst_bool(true), unconst_bool(true)), vec2<bool>(unconst_bool(true), unconst_bool(false)), unconst_bool(true))) {
  vp0 += vec2i(i32(override0));
  out += exp(vec3h(unconst_f16(440.9), unconst_f16(12.22), unconst_f16(17276.2))).gb;
  _ = override0;
}
  out = bitcast<vec2h>(vf2[unconst_u32(1111737671)]);
  out *= transpose(mat2x2h(unconst_f16(31633.8), unconst_f16(15323.9), unconst_f16(7020.4), unconst_f16(689.3)))[unconst_i32(1)];
  out += bitcast<vec2h>(asinh(unconst_f32(0.08950e15)));
  vf2 = vec4u(select(vec2<bool>(unconst_bool(false), unconst_bool(true)), vec2<bool>(unconst_bool(true), unconst_bool(true)), unconst_bool(false)).ggrr.zxxx.xwyz);
  _ = override0;
}
  return out;
  _ = override0;
}

@group(0) @binding(0) var st0: texture_storage_1d<rgba32uint, write>;

struct FragmentOutput0 {
  @location(3) f0: i32,
  @location(0) f1: vec4f,
  @location(4) @interpolate(flat) f2: vec4i,
  @builtin(frag_depth) f3: f32,
}

override override0: f16 = 8896.3;

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

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

struct T4 {
  @align(8) @size(1408) f0: array<vec2h>,
}

var<private> vp0: vec2i = vec2i(337004226, 285289072);

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

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

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

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

var<workgroup> vw0: atomic<i32>;

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

/* zero global variables used */
@vertex
fn vertex0() -> @builtin(position) vec4f {
  var out: vec4f;
  var vf3: vec2f = saturate(vec2f(unconst_f32(-0.2415), unconst_f32(0.04436)));
  let vf4: vec2<bool> =  !vec2<bool>(unconst_bool(true), unconst_bool(true));
  var vf5: vec3f = atan(vec3f(unconst_f32(-0.05508e20), unconst_f32(0.1050), unconst_f32(0.07418)));
  out -= vf5.yzyy;
  vp0 &= vec2i(i32(any(vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true)))));
  vf3 = log2(vec4f(unconst_f32(0.2229), unconst_f32(0.1952e13), unconst_f32(0.05096e-22), unconst_f32(0.1002e35))).wz;
  vp0 *= vec2i(i32(any(vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false)))));
  vf5 = sqrt(vec2f(unconst_f32(-0.2553), unconst_f32(0.1371e-4))).yyy;
  var vf6: vec4f = max(vec4f(unconst_f32(0.03227), unconst_f32(0.08470e-12), unconst_f32(0.2954), unconst_f32(0.03766)), vec4f(unconst_f32(0.05218e33), unconst_f32(0.1489e27), unconst_f32(0.4615), unconst_f32(0.2792e17)));
  vp0 ^= vec2i(atanh(vec2f(unconst_f32(0.00159e-13), unconst_f32(0.00881e-35))).rr);
  vp0 += vec2i(i32(atanh(unconst_f32(0.00707))));
  return out;
}

/* zero global variables used */
@fragment
fn fragment0(@invariant @builtin(position) a0: vec4f) -> FragmentOutput0 {
  var out: FragmentOutput0;
  let vf7: i32 = vp0[unconst_u32(2257604007)];
  let vf8: vec4f = a0;
  out.f3 = bitcast<vec2f>((vec2i(unconst_i32(-235760948), unconst_i32(949503783)) | vec2i(bitcast<i32>(vf8[unconst_u32(1211654864)])))).r;
  var vf9: i32 = vf7;
  var vf10 = fn0();
  let ptr0: ptr<function, i32> = &vf9;
  _ = fn0();
  vf10 -= vec2h(f16((unconst_bool(true) && unconst_bool(false))));
  var vf11 = fn0();
  out.f0 |= i32(vf8.x);
  out.f1 += vec4f(bitcast<f32>((*ptr0)));
  out.f1 *= vec4f(f32(vf9));
  return out;
  _ = override0;
}

/* used global variables: st0 */
@compute @workgroup_size(2, 1, 1)
fn compute0() {
  atomicXor(&vw1[unconst_u32(349767354)], unconst_u32(1526373867));
  textureStore(st0, unconst_i32(106217254), vec4u(vec4u(unconst_u32(717704398), unconst_u32(740619250), unconst_u32(225646399), unconst_u32(87498129))));
  var vf12: vec4h = atan(vec4h(unconst_f16(-1076.2), unconst_f16(4121.5), unconst_f16(1333.0), unconst_f16(629.6)));
  vw2 = f16(firstLeadingBit(unconst_i32(576319628)));
  let vf13: vec2h = (vec2h(unconst_f16(-11176.8), unconst_f16(-51003.6)) - unconst_f16(22229.9));
  textureStore(st0, unconst_i32(122071010), vec4u(vec4u(unconst_u32(574442821), unconst_u32(423919562), unconst_u32(649006010), unconst_u32(665704144))));
  let vf14: u32 = atomicExchange(&(*&vw1)[unconst_u32(412871466)], unconst_u32(1363918790));
  return;
  _ = st0;
}`,
});
let bindGroup25 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture2}]});
let commandEncoder34 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(2, bindGroup3);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
computePassEncoder17.insertDebugMarker('\u{1fefe}');
} catch {}
document.body.prepend(img0);
let commandBuffer2 = commandEncoder33.finish();
let texture45 = device0.createTexture({
  size: [35, 4, 36],
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder33 = commandEncoder34.beginComputePass({timestampWrites: {querySet: querySet3}});
let querySet7 = device0.createQuerySet({type: 'timestamp', count: 1064});
let sampler20 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 3,
});
try {
buffer24.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
let texture46 = device0.createTexture({
  size: {width: 17, height: 2, depthOrArrayLayers: 71},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder20.setBindGroup(1, bindGroup4, new Uint32Array(703), 76, 0);
} catch {}
let buffer30 = device0.createBuffer({size: 624, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder35 = device0.createCommandEncoder({});
let sampler21 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 81.40,
  maxAnisotropy: 11,
});
try {
computePassEncoder14.setBindGroup(1, bindGroup22, new Uint32Array(303), 65, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline0 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  multisample: {count: 4, mask: 0xffffffff, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{format: 'rgba32float', writeMask: GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth32float',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilWriteMask: 183032109,
    depthBiasSlopeScale: 432.98051454189067,
  },
  vertex: {module: shaderModule0, constants: {}, buffers: []},
  primitive: {topology: 'line-list', cullMode: 'front'},
});
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpte240m', transfer: 'smpteSt4281'} });
let bindGroup26 = device0.createBindGroup({layout: veryExplicitBindGroupLayout4, entries: [{binding: 370, resource: textureView41}]});
let commandEncoder36 = device0.createCommandEncoder({});
let textureView45 = texture6.createView({});
let renderPassEncoder0 = commandEncoder36.beginRenderPass({
  colorAttachments: [{
  view: textureView40,
  clearValue: { r: 887.9, g: -133.3, b: 624.7, a: -972.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg16float']});
try {
computePassEncoder5.setBindGroup(1, bindGroup23);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup19, new Uint32Array(61), 11, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup16, []);
} catch {}
try {
commandEncoder35.copyTextureToTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 5, y: 3, z: 20},
  aspect: 'all',
},
{
  texture: texture28,
  mipLevel: 0,
  origin: {x: 67, y: 11, z: 0},
  aspect: 'all',
},
{width: 30, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder35.resolveQuerySet(querySet0, 12, 8, buffer7, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer31 = device0.createBuffer({size: 264, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let computePassEncoder34 = commandEncoder35.beginComputePass({timestampWrites: {querySet: querySet2, beginningOfPassWriteIndex: 163, endOfPassWriteIndex: 388}});
let externalTexture5 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder12.setBindGroup(1, bindGroup14);
} catch {}
try {
computePassEncoder31.setBindGroup(3, bindGroup10, new Uint32Array(395), 15, 0);
} catch {}
try {
computePassEncoder17.end();
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup18, new Uint32Array(1684), 40, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer15, 88, new DataView(new ArrayBuffer(1610)), 211, 20);
} catch {}
let buffer32 = device0.createBuffer({size: 23, usage: GPUBufferUsage.INDEX});
let commandEncoder37 = device0.createCommandEncoder({});
let texture47 = device0.createTexture({
  size: [1020, 428, 41],
  mipLevelCount: 4,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST,
});
let renderBundle4 = renderBundleEncoder4.finish({});
let sampler22 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 75.45});
try {
computePassEncoder0.setBindGroup(0, bindGroup16, new Uint32Array(1851), 165, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup12, new Uint32Array(589), 29, 0);
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let computePassEncoder35 = commandEncoder13.beginComputePass();
try {
computePassEncoder1.setBindGroup(2, bindGroup10, new Uint32Array(3483), 107, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle4, renderBundle4]);
} catch {}
document.body.append(img0);
let bindGroup27 = device0.createBindGroup({layout: veryExplicitBindGroupLayout4, entries: [{binding: 370, resource: textureView24}]});
let computePassEncoder36 = commandEncoder37.beginComputePass();
let sampler23 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 71.33,
});
let externalTexture6 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder16.setBindGroup(2, bindGroup25);
} catch {}
let texture48 = device0.createTexture({
  size: {width: 510, height: 214, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView46 = texture21.createView({aspect: 'all'});
try {
computePassEncoder11.setBindGroup(0, bindGroup3);
} catch {}
let textureView47 = texture13.createView({dimension: '2d', aspect: 'depth-only', format: 'depth32float', baseArrayLayer: 28});
try {
computePassEncoder24.setBindGroup(1, bindGroup22);
} catch {}
let texture49 = device0.createTexture({
  size: {width: 280, height: 1, depthOrArrayLayers: 2},
  mipLevelCount: 5,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture50 = gpuCanvasContext0.getCurrentTexture();
let sampler24 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.44,
  maxAnisotropy: 9,
});
try {
computePassEncoder18.setBindGroup(0, bindGroup18);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup6);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle4, renderBundle4]);
} catch {}
try {
renderPassEncoder0.setStencilReference(823);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer32, 'uint32', 0, 6);
} catch {}
let pipeline1 = device0.createRenderPipeline({
  layout: pipelineLayout1,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule0,
  targets: [{
  format: 'rgba32float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}],
},
  depthStencil: {
    format: 'depth32float',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilReadMask: 768138133,
  },
  vertex: {module: shaderModule0, constants: {}, buffers: []},
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'none'},
});
let sampler25 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 64.39,
  compare: 'equal',
  maxAnisotropy: 15,
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup6, new Uint32Array(781), 8, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer28, 'uint16', 0, 15);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer30, 0, 8);
} catch {}
document.body.prepend(img0);
let textureView48 = texture48.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder23.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder0.setScissorRect(32, 4, 3, 2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 343, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(39).fill(94), /* required buffer size: 39 */
{offset: 39, bytesPerRow: 1391}, {width: 171, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(0);
let textureView49 = texture25.createView({dimension: '2d-array'});
try {
renderPassEncoder0.setBindGroup(0, bindGroup24, new Uint32Array(719), 57, 0);
} catch {}
let canvas0 = document.createElement('canvas');
try {
globalThis.someLabel = externalTexture2.label;
} catch {}
let buffer33 = device0.createBuffer({size: 13084, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
try {
renderPassEncoder0.setBindGroup(2, bindGroup12);
} catch {}
try {
renderPassEncoder0.setViewport(71.85716688586815, 8.744998956995945, 35.078451557926705, 5.0613136797166325, 0.6659190240781362, 0.9084386249586769);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer33, 'uint32', 7_556, 350);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer19, 0, 36);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext1 = canvas0.getContext('webgpu');
try {
computePassEncoder12.setBindGroup(1, bindGroup1, new Uint32Array(365), 315, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup24);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: 360.7, g: -892.7, b: -739.1, a: 709.7, });
} catch {}
let pipeline2 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule0}});
let offscreenCanvas1 = new OffscreenCanvas(112, 40);
let textureView50 = texture43.createView({aspect: 'all'});
try {
computePassEncoder27.setBindGroup(1, bindGroup25, new Uint32Array(1840), 391, 0);
} catch {}
try {
computePassEncoder20.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer11, 'uint16', 2, 3);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer19, 368);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let pipeline3 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule0}});
let texture51 = gpuCanvasContext0.getCurrentTexture();
let textureView51 = texture9.createView({baseMipLevel: 0, arrayLayerCount: 1});
let sampler26 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 82.32});
try {
renderPassEncoder0.setBindGroup(3, bindGroup23, new Uint32Array(150), 13, 0);
} catch {}
try {
renderPassEncoder0.end();
} catch {}
try {
device0.queue.writeBuffer(buffer24, 12, new Uint32Array(9930), 967, 0);
} catch {}
let pipeline4 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule0}});
let computePassEncoder37 = commandEncoder36.beginComputePass();
try {
computePassEncoder15.setBindGroup(0, bindGroup15, new Uint32Array(1054), 78, 0);
} catch {}
let buffer34 = device0.createBuffer({
  label: '\u8486\u9b59',
  size: 40,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let commandEncoder38 = device0.createCommandEncoder({});
let textureView52 = texture1.createView({mipLevelCount: 2});
let computePassEncoder38 = commandEncoder38.beginComputePass({timestampWrites: {querySet: querySet4}});
let sampler27 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 91.89,
  lodMaxClamp: 97.14,
  maxAnisotropy: 1,
});
let commandEncoder39 = device0.createCommandEncoder({});
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 3133});
let texture52 = device0.createTexture({
  size: [2240, 1, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder39 = commandEncoder39.beginComputePass();
let sampler28 = device0.createSampler({addressModeW: 'repeat', mipmapFilter: 'linear', lodMinClamp: 31.66});
try {
computePassEncoder25.insertDebugMarker('\uc183');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 280, height: 1, depthOrArrayLayers: 5}
*/
{
  source: videoFrame4,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder40 = device0.createCommandEncoder();
let textureView53 = texture52.createView({arrayLayerCount: 1});
try {
buffer14.unmap();
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 30,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout6, veryExplicitBindGroupLayout0]});
let commandEncoder41 = device0.createCommandEncoder({});
let querySet9 = device0.createQuerySet({type: 'timestamp', count: 1768});
let textureView54 = texture52.createView({});
let computePassEncoder40 = commandEncoder41.beginComputePass();
try {
computePassEncoder20.setBindGroup(0, bindGroup18, new Uint32Array(179), 3, 0);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, alphaMode: 'opaque'});
} catch {}
let computePassEncoder41 = commandEncoder40.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 635, endOfPassWriteIndex: 245}});
let sampler29 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 91.60,
});
try {
computePassEncoder37.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeBuffer(buffer24, 4, new Uint32Array(2868), 405, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 1, depthOrArrayLayers: 2}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 3,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer35 = device0.createBuffer({size: 220, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let texture53 = device0.createTexture({
  size: {width: 1120, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView55 = texture23.createView({});
let promise9 = device0.queue.onSubmittedWorkDone();
let pipeline5 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule0, constants: {}}});
let commandEncoder42 = device0.createCommandEncoder();
let textureView56 = texture13.createView({dimension: '2d', baseArrayLayer: 1});
let computePassEncoder42 = commandEncoder42.beginComputePass();
try {
computePassEncoder29.setBindGroup(2, bindGroup12, new Uint32Array(770), 54, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(2, 1); };
} catch {}
try {
computePassEncoder3.setPipeline(pipeline5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(234).fill(101), /* required buffer size: 234 */
{offset: 234}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout1 = pipeline4.getBindGroupLayout(0);
let textureView57 = texture8.createView({mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer29, 60); };
} catch {}
try {
computePassEncoder20.end();
} catch {}
try {
computePassEncoder9.setPipeline(pipeline4);
} catch {}
try {
commandEncoder20.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 280 */
  offset: 280,
  buffer: buffer6,
}, {
  texture: texture49,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer15, 8, new Int16Array(14206), 7480, 8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 26, y: 36, z: 0},
  aspect: 'all',
}, new Uint8Array(6).fill(28), /* required buffer size: 6 */
{offset: 6, bytesPerRow: 462}, {width: 111, height: 8, depthOrArrayLayers: 0});
} catch {}
let texture54 = device0.createTexture({
  size: [35, 4, 36],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView58 = texture40.createView({});
let computePassEncoder43 = commandEncoder20.beginComputePass();
try {
computePassEncoder31.setBindGroup(0, bindGroup6, new Uint32Array(424), 16, 0);
} catch {}
try {
buffer31.unmap();
} catch {}
let buffer36 = device0.createBuffer({size: 116, usage: GPUBufferUsage.INDEX});
let sampler30 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 85.62});
try {
computePassEncoder4.setBindGroup(3, bindGroup16, new Uint32Array(5916), 1_092, 0);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline3);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let querySet10 = device0.createQuerySet({type: 'timestamp', count: 1177});
try {
computePassEncoder6.setPipeline(pipeline5);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let commandEncoder43 = device0.createCommandEncoder();
let textureView59 = texture10.createView({dimension: '2d-array', aspect: 'depth-only', baseArrayLayer: 6, arrayLayerCount: 1});
try {
buffer19.unmap();
} catch {}
try {
commandEncoder43.copyTextureToTexture({
  texture: texture49,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture49,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let imageData7 = new ImageData(48, 16);
let buffer37 = device0.createBuffer({
  size: 424,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let computePassEncoder44 = commandEncoder43.beginComputePass();
let sampler31 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 11,
});
try {
computePassEncoder43.setPipeline(pipeline4);
} catch {}
let textureView60 = texture45.createView({baseArrayLayer: 0});
try {
computePassEncoder26.setPipeline(pipeline2);
} catch {}
let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu');
try {
gpuCanvasContext2.unconfigure();
} catch {}
let videoFrame9 = new VideoFrame(videoFrame1, {timestamp: 0});
let textureView61 = texture54.createView({mipLevelCount: 1});
let externalTexture7 = device0.importExternalTexture({source: videoFrame8});
try {
computePassEncoder44.setPipeline(pipeline3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture45,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture55 = device0.createTexture({
  size: {width: 280, height: 1, depthOrArrayLayers: 30},
  mipLevelCount: 6,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder9.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline4);
} catch {}
let bindGroup28 = device0.createBindGroup({
  label: '\u0980\u{1f75f}\u6b77\u3ce2\u04cd\u017e',
  layout: veryExplicitBindGroupLayout6,
  entries: [{binding: 30, resource: textureView53}],
});
let textureView62 = texture38.createView({dimension: '2d-array', baseArrayLayer: 0});
try {
computePassEncoder8.setPipeline(pipeline5);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 900, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(87).fill(120), /* required buffer size: 87 */
{offset: 87}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 8, height: 1, depthOrArrayLayers: 9}
*/
{
  source: canvas0,
  origin: { x: 118, y: 15 },
  flipY: false,
}, {
  texture: texture54,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
try {
computePassEncoder35.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline4);
} catch {}
let buffer38 = device0.createBuffer({size: 72, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let textureView63 = texture17.createView({baseMipLevel: 0});
let texture56 = device0.createTexture({
  size: {width: 255, height: 107, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
buffer1.destroy();
} catch {}
let querySet11 = device0.createQuerySet({type: 'occlusion', count: 360});
let texture57 = device0.createTexture({
  size: {width: 35, height: 4, depthOrArrayLayers: 18},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture58 = device0.createTexture({
  label: '\u{1fd45}\u{1fdf5}\u1ef3\u{1faff}\u61ae\u4c4c\u0361\u5fdc\u029a',
  size: {width: 71, height: 8, depthOrArrayLayers: 1},
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder35.setBindGroup(0, bindGroup13);
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

enable f16;

requires pointer_composite_access;

struct T0 {
  @size(256) f0: array<array<atomic<u32>, 1>, 2>,
  @size(512) f1: u32,
  @align(16) @size(1536) f2: array<array<atomic<u32>, 1>>,
}

alias vec3b = vec3<bool>;

struct VertexOutput1 {
  @builtin(position) f1: vec4f,
}

var<workgroup> vw4: FragmentOutput1;

@group(0) @binding(0) var st1: texture_storage_1d<rgba32uint, write>;

/* zero global variables used */
fn fn0(a0: ptr<workgroup, VertexOutput0>) -> VertexOutput0 {
  var out: VertexOutput0;
  var vf15: vec4h = select(vec4h(unconst_f16(-14902.8), unconst_f16(-6810.7), unconst_f16(32992.3), unconst_f16(13419.5)), vec4h(unconst_f16(8281.5), unconst_f16(5166.8), unconst_f16(5243.7), unconst_f16(12180.8)), vec4<bool>(firstLeadingBit(vec4u(unconst_u32(362180120), unconst_u32(663273468), unconst_u32(114929309), unconst_u32(1680586527)))));
  out.f0 *= bitcast<vec4f>((vec2i(unconst_i32(198529082), unconst_i32(415810335)) | vec2i(unconst_i32(32887626), unconst_i32(7232036))).yxxx);
  let vf16: mat3x2h = transpose(mat2x3h());
  (*a0) = VertexOutput0(vec4f(vf16[unconst_i32(0)].ggrr));
  {
  (*a0).f0 = cos(vec2f(unconst_f32(0.05396e35), unconst_f32(0.3683e23))).xyyy;
  out.f0 = unpack4x8snorm(unconst_u32(957290625));
  var vf17: u32 = (pack2x16float(vec2f(unconst_f32(-0.2883e15), unconst_f32(0.2904))) >> unconst_u32(513924394));
  out.f0 = (*a0).f0;
  let vf18: f32 = log2(unconst_f32(0.00620e19));
  var vf19: bool = all(bool(radians(vec3f(unconst_f32(0.4630), unconst_f32(-0.3349), unconst_f32(0.2480e12)))[1]));
}
  var vf20: mat3x2h = vf16;
  out.f0 -= vec4f(f32(dot(vec4u(unconst_u32(1988437916), unconst_u32(60858296), unconst_u32(774990443), unconst_u32(611081186)), vec4u((*a0).f0.rrab.xzxz))));
  if bool((*a0).f0[2]) {
  out = VertexOutput0(vec4f((*a0).f0[unconst_u32(873829147)]));
  let ptr1: ptr<workgroup, VertexOutput0> = &(*a0);
}
  let ptr2: ptr<function, mat3x2h> = &vf20;
  var vf21: vec2h = vf16[unconst_u32(2025097724)];
  return out;
}

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

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

var<workgroup> vw7: atomic<i32>;

var<workgroup> vw3: VertexOutput1;

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

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

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

var<workgroup> vw6: VertexOutput0;

struct T1 {
  @size(76) f0: array<array<i32, 9>, 1>,
  @size(8) f1: array<u32, 1>,
}

struct FragmentOutput1 {
  @location(0) @interpolate(flat, sample) f0: vec2f,
  @builtin(sample_mask) f1: u32,
}

struct T3 {
  @align(64) @size(1728) f0: array<atomic<i32>>,
}

struct T2 {
  @size(16) f0: array<u32>,
}

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

var<workgroup> vw5: VertexOutput0;

/* zero global variables used */
@vertex
fn vertex1(@location(5) @interpolate(perspective) a0: f32) -> VertexOutput0 {
  var out: VertexOutput0;
  out.f0 += bitcast<vec4f>(insertBits(vec2u(unconst_u32(59853415), unconst_u32(526142743)), vec2u(unconst_u32(49522241), unconst_u32(186957958)), unconst_u32(5505668), unconst_u32(1693499432)).rgrg);
  var vf22: vec2u = insertBits(vec2u(unconst_u32(78540915), unconst_u32(261881515)), vec2u(unconst_u32(717060533), unconst_u32(711355256)), unconst_u32(308757040), unconst_u32(527334596));
  vf22 = vec2u(pack4x8unorm(vec4f(unconst_f32(0.03381e-43), unconst_f32(0.8129e-26), unconst_f32(0.01589e28), unconst_f32(0.03593e7))));
  out.f0 = atan2(vec2f(unconst_f32(0.4866e25), unconst_f32(0.04192)), vec2f(unconst_f32(0.2562e-13), unconst_f32(0.2841))).yxxx;
  vf22 = vec2u(bitcast<u32>(a0));
  var vf23: f32 = a0;
  loop {
  var vf24: vec4f = (vec4f(unconst_f32(0.3018), unconst_f32(0.1658), unconst_f32(-0.00838e29), unconst_f32(0.5063e-42)) % f32(determinant(mat2x2h(unconst_f16(20923.7), unconst_f16(1554.5), unconst_f16(3254.6), unconst_f16(4423.5)))));
  var vf25: f32 = a0;
  vf25 = pow(vec3f(unconst_f32(0.03454e16), unconst_f32(0.3305e28), unconst_f32(0.09657e-37)), unpack2x16snorm(unconst_u32(165489718)).xyx).r;
  var vf26: vec3u = extractBits(vec3u(unconst_u32(78002419), unconst_u32(1449491266), unconst_u32(52532018)), unconst_u32(262042851), pack4xU8(bitcast<vec4u>(step(vec4f(unconst_f32(0.06675e22), unconst_f32(0.06160), unconst_f32(0.2746), unconst_f32(0.3081)), vec4f(unconst_f32(0.08480e-13), unconst_f32(0.1314e-16), unconst_f32(0.00637e-25), unconst_f32(0.05386e-38))).argg)));
  var vf27: f32 = a0;
  let vf28: vec3h = saturate(vec3h(unconst_f16(35241.9), unconst_f16(3004.8), unconst_f16(11709.1)));
  break;
}
  var vf29: vec2h = sin(vec2h(unconst_f16(451.2), unconst_f16(2215.7)));
  let ptr3: ptr<function, f32> = &vf23;
  var vf30: mat2x4f = transpose(mat4x2f(vf23, vf23, vf23, vf23, vf23, vf23, vf23, vf23));
  return out;
}

/* zero global variables used */
@vertex
fn vertex2(@location(12) a0: vec4f) -> VertexOutput1 {
  var out: VertexOutput1;
  let vf31: vec4f = atanh(vec4f(unconst_f32(0.1699), unconst_f32(0.03867), unconst_f32(0.07032e-30), unconst_f32(0.09812e-9)));
  out.f1 = vec4f(vf31[bitcast<u32>(countOneBits(vec3i(unconst_i32(84587265), unconst_i32(356744281), unconst_i32(377063476)))[0])]);
  let vf32: vec4h = acosh(vec4h(unconst_f16(11923.9), unconst_f16(8605.9), unconst_f16(5814.1), unconst_f16(11672.5)));
  let vf33: f32 = determinant(mat2x2f(f32((unconst_f32(0.1197e2) >= sinh(unconst_f32(0.1563)))), f32((unconst_f32(0.1197e2) >= sinh(unconst_f32(0.1563)))), f32((unconst_f32(0.1197e2) >= sinh(unconst_f32(0.1563)))), f32((unconst_f32(0.1197e2) >= sinh(unconst_f32(0.1563))))));
  var vf34: bool = (atanh(vec4f(unconst_f32(0.2442e-7), unconst_f32(0.07287e21), unconst_f32(-0.4401), unconst_f32(0.01524e28))).y < vec4f(vf32)[0]);
  let vf35: f32 = length(vec4f(unconst_f32(0.3269e37), unconst_f32(-0.1123), unconst_f32(0.05829), unconst_f32(0.02102)));
  var vf36: bool = (unconst_bool(true) != unconst_bool(true));
  return out;
}

/* zero global variables used */
@vertex
fn vertex3(@location(1) a0: vec2h, @location(11) @interpolate(flat, first) a1: vec4u, @location(0) a2: vec2f) -> @builtin(position) vec4f {
  var out: vec4f;
  var vf37: vec2f = a2;
  {
  out = asin(vec4f(unconst_f32(0.02525e35), unconst_f32(0.07450e-35), unconst_f32(0.1643e-8), unconst_f32(0.1169e-4)));
  var vf38: vec2f = reflect(vec2f(unconst_f32(0.06213e7), unconst_f32(0.07997)), vec2f(unconst_f32(0.9417), unconst_f32(0.1925)));
  var vf39: vec4h = step(vec4h(unconst_f16(17456.8), unconst_f16(46483.4), unconst_f16(6658.6), unconst_f16(15635.9)), vec4h(unconst_f16(3921.5), unconst_f16(649.5), unconst_f16(6931.9), unconst_f16(-2423.5)));
}
  vf37 = vec2f(vf37[unconst_u32(629380845)]);
  let vf40: f32 = a2[unconst_u32(386210005)];
  vf37 = vec2f(bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.3565e-36), unconst_f32(-0.01730e-9)))));
  out *= vec4f(vf37[unconst_u32(1019812934)]);
  let vf41: vec4u = a1;
  var vf42: vec2h = fract(vec2h(unconst_f16(1264.2), unconst_f16(2041.1)));
  vf37 -= vec2f(fract(vec2h(unconst_f16(7059.1), unconst_f16(10938.6))));
  vf37 *= vec2f(f32(vf42[unconst_u32(257995315)]));
  let vf43: vec2h = a0;
  vf42 = bitcast<vec2h>(vf40);
  return out;
}

/* zero global variables used */
@fragment
fn fragment1() -> FragmentOutput1 {
  var out: FragmentOutput1;
  discard;
  out.f0 *= select(vec4f(unconst_f32(0.7790), unconst_f32(0.09221e-40), unconst_f32(0.3966e-13), unconst_f32(0.2437e3)), vec4f(unconst_f32(0.1395), unconst_f32(-0.1697e-40), unconst_f32(0.1997e-21), unconst_f32(0.06578)), vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false), unconst_bool(false))).bb;
  var vf44: u32 = pack4x8snorm(vec4f(unpack4xI8(unconst_u32(2015119378))));
  out.f1 = pack4xI8Clamp(unpack4xI8(unconst_u32(638134469)));
  let vf45: u32 = dot4U8Packed(unconst_u32(428118278), unconst_u32(673522134));
  out.f0 = vec2f(bitcast<f32>(dot4I8Packed( ~unconst_u32(303350582), unconst_u32(443546687))));
  return out;
}

/* used global variables: st1 */
@compute @workgroup_size(1, 1, 1)
fn compute1() {
  var vf46: vec3i = reverseBits(vec3i(unconst_i32(378312666), unconst_i32(-36666233), unconst_i32(680804855)));
  let vf47: f32 = vw4.f0[unconst_u32(1227582279)];
  if bool((*&vw4).f0[1]) {
  for (var it0=u32((*&vw3).f1[2]); it0<(bitcast<u32>(atomicLoad(&(*&vw7))) & 0xfff); it0++) {
  vw5 = VertexOutput0(vec4f(bitcast<f32>(pack4x8snorm(vec4f(unconst_f32(0.1700e38), unconst_f32(0.2037e-7), unconst_f32(0.8683), unconst_f32(0.7161))))));
  textureStore(st1, unconst_i32(94058562), vec4u(vec4u(unconst_u32(12989257), unconst_u32(268179117), unconst_u32(356228276), unconst_u32(896616405))));
  vw3.f1 = workgroupUniformLoad(&vw5).f0;
  break;
  _ = st1;
}
  var vf48 = fn0(&vw6);
  let ptr4: ptr<workgroup, u32> = &vw4.f1;
  _ = st1;
}
  fn0(&vw6);
  var vf49 = fn0(&vw5);
  while bool(pack4xU8Clamp(vec4u(unconst_u32(322740874), unconst_u32(1703412073), unconst_u32(61316136), unconst_u32(517653131)))) {
  vw4.f1 |= pack2x16snorm((*&vw4).f0);
  loop {
  atomicAnd(&vw7, unconst_i32(176121078));
  let vf50: i32 = atomicLoad(&(*&vw7));
  vw4.f1 = vec2u(log2(vec2f(unconst_f32(-0.04886e-24), unconst_f32(-0.2430e8))))[0];
  break;
}
}
  _ = fn0(&vw5);
  _ = st1;
}`,
});
let texture59 = device0.createTexture({
  size: [1020, 428, 1],
  mipLevelCount: 1,
  dimension: '2d',
  format: 'rg32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder9.setBindGroup(1, bindGroup24, new Uint32Array(557), 49, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
document.body.prepend(canvas0);
let textureView64 = texture59.createView({dimension: '2d-array', baseMipLevel: 0, arrayLayerCount: 1});
let textureView65 = texture52.createView({arrayLayerCount: 1});
let sampler32 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 98.15,
});
try {
computePassEncoder4.setPipeline(pipeline2);
} catch {}
let buffer39 = device0.createBuffer({size: 40, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
try {
computePassEncoder14.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let textureView66 = texture22.createView({});
try {
computePassEncoder10.setPipeline(pipeline5);
} catch {}
canvas0.height = 88;
let commandEncoder44 = device0.createCommandEncoder({});
let texture60 = device0.createTexture({
  size: [560, 1, 119],
  dimension: '2d',
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView67 = texture26.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder45 = commandEncoder44.beginComputePass();
try {
computePassEncoder40.setPipeline(pipeline5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 47, z: 2},
  aspect: 'stencil-only',
}, new Uint8Array(35).fill(20), /* required buffer size: 35 */
{offset: 35}, {width: 256, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: imageData3,
  origin: { x: 1, y: 5 },
  flipY: false,
}, {
  texture: texture45,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await promise7;
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(24).fill(63), /* required buffer size: 24 */
{offset: 24, bytesPerRow: 81, rowsPerImage: 23}, {width: 27, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture61 = device0.createTexture({
  size: {width: 71, height: 8, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder45.setPipeline(pipeline2);
} catch {}
try {
  await buffer24.mapAsync(GPUMapMode.READ);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 8, height: 1, depthOrArrayLayers: 9}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture54,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture3.label = '\ubf20\ue58b\u{1fb23}\u0d72';
} catch {}
let bindGroup29 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 5, resource: externalTexture5}]});
let commandEncoder45 = device0.createCommandEncoder({});
let texture62 = device0.createTexture({
  size: {width: 255, height: 107, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView68 = texture56.createView({baseMipLevel: 0, baseArrayLayer: 0});
let renderPassEncoder1 = commandEncoder45.beginRenderPass({
  colorAttachments: [{
  view: textureView40,
  clearValue: { r: -159.2, g: -468.6, b: -533.8, a: 872.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 86406486,
});
let sampler33 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 77.39, compare: 'greater'});
let externalTexture8 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'});
try {
computePassEncoder8.setBindGroup(1, bindGroup23);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
try {
  await promise8;
} catch {}
let bindGroup30 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 5, resource: externalTexture1}]});
let buffer40 = device0.createBuffer({size: 28, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let texture63 = device0.createTexture({
  size: [2240, 1, 10],
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder31.setBindGroup(1, bindGroup6, []);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer14);
} catch {}
let buffer41 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let commandEncoder46 = device0.createCommandEncoder({});
let textureView69 = texture24.createView({mipLevelCount: 1, baseArrayLayer: 20, arrayLayerCount: 5});
let renderPassEncoder2 = commandEncoder46.beginRenderPass({
  colorAttachments: [{
  view: textureView60,
  depthSlice: 18,
  clearValue: { r: 990.4, g: -812.9, b: 148.3, a: -0.5458, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet11,
});
try {
computePassEncoder36.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(5, buffer19);
} catch {}
let imageData8 = new ImageData(20, 60);
let textureView70 = texture46.createView({mipLevelCount: 1, arrayLayerCount: 5});
try {
computePassEncoder44.setBindGroup(3, bindGroup29, new Uint32Array(1256), 41, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup10, new Uint32Array(6619), 1_206, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle4, renderBundle4, renderBundle4, renderBundle4]);
} catch {}
let texture64 = device0.createTexture({
  size: {width: 2240, height: 1, depthOrArrayLayers: 3},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder15.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer11, 'uint32', 4, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 8, new BigUint64Array(5198), 1253, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt709', transfer: 'gamma22curve'} });
let bindGroup31 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 5, resource: externalTexture0}]});
let commandEncoder47 = device0.createCommandEncoder({});
let texture65 = device0.createTexture({
  size: {width: 71, height: 8, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder46 = commandEncoder47.beginComputePass();
try {
computePassEncoder11.setPipeline(pipeline4);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u0fbe');
} catch {}
document.body.prepend(canvas0);
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let texture66 = device0.createTexture({
  size: {width: 1120, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler34 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 18,
});
try {
computePassEncoder31.setBindGroup(2, bindGroup31, []);
} catch {}
try {
computePassEncoder33.setBindGroup(0, bindGroup25, new Uint32Array(68), 5, 0);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline5);
} catch {}
try {
computePassEncoder42.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle4, renderBundle4, renderBundle4, renderBundle4]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer22, 'uint16', 4, 11);
} catch {}
try {
buffer38.unmap();
} catch {}
document.body.append(canvas0);
try {
adapter0.label = '\u1c84\u0b5f\u091c\uceae\u7c94\u541c\u6b2c\u8982\u{1fabe}';
} catch {}
let buffer42 = device0.createBuffer({size: 152, usage: GPUBufferUsage.COPY_DST});
let sampler35 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 73.49,
  compare: 'greater-equal',
});
try {
computePassEncoder31.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup31);
} catch {}
try {
renderPassEncoder2.beginOcclusionQuery(80);
} catch {}
try {
renderPassEncoder2.setStencilReference(164);
} catch {}
try {
  await promise10;
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'pq'} });
let sampler36 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'clamp-to-edge'});
try {
computePassEncoder43.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder4.setBindGroup(1, bindGroup25, new Uint32Array(1623), 27, 0);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup17, new Uint32Array(1287), 357, 0);
} catch {}
try {
renderPassEncoder1.setViewport(1.2417213994863676, 9.092396083844642, 113.28562828159092, 6.269517667610869, 0.038261499280905165, 0.48022047521238176);
} catch {}
let bindGroup32 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 5, resource: externalTexture7}]});
let texture67 = device0.createTexture({
  size: {width: 142, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler37 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat'});
try {
computePassEncoder12.setBindGroup(2, bindGroup24, new Uint32Array(2336), 859, 0);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup23, new Uint32Array(1754), 717, 0);
} catch {}
try {
renderPassEncoder2.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setStencilReference(462);
} catch {}
let arrayBuffer0 = buffer24.getMappedRange(0, 0);
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 241, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(449).fill(124), /* required buffer size: 449 */
{offset: 449}, {width: 118, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let textureView71 = texture16.createView({aspect: 'depth-only', mipLevelCount: 1});
let sampler38 = device0.createSampler({addressModeV: 'mirror-repeat', lodMaxClamp: 70.90, maxAnisotropy: 1});
try {
computePassEncoder29.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 0, 0);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
  await promise9;
} catch {}
let bindGroup33 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture1}]});
let textureView72 = texture5.createView({dimension: '2d'});
try {
computePassEncoder16.setBindGroup(2, bindGroup19);
} catch {}
try {
computePassEncoder8.setBindGroup(1, bindGroup11, new Uint32Array(744), 129, 0);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setViewport(28.725550445425508, 15.723502471588906, 106.9584636436541, 0.07463789944731085, 0.8128656770041587, 0.9526950605607098);
} catch {}
try {
device0.queue.writeBuffer(buffer41, 0, new Uint32Array(6241), 951, 0);
} catch {}
let imageData9 = new ImageData(16, 168);
try {
globalThis.someLabel = externalTexture0.label;
} catch {}
let textureView73 = texture52.createView({});
let sampler39 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', mipmapFilter: 'linear', lodMaxClamp: 85.56});
try {
computePassEncoder21.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setViewport(105.08915072357978, 13.565919960213996, 27.7682686648473, 0.9416546279281438, 0.5680744232234055, 0.6238921677187753);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer2, 0);
} catch {}
let commandEncoder48 = device0.createCommandEncoder({});
let textureView74 = texture45.createView({dimension: '3d', baseArrayLayer: 0});
let computePassEncoder47 = commandEncoder48.beginComputePass();
try {
computePassEncoder19.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(6, buffer14, 0, 105);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let pipeline6 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule1}});
let commandEncoder49 = device0.createCommandEncoder({});
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 483});
let textureView75 = texture1.createView({mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer18, 12); };
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer0, 'uint32', 32, 1);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer19, 0, 9);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 1, depthOrArrayLayers: 2}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder50 = device0.createCommandEncoder({});
try {
computePassEncoder46.setPipeline(pipeline4);
} catch {}
let buffer43 = device0.createBuffer({size: 768, usage: GPUBufferUsage.UNIFORM});
let textureView76 = texture63.createView({baseArrayLayer: 1, arrayLayerCount: 3});
try {
renderPassEncoder2.executeBundles([renderBundle4]);
} catch {}
try {
commandEncoder49.resolveQuerySet(querySet11, 143, 0, buffer19, 256);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 8, new DataView(new ArrayBuffer(5855)), 1086, 32);
} catch {}
let img1 = await imageWithData(64, 80, '#10101010', '#20202020');
let texture68 = device0.createTexture({
  size: {width: 71, height: 8, depthOrArrayLayers: 50},
  mipLevelCount: 2,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder48 = commandEncoder49.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder32.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer11, 'uint32', 4, 2);
} catch {}
try {
commandEncoder50.copyBufferToBuffer(buffer19, 48, buffer21, 0, 0);
} catch {}
let commandEncoder51 = device0.createCommandEncoder();
let renderPassEncoder3 = commandEncoder51.beginRenderPass({
  colorAttachments: [{
  view: textureView40,
  clearValue: { r: 78.84, g: -987.9, b: -946.0, a: -96.51, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 791661775,
});
let sampler40 = device0.createSampler({
  label: '\uae39\u4f58\u3f3a\u{1f882}\u8a43\u4122\u{1f819}\u1493\u8554',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMaxClamp: 91.63,
  compare: 'less',
  maxAnisotropy: 1,
});
try {
computePassEncoder3.setBindGroup(3, bindGroup27, new Uint32Array(206), 12, 0);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer14, 0, 81);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
document.body.append(img1);
let recycledExplicitBindGroupLayout2 = pipeline6.getBindGroupLayout(0);
let bindGroup34 = device0.createBindGroup({layout: veryExplicitBindGroupLayout5, entries: [{binding: 0, resource: textureView16}]});
let commandEncoder52 = device0.createCommandEncoder({});
let textureView77 = texture4.createView({baseArrayLayer: 0});
let texture69 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 409},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder45.setBindGroup(2, bindGroup13, new Uint32Array(2407), 465, 0);
} catch {}
try {
computePassEncoder34.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup6);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer35, 'uint16', 12, 33);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer31);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(6); };
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt709', transfer: 'smpte240m'} });
let textureView78 = texture53.createView({});
let computePassEncoder49 = commandEncoder50.beginComputePass();
try {
renderPassEncoder2.beginOcclusionQuery(231);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -460.3, g: 726.8, b: -399.5, a: -732.5, });
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 768 widthInBlocks: 192 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 600 */
  offset: 600,
  buffer: buffer8,
}, {
  texture: texture7,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 192, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let commandEncoder53 = device0.createCommandEncoder({});
let querySet13 = device0.createQuerySet({type: 'timestamp', count: 62});
let textureView79 = texture32.createView({});
let renderPassEncoder4 = commandEncoder53.beginRenderPass({
  colorAttachments: [{
  view: textureView60,
  depthSlice: 1,
  clearValue: { r: 659.7, g: 629.2, b: 361.5, a: 787.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet11,
});
try {
computePassEncoder26.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer31);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'srgb'});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 45, y: 9, z: 0},
  aspect: 'all',
}, new Uint8Array(224).fill(7), /* required buffer size: 224 */
{offset: 224}, {width: 105, height: 1, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder50 = commandEncoder52.beginComputePass({timestampWrites: {querySet: querySet0}});
try {
computePassEncoder37.setBindGroup(2, bindGroup5);
} catch {}
try {
renderPassEncoder2.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer40, 'uint16', 0, 7);
} catch {}
try {
  await buffer13.mapAsync(GPUMapMode.WRITE);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 4, height: 1, depthOrArrayLayers: 4}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture54,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 245,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder54 = device0.createCommandEncoder({});
let computePassEncoder51 = commandEncoder54.beginComputePass();
try {
computePassEncoder10.setBindGroup(2, bindGroup15);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer33, 16); };
} catch {}
try {
computePassEncoder7.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup25, new Uint32Array(5699), 40, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer32, 'uint32', 0, 0);
} catch {}
document.body.prepend(img0);
let commandEncoder55 = device0.createCommandEncoder({});
let computePassEncoder52 = commandEncoder55.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer34, 0); };
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: videoFrame10,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture45,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 11},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline7 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}});
let buffer44 = device0.createBuffer({size: 228, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder56 = device0.createCommandEncoder({});
try {
computePassEncoder35.setBindGroup(1, bindGroup10);
} catch {}
try {
computePassEncoder43.end();
} catch {}
try {
renderPassEncoder3.setViewport(36.25628177005631, 14.372583149862164, 84.42834586665565, 0.3600692224829185, 0.5650583171751278, 0.7647802592253812);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer40, 'uint32', 8, 0);
} catch {}
try {
commandEncoder20.copyBufferToBuffer(buffer6, 168, buffer24, 8, 0);
} catch {}
try {
commandEncoder56.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 7772 */
  offset: 7772,
  buffer: buffer33,
}, {
  texture: texture49,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer45 = device0.createBuffer({size: 160, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let textureView80 = texture65.createView({dimension: '2d-array', baseArrayLayer: 0, arrayLayerCount: 1});
let computePassEncoder53 = commandEncoder20.beginComputePass();
let externalTexture9 = device0.importExternalTexture({source: videoFrame12});
try {
computePassEncoder48.setBindGroup(1, bindGroup4, new Uint32Array(705), 158, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer30, 164); };
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer11, 'uint32', 0, 10);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer3, 0, 12);
} catch {}
try {
commandEncoder56.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2532 */
  offset: 2532,
  bytesPerRow: 40448,
  buffer: buffer33,
}, {
  texture: texture54,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder57 = device0.createCommandEncoder({});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], depthReadOnly: true, stencilReadOnly: true});
let sampler41 = device0.createSampler({addressModeV: 'mirror-repeat', lodMaxClamp: 67.71});
try {
computePassEncoder12.end();
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer45);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup34);
} catch {}
try {
querySet7.destroy();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 280, height: 1, depthOrArrayLayers: 5}
*/
{
  source: offscreenCanvas1,
  origin: { x: 50, y: 30 },
  flipY: true,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView81 = texture69.createView({mipLevelCount: 1});
let renderPassEncoder5 = commandEncoder56.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  depthSlice: 7,
  clearValue: { r: -244.6, g: -583.0, b: -66.96, a: 439.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet8,
});
let renderBundle5 = renderBundleEncoder5.finish();
try {
renderPassEncoder2.setIndexBuffer(buffer0, 'uint32', 4, 2);
} catch {}
try {
commandEncoder12.resolveQuerySet(querySet2, 4, 0, buffer40, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 0, new Uint32Array(4246), 157, 8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(53).fill(215), /* required buffer size: 53 */
{offset: 53}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: img1,
  origin: { x: 5, y: 2 },
  flipY: false,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder54 = commandEncoder57.beginComputePass();
try {
renderPassEncoder4.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup8, new Uint32Array(1958), 144, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer14);
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let texture70 = device0.createTexture({
  size: {width: 510, height: 214, depthOrArrayLayers: 1},
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder55 = commandEncoder12.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 20, endOfPassWriteIndex: 3}});
let sampler42 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 87.72});
try {
computePassEncoder9.setBindGroup(0, bindGroup20);
} catch {}
try {
computePassEncoder14.setBindGroup(2, bindGroup23, new Uint32Array(321), 149, 0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer22, 'uint32', 32, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: imageData2,
  origin: { x: 1, y: 2 },
  flipY: false,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 14},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'bt2020_12bit'} });
let commandEncoder58 = device0.createCommandEncoder({});
let computePassEncoder56 = commandEncoder58.beginComputePass({timestampWrites: {querySet: querySet4}});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], sampleCount: 1, depthReadOnly: true});
let renderBundle6 = renderBundleEncoder6.finish({});
try {
computePassEncoder18.setBindGroup(2, bindGroup10);
} catch {}
try {
computePassEncoder32.setBindGroup(2, bindGroup28, new Uint32Array(128), 25, 0);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle4]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: imageData9,
  origin: { x: 9, y: 16 },
  flipY: false,
}, {
  texture: texture45,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer46 = device0.createBuffer({size: 280, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder23.setBindGroup(2, bindGroup14, new Uint32Array(631), 7, 0);
} catch {}
try {
computePassEncoder55.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup33, new Uint32Array(1311), 90, 0);
} catch {}
try {
renderPassEncoder2.setViewport(33.573591822376116, 3.7536291100357553, 0.8773292349322321, 0.06304179722912229, 0.7266013956113662, 0.9553898003119934);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup22, new Uint32Array(2500), 4, 0);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(3, buffer45);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
computePassEncoder56.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(5, buffer3, 152, 10);
} catch {}
let textureView82 = texture69.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({
  colorFormats: ['rgba32float'],
  depthStencilFormat: 'depth32float',
  sampleCount: 4,
  stencilReadOnly: true,
});
let renderBundle7 = renderBundleEncoder7.finish({});
let sampler43 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', compare: 'greater-equal'});
try {
computePassEncoder46.setBindGroup(2, bindGroup26, new Uint32Array(2240), 292, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup18);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 71, y: 0, z: 12},
  aspect: 'all',
}, new Uint8Array(335_041).fill(85), /* required buffer size: 335_041 */
{offset: 497, bytesPerRow: 181, rowsPerImage: 307}, {width: 14, height: 7, depthOrArrayLayers: 7});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.prepend(canvas0);
try {
computePassEncoder25.setBindGroup(3, bindGroup30);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer40, 'uint16', 2, 12);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup3, new Uint32Array(1201), 52, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer9, 1_712); };
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer3, 0, 17);
} catch {}
let buffer47 = device0.createBuffer({size: 1016, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView83 = texture65.createView({format: 'rg32sint'});
let renderBundle8 = renderBundleEncoder8.finish({});
try {
computePassEncoder8.setBindGroup(0, bindGroup15);
} catch {}
try {
computePassEncoder16.setBindGroup(2, bindGroup25, new Uint32Array(11), 1, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer18, 0); };
} catch {}
try {
computePassEncoder51.setPipeline(pipeline6);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let pipeline8 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {module: shaderModule0, targets: [{format: 'rgba32float', writeMask: GPUColorWrite.BLUE}]},
  depthStencil: {
    format: 'depth32float',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilReadMask: 39555956,
    stencilWriteMask: 828249429,
    depthBias: -2109240652,
    depthBiasSlopeScale: 46.24789564334364,
  },
  vertex: {module: shaderModule0, constants: {}, buffers: []},
  primitive: {cullMode: 'none'},
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let texture71 = device0.createTexture({
  size: {width: 255},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture72 = device0.createTexture({
  size: [127, 53, 1],
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder5.beginOcclusionQuery(1446);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle4, renderBundle4, renderBundle4]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer21, 0, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
let recycledExplicitBindGroupLayout3 = pipeline5.getBindGroupLayout(0);
let commandEncoder59 = device0.createCommandEncoder();
let textureView84 = texture71.createView({});
let computePassEncoder57 = commandEncoder59.beginComputePass({timestampWrites: {querySet: querySet7, endOfPassWriteIndex: 556}});
try {
computePassEncoder22.setBindGroup(3, bindGroup32, new Uint32Array(1695), 128, 0);
} catch {}
try {
computePassEncoder33.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup28);
} catch {}
try {
renderPassEncoder5.endOcclusionQuery();
} catch {}
try {
externalTexture2.label = '\u{1f95f}\ub741\u0801\u{1fd2e}\udbd6\u{1ff0a}\u0b84';
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 370,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let texture73 = device0.createTexture({
  size: [2240, 1, 1],
  mipLevelCount: 3,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler44 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMaxClamp: 79.63});
try {
computePassEncoder6.setBindGroup(2, bindGroup7);
} catch {}
try {
computePassEncoder22.setBindGroup(0, bindGroup18, new Uint32Array(284), 67, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle4, renderBundle4]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, undefined, 0, 1_483_517_027);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: imageData0,
  origin: { x: 1, y: 1 },
  flipY: true,
}, {
  texture: texture45,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline9 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule0}});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup35 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 3, resource: {buffer: buffer5}},
    {binding: 245, resource: textureView54},
    {binding: 0, resource: textureView64},
  ],
});
let textureView85 = texture61.createView({dimension: '2d', mipLevelCount: 1});
try {
computePassEncoder49.setBindGroup(1, bindGroup12);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint16', 2, 2);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(268).fill(150), /* required buffer size: 268 */
{offset: 268, rowsPerImage: 42}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer48 = device0.createBuffer({size: 173, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder60 = device0.createCommandEncoder({});
let texture74 = device0.createTexture({
  size: [17, 2, 18],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder6 = commandEncoder60.beginRenderPass({
  colorAttachments: [{
  view: textureView81,
  depthSlice: 183,
  clearValue: { r: 158.0, g: 632.7, b: 25.11, a: 174.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 22521169,
});
let externalTexture10 = device0.importExternalTexture({label: '\ua1bc\u0e9f\udccc\u8e9e\u2157\u0a27\uaa9c\u4154\u0562\u{1f907}', source: videoFrame3});
try {
renderPassEncoder1.setVertexBuffer(5, buffer30, 0, 39);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 8, new BigUint64Array(452), 24, 0);
} catch {}
try {
computePassEncoder33.setBindGroup(0, bindGroup23, new Uint32Array(991), 30, 0);
} catch {}
try {
computePassEncoder27.end();
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(54);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder4.setViewport(20.740917324478566, 3.436339084120287, 1.6958546323582098, 0.03876851591953628, 0.01106283799664276, 0.6429437467487747);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(6, buffer19);
} catch {}
try {
commandEncoder27.clearBuffer(buffer10);
} catch {}
let pipeline10 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
let textureView86 = texture71.createView({});
let texture75 = device0.createTexture({size: [510, 214, 40], dimension: '3d', format: 'r32sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView87 = texture24.createView({dimension: '2d', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 24});
let computePassEncoder58 = commandEncoder27.beginComputePass();
try {
renderPassEncoder6.setIndexBuffer(buffer28, 'uint32', 0, 28);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture71,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(29).fill(123), /* required buffer size: 29 */
{offset: 29}, {width: 92, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder61 = device0.createCommandEncoder({});
let texture76 = device0.createTexture({
  size: {width: 142, height: 16, depthOrArrayLayers: 30},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture77 = device0.createTexture({
  size: {width: 71, height: 8, depthOrArrayLayers: 28},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler45 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 89.88,
});
try {
computePassEncoder49.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup12, new Uint32Array(1187), 446, 0);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
commandEncoder61.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 276 */
  offset: 276,
  rowsPerImage: 180,
  buffer: buffer33,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder62 = device0.createCommandEncoder({});
let texture78 = device0.createTexture({
  size: [510, 214, 1],
  mipLevelCount: 1,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture79 = device0.createTexture({
  size: [1120],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder59 = commandEncoder61.beginComputePass();
let renderPassEncoder7 = commandEncoder62.beginRenderPass({
  colorAttachments: [{
  view: textureView82,
  depthSlice: 168,
  clearValue: { r: 640.8, g: 580.7, b: -917.2, a: 25.80, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 133265712,
});
try {
computePassEncoder53.setBindGroup(0, bindGroup35);
} catch {}
try {
computePassEncoder22.end();
} catch {}
try {
computePassEncoder16.setPipeline(pipeline5);
} catch {}
try {
commandEncoder22.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1512 */
  offset: 1512,
  bytesPerRow: 13312,
  buffer: buffer33,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 18, y: 41, z: 0},
  aspect: 'all',
}, {width: 30, height: 12, depthOrArrayLayers: 0});
} catch {}
let bindGroup36 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture5}]});
let textureView88 = texture69.createView({dimension: '3d', mipLevelCount: 1});
let renderPassEncoder8 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView60,
  depthSlice: 8,
  clearValue: { r: 509.5, g: 370.3, b: -320.5, a: 392.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder36.setBindGroup(1, bindGroup32, new Uint32Array(52), 2, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1, 2); };
} catch {}
try {
computePassEncoder28.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup27);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
let bindGroup37 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture6}]});
try {
computePassEncoder1.setBindGroup(3, bindGroup25);
} catch {}
try {
computePassEncoder55.setBindGroup(0, bindGroup28, new Uint32Array(2424), 497, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer45, 'uint32', 36, 1);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(7); };
} catch {}
let bindGroup38 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout2, entries: [{binding: 0, resource: textureView77}]});
let buffer49 = device0.createBuffer({
  size: 20,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let textureView89 = texture30.createView({mipLevelCount: 1});
try {
computePassEncoder26.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder42.setBindGroup(3, bindGroup23, new Uint32Array(440), 10, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1, 4); };
} catch {}
try {
computePassEncoder47.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup29, new Uint32Array(1221), 112, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer44, 'uint32', 60, 2);
} catch {}
let texture80 = device0.createTexture({
  size: [1020, 428, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32sint'],
});
let textureView90 = texture14.createView({});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg16float'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle9 = renderBundleEncoder9.finish({});
let sampler46 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', mipmapFilter: 'nearest'});
try {
computePassEncoder8.setBindGroup(3, bindGroup35);
} catch {}
try {
computePassEncoder9.end();
} catch {}
try {
computePassEncoder30.setPipeline(pipeline7);
} catch {}
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 370,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder63 = device0.createCommandEncoder();
let texture81 = device0.createTexture({
  size: {width: 1120, height: 1, depthOrArrayLayers: 300},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder60 = commandEncoder10.beginComputePass();
let renderPassEncoder9 = commandEncoder63.beginRenderPass({
  colorAttachments: [{
  view: textureView82,
  depthSlice: 38,
  clearValue: { r: -472.9, g: -496.2, b: -565.6, a: 492.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 106263432,
});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthStencilFormat: 'depth32float', sampleCount: 4, depthReadOnly: true});
let sampler47 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 94.89,
});
try {
computePassEncoder59.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle5]);
} catch {}
try {
renderBundleEncoder10.setBindGroup(0, bindGroup8, new Uint32Array(1654), 378, 0);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(5, buffer19, 60, 91);
} catch {}
try {
computePassEncoder11.insertDebugMarker('\u0681');
} catch {}
let commandEncoder64 = device0.createCommandEncoder({});
let querySet14 = device0.createQuerySet({type: 'occlusion', count: 1243});
let renderPassEncoder10 = commandEncoder64.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  depthSlice: 1,
  clearValue: { r: -32.97, g: 401.8, b: 675.3, a: -570.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let renderBundle10 = renderBundleEncoder10.finish({});
try {
computePassEncoder53.setBindGroup(3, bindGroup27);
} catch {}
try {
computePassEncoder39.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer45, 0, 32);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
let buffer50 = device0.createBuffer({size: 56, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture82 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder52.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer44, 'uint32', 4, 16);
} catch {}
try {
computePassEncoder57.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle5, renderBundle7]);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer11, 'uint32', 0, 13);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer14, 56, 56);
} catch {}
document.body.prepend(img1);
let textureView91 = texture36.createView({aspect: 'stencil-only', arrayLayerCount: 4});
try {
computePassEncoder39.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup10, new Uint32Array(174), 39, 0);
} catch {}
let commandEncoder65 = device0.createCommandEncoder({});
let texture83 = device0.createTexture({
  size: {width: 1120, height: 1, depthOrArrayLayers: 129},
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC,
});
let computePassEncoder61 = commandEncoder65.beginComputePass();
try {
computePassEncoder48.setBindGroup(2, bindGroup5, new Uint32Array(355), 46, 0);
} catch {}
try {
computePassEncoder60.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder5.beginOcclusionQuery(1720);
} catch {}
try {
renderPassEncoder5.endOcclusionQuery();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 280, height: 1, depthOrArrayLayers: 5}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline11 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule1}});
let commandEncoder66 = device0.createCommandEncoder({});
try {
computePassEncoder8.setBindGroup(2, bindGroup2, new Uint32Array(2843), 2_630, 0);
} catch {}
try {
computePassEncoder41.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup6, new Uint32Array(10), 1, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer23, 'uint32', 12, 1);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer14);
} catch {}
try {
commandEncoder66.copyBufferToTexture({
  /* bytesInLastRow: 992 widthInBlocks: 62 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1008 */
  offset: 1008,
  bytesPerRow: 13056,
  buffer: buffer47,
}, {
  texture: texture56,
  mipLevel: 0,
  origin: {x: 9, y: 6, z: 0},
  aspect: 'all',
}, {width: 62, height: 47, depthOrArrayLayers: 0});
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let textureView92 = texture27.createView({});
let sampler48 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.46,
  compare: 'less-equal',
  maxAnisotropy: 13,
});
try {
commandEncoder67.copyBufferToBuffer(buffer2, 4, buffer10, 20, 0);
} catch {}
try {
commandEncoder66.insertDebugMarker('\u00d4');
} catch {}
try {
  await promise11;
} catch {}
let commandEncoder68 = device0.createCommandEncoder({});
let texture84 = device0.createTexture({
  size: {width: 35},
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder62 = commandEncoder68.beginComputePass({timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 141}});
let renderPassEncoder11 = commandEncoder67.beginRenderPass({
  colorAttachments: [{
  view: textureView40,
  clearValue: { r: 749.2, g: 169.2, b: 616.9, a: -912.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet12,
  timestampWrites: {querySet: querySet9, endOfPassWriteIndex: 953},
});
try {
renderPassEncoder2.setBindGroup(3, bindGroup6);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup2, new Uint32Array(123), 9, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer14);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
document.body.prepend(img1);
let bindGroup39 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 3, resource: {buffer: buffer46}},
    {binding: 245, resource: textureView54},
    {binding: 0, resource: textureView80},
  ],
});
let commandEncoder69 = device0.createCommandEncoder({});
try {
computePassEncoder14.setBindGroup(0, bindGroup20);
} catch {}
try {
computePassEncoder29.setBindGroup(3, bindGroup27, new Uint32Array(821), 118, 0);
} catch {}
try {
computePassEncoder62.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup1);
} catch {}
try {
renderPassEncoder5.setViewport(7.1651741619451546, 1.7254223468099434, 21.438338851703516, 1.791644689088507, 0.019649235376193674, 0.29223509858340263);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(2, buffer45, 0, 48);
} catch {}
try {
commandEncoder69.copyBufferToTexture({
  /* bytesInLastRow: 392 widthInBlocks: 98 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1784 */
  offset: 1784,
  bytesPerRow: 18176,
  buffer: buffer33,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 98, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer21, 0, new Uint32Array(7671), 66, 0);
} catch {}
let textureView93 = texture16.createView({mipLevelCount: 1});
let computePassEncoder63 = commandEncoder66.beginComputePass({timestampWrites: {querySet: querySet4, endOfPassWriteIndex: 680}});
try {
computePassEncoder62.setBindGroup(1, bindGroup11);
} catch {}
try {
computePassEncoder54.setPipeline(pipeline3);
} catch {}
let bindGroup40 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 370, resource: textureView41}]});
let texture85 = device0.createTexture({
  size: {width: 2240, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder4.setBindGroup(2, bindGroup16);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer3);
} catch {}
let img2 = await imageWithData(138, 9, '#10101010', '#20202020');
let buffer51 = device0.createBuffer({size: 412, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let textureView94 = texture65.createView({});
let textureView95 = texture55.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 5});
let computePassEncoder64 = commandEncoder69.beginComputePass();
try {
computePassEncoder44.setBindGroup(1, bindGroup11, new Uint32Array(1334), 32, 0);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline10);
} catch {}
document.body.prepend(canvas0);
let commandEncoder70 = device0.createCommandEncoder({});
let querySet15 = device0.createQuerySet({type: 'timestamp', count: 687});
let textureView96 = texture76.createView({baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder65 = commandEncoder70.beginComputePass();
try {
renderPassEncoder9.setBindGroup(2, bindGroup38);
} catch {}
try {
renderPassEncoder7.setViewport(127.29276737495815, 178.74336149899398, 31.920942371315757, 44.678508375310805, 0.6878346324256708, 0.8346516373687596);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  label: '\u0d0a\uaf40',
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let querySet16 = device0.createQuerySet({type: 'occlusion', count: 221});
let textureView97 = texture43.createView({aspect: 'all', baseArrayLayer: 0, arrayLayerCount: 1});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({
  colorFormats: ['rgba16uint'],
  depthStencilFormat: 'stencil8',
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder53.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer23, 'uint32', 4, 4);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(4, buffer2, 0, 14);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
} catch {}
let pipeline12 = device0.createRenderPipeline({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment1',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.GREEN,
}],
},
  vertex: {module: shaderModule0, buffers: []},
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'front'},
});
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'linear'} });
let bindGroup41 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 245, resource: textureView73},
    {binding: 0, resource: textureView64},
    {binding: 3, resource: {buffer: buffer30, size: 316}},
  ],
});
let commandEncoder71 = device0.createCommandEncoder();
let computePassEncoder66 = commandEncoder71.beginComputePass();
let renderBundle11 = renderBundleEncoder11.finish({});
try {
renderPassEncoder6.setVertexBuffer(5, buffer44, 0);
} catch {}
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 245,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
try {
computePassEncoder66.setBindGroup(3, bindGroup8);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer34, 0); };
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup37, new Uint32Array(385), 123, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let pipelineLayout5 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout10, recycledExplicitBindGroupLayout3, veryExplicitBindGroupLayout7],
});
let buffer52 = device0.createBuffer({size: 1, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let textureView98 = texture84.createView({});
try {
computePassEncoder50.setBindGroup(0, bindGroup3, []);
} catch {}
try {
computePassEncoder38.setBindGroup(2, bindGroup36, new Uint32Array(559), 13, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer29, 24); };
} catch {}
try {
computePassEncoder66.setPipeline(pipeline2);
} catch {}
let buffer53 = device0.createBuffer({size: 92, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder72 = device0.createCommandEncoder({});
let computePassEncoder67 = commandEncoder72.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 526}});
try {
computePassEncoder61.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup37, new Uint32Array(352), 18, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer31);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm'],
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 1, depthOrArrayLayers: 2}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let sampler49 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'always',
  maxAnisotropy: 11,
});
try {
computePassEncoder14.setBindGroup(0, bindGroup38);
} catch {}
try {
computePassEncoder56.setBindGroup(1, bindGroup33, new Uint32Array(983), 102, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup4, new Uint32Array(3252), 229, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer23, 'uint16', 14, 20);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline12);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(16); };
} catch {}
let imageBitmap0 = await createImageBitmap(videoFrame8);
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'gamma22curve'} });
let buffer54 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false});
try {
renderPassEncoder11.setBindGroup(3, bindGroup41);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup19, new Uint32Array(1312), 136, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer2);
} catch {}
let commandEncoder73 = device0.createCommandEncoder({});
try {
computePassEncoder54.setBindGroup(0, bindGroup34);
} catch {}
try {
computePassEncoder67.setBindGroup(0, bindGroup33, new Uint32Array(1564), 78, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup26, new Uint32Array(1367), 67, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer3, 0);
} catch {}
try {
buffer25.unmap();
} catch {}
let querySet17 = device0.createQuerySet({type: 'occlusion', count: 908});
let textureView99 = texture61.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder64.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup14, []);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer50, 8, 7);
} catch {}
try {
device0.queue.writeBuffer(buffer21, 0, new DataView(new ArrayBuffer(3934)), 439, 0);
} catch {}
let commandEncoder74 = device0.createCommandEncoder();
let textureView100 = texture69.createView({dimension: '3d', format: 'r32sint', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder54); computePassEncoder54.dispatchWorkgroupsIndirect(buffer30, 20); };
} catch {}
try {
computePassEncoder67.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup28, new Uint32Array(1301), 28, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 14},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture86 = device0.createTexture({
  size: {width: 510, height: 214, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView101 = texture2.createView({label: '\ue385\ua723\u4675\u{1feaa}\u4e3c\u00de\ufde6', dimension: '2d-array', format: 'rgba16float'});
let computePassEncoder68 = commandEncoder73.beginComputePass();
let sampler50 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 77.51,
  lodMaxClamp: 91.84,
  maxAnisotropy: 5,
});
try {
computePassEncoder14.end();
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer12, 'uint32', 4, 3);
} catch {}
try {
commandEncoder74.clearBuffer(buffer24);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 28, new Uint32Array(4453), 1209, 0);
} catch {}
document.body.prepend(canvas0);
let buffer55 = device0.createBuffer({size: 236, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder75 = device0.createCommandEncoder({});
let computePassEncoder69 = commandEncoder74.beginComputePass();
let renderPassEncoder12 = commandEncoder15.beginRenderPass({
  colorAttachments: [{
  view: textureView100,
  depthSlice: 341,
  clearValue: { r: 543.4, g: 743.5, b: -372.3, a: 146.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder5.setBindGroup(1, bindGroup29);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup26, new Uint32Array(5532), 800, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(7, undefined, 0, 1_966_069_328);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
document.body.prepend(img2);
let canvas1 = document.createElement('canvas');
let commandEncoder76 = device0.createCommandEncoder({});
let texture87 = device0.createTexture({
  size: [35, 4, 36],
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder70 = commandEncoder75.beginComputePass();
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthStencilFormat: 'depth32float', sampleCount: 4});
try {
renderPassEncoder5.setBindGroup(2, bindGroup27);
} catch {}
try {
renderPassEncoder7.setViewport(233.97920080957016, 229.69353238679204, 9.47510389340198, 18.664358626248745, 0.3632475471721157, 0.49490145018219733);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer45, 'uint32', 48, 96);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup9, new Uint32Array(412), 65, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer36, 'uint32', 0, 22);
} catch {}
try {
buffer11.unmap();
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
let computePassEncoder71 = commandEncoder77.beginComputePass({timestampWrites: {querySet: querySet3}});
let renderBundle12 = renderBundleEncoder12.finish();
try {
computePassEncoder54.end();
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle5, renderBundle5]);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer28, 'uint16', 10, 7);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline12);
} catch {}
let gpuCanvasContext3 = canvas1.getContext('webgpu');
let querySet18 = device0.createQuerySet({type: 'occlusion', count: 380});
let texture88 = device0.createTexture({
  size: [1020],
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture89 = device0.createTexture({
  size: {width: 1020, height: 428, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView102 = texture25.createView({});
try {
computePassEncoder65.setPipeline(pipeline7);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup42 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 0, resource: textureView5}]});
let commandBuffer3 = commandEncoder57.finish();
let sampler51 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 81.07,
  compare: 'always',
  maxAnisotropy: 20,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup40);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder58.setPipeline(pipeline11);
} catch {}
try {
commandEncoder76.copyBufferToTexture({
  /* bytesInLastRow: 448 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 464 */
  offset: 464,
  bytesPerRow: 17408,
  buffer: buffer6,
}, {
  texture: texture56,
  mipLevel: 0,
  origin: {x: 13, y: 2, z: 0},
  aspect: 'all',
}, {width: 28, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder76.resolveQuerySet(querySet18, 42, 0, buffer52, 0);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let buffer56 = device0.createBuffer({size: 216, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder78 = device0.createCommandEncoder();
let renderPassEncoder13 = commandEncoder76.beginRenderPass({
  colorAttachments: [{
  view: textureView60,
  depthSlice: 19,
  clearValue: { r: 891.7, g: 613.5, b: 222.5, a: 667.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 508538057,
});
try {
computePassEncoder36.setBindGroup(0, bindGroup35);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup19, new Uint32Array(5214), 499, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer44, 'uint32', 60, 34);
} catch {}
let bindGroup43 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 30, resource: textureView65}]});
let computePassEncoder72 = commandEncoder78.beginComputePass({
  timestampWrites: {querySet: querySet13, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 17},
});
try {
computePassEncoder49.setBindGroup(0, bindGroup21);
} catch {}
try {
computePassEncoder18.setBindGroup(0, bindGroup3, new Uint32Array(293), 22, 0);
} catch {}
try {
computePassEncoder28.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder7.setViewport(178.2365829240564, 230.6650753021921, 48.44000740735466, 18.962584511258694, 0.8150084926266413, 0.8411268316361201);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(3, buffer44);
} catch {}
try {
buffer56.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(695).fill(221), /* required buffer size: 695 */
{offset: 695}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer57 = device0.createBuffer({size: 136, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder79 = device0.createCommandEncoder({});
let textureView103 = texture84.createView({mipLevelCount: 1});
try {
computePassEncoder19.setBindGroup(1, bindGroup16);
} catch {}
try {
computePassEncoder50.setBindGroup(2, bindGroup35, new Uint32Array(1535), 54, 0);
} catch {}
try {
buffer34.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer41, 0, new BigUint64Array(18298), 9808, 0);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let computePassEncoder73 = commandEncoder79.beginComputePass({timestampWrites: {querySet: querySet3, endOfPassWriteIndex: 600}});
try {
computePassEncoder56.setBindGroup(2, bindGroup37, []);
} catch {}
try {
computePassEncoder15.setPipeline(pipeline10);
} catch {}
try {
computePassEncoder69.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer45, 'uint16', 10, 7);
} catch {}
try {
buffer5.unmap();
} catch {}
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 245,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer58 = device0.createBuffer({
  size: 24,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder80 = device0.createCommandEncoder();
let texture90 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 12},
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let computePassEncoder74 = commandEncoder80.beginComputePass();
try {
computePassEncoder52.setBindGroup(1, bindGroup17);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder49); computePassEncoder49.dispatchWorkgroupsIndirect(buffer18, 16); };
} catch {}
try {
computePassEncoder73.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup31);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup38, new Uint32Array(121), 12, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(6, buffer45);
} catch {}
try {
computePassEncoder39.pushDebugGroup('\u512e');
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
try {
gpuCanvasContext3.unconfigure();
} catch {}
let texture91 = device0.createTexture({size: [255], dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
let textureView104 = texture40.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder49); computePassEncoder49.dispatchWorkgroupsIndirect(buffer9, 9_440); };
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup25, new Uint32Array(780), 189, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer25, 'uint32', 12, 31);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline12);
} catch {}
try {
adapter0.label = '\u07e6\u{1fbac}\u3a2c\u3112\u{1fb76}\u{1fbd0}';
} catch {}
let commandEncoder81 = device0.createCommandEncoder({});
let computePassEncoder75 = commandEncoder81.beginComputePass();
try {
computePassEncoder15.setBindGroup(2, bindGroup36);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup3, new Uint32Array(1071), 489, 0);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(27); };
} catch {}
document.body.prepend(img1);
let texture92 = device0.createTexture({
  size: [8, 6, 1],
  format: 'astc-8x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['astc-8x6-unorm'],
});
let sampler52 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 16,
});
try {
computePassEncoder49.end();
} catch {}
try {
computePassEncoder68.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline12);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
renderPassEncoder6.insertDebugMarker('\ud53d');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let bindGroup44 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 245, resource: textureView53},
    {binding: 0, resource: textureView80},
    {binding: 3, resource: {buffer: buffer3}},
  ],
});
let texture93 = device0.createTexture({
  size: [280, 1, 1],
  sampleCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder76 = commandEncoder50.beginComputePass({timestampWrites: {querySet: querySet15, beginningOfPassWriteIndex: 160}});
try {
renderPassEncoder12.executeBundles([renderBundle6, renderBundle5, renderBundle6]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 510, height: 214, depthOrArrayLayers: 1}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 39, y: 165, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let textureView105 = texture65.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder56.setBindGroup(0, bindGroup29);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle9]);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer48, 'uint32', 20, 12);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline12);
} catch {}
let texture94 = device0.createTexture({size: [17], dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
let texture95 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder50.setBindGroup(3, bindGroup41);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer14, 0, 42);
} catch {}
await gc();
let commandEncoder82 = device0.createCommandEncoder({});
let computePassEncoder77 = commandEncoder82.beginComputePass({timestampWrites: {querySet: querySet13}});
try {
computePassEncoder72.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder76.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup28, new Uint32Array(1985), 69, 0);
} catch {}
try {
computePassEncoder39.popDebugGroup();
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 1, depthOrArrayLayers: 2}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture49,
  mipLevel: 3,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder83 = device0.createCommandEncoder({});
let renderPassEncoder14 = commandEncoder83.beginRenderPass({
  colorAttachments: [{
  view: textureView40,
  clearValue: { r: -206.8, g: -735.9, b: 875.6, a: -695.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 806},
});
try {
computePassEncoder19.setBindGroup(2, bindGroup17);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup1);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle6, renderBundle5, renderBundle5]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture71,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(426).fill(179), /* required buffer size: 426 */
{offset: 426}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 140, height: 1, depthOrArrayLayers: 2}
*/
{
  source: imageData5,
  origin: { x: 4, y: 2 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 1,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer59 = device0.createBuffer({size: 190, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder84 = device0.createCommandEncoder({});
let texture96 = device0.createTexture({
  size: [256],
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder78 = commandEncoder84.beginComputePass();
let sampler53 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat'});
try {
computePassEncoder70.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer11, 'uint16', 8, 1);
} catch {}
let pipeline13 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule1}});
document.body.append(img1);
let externalTexture11 = device0.importExternalTexture({source: videoFrame13});
try {
computePassEncoder8.setBindGroup(2, bindGroup44);
} catch {}
try {
computePassEncoder36.setBindGroup(0, bindGroup6, new Uint32Array(1199), 304, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle9]);
} catch {}
document.body.prepend(img2);
await gc();
let textureView106 = texture74.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder72.setPipeline(pipeline9);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture78,
  mipLevel: 0,
  origin: {x: 28, y: 46, z: 0},
  aspect: 'all',
}, new Uint8Array(73).fill(172), /* required buffer size: 73 */
{offset: 73, bytesPerRow: 984}, {width: 122, height: 6, depthOrArrayLayers: 0});
} catch {}
document.body.append(img1);
let bindGroup45 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 5, resource: externalTexture10}]});
let texture97 = device0.createTexture({
  size: [256, 256, 25],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder5.setBindGroup(0, bindGroup10, new Uint32Array(1003), 122, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup41, new Uint32Array(3222), 1_145, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer11, 'uint32', 0, 0);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline12);
} catch {}
let bindGroup46 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 5, resource: externalTexture2}]});
let sampler54 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 78.59,
});
try {
{ clearResourceUsages(device0, computePassEncoder72); computePassEncoder72.dispatchWorkgroupsIndirect(buffer34, 0); };
} catch {}
try {
computePassEncoder72.end();
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup15, new Uint32Array(181), 5, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle9, renderBundle9, renderBundle9, renderBundle9, renderBundle4, renderBundle9]);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer58, 0, 0);
} catch {}
try {
commandEncoder78.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1612 */
  offset: 1612,
  bytesPerRow: 10240,
  rowsPerImage: 1476,
  buffer: buffer33,
}, {
  texture: texture49,
  mipLevel: 4,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: imageData7,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(73); };
} catch {}
document.body.append(img1);
let commandEncoder85 = device0.createCommandEncoder({});
let computePassEncoder79 = commandEncoder78.beginComputePass({timestampWrites: {querySet: querySet9, endOfPassWriteIndex: 206}});
try {
computePassEncoder19.setBindGroup(2, bindGroup28, new Uint32Array(198), 11, 0);
} catch {}
try {
computePassEncoder78.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup42, new Uint32Array(1067), 753, 0);
} catch {}
try {
commandEncoder85.copyBufferToTexture({
  /* bytesInLastRow: 556 widthInBlocks: 139 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 8976 */
  offset: 8976,
  buffer: buffer33,
}, {
  texture: texture20,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 0},
  aspect: 'all',
}, {width: 139, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise13;
} catch {}
offscreenCanvas0.width = 288;
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 370,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let recycledExplicitBindGroupLayout4 = pipeline2.getBindGroupLayout(0);
let bindGroup47 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 4, resource: externalTexture11}]});
let commandEncoder86 = device0.createCommandEncoder({});
let computePassEncoder80 = commandEncoder86.beginComputePass();
let sampler55 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
});
try {
computePassEncoder38.setBindGroup(1, bindGroup32, new Uint32Array(26), 0, 0);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setViewport(112.85301175844243, 9.00457797067079, 5.650068983865833, 2.2284904691968292, 0.06060185824021502, 0.3715010029096456);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer30, 0, 160);
} catch {}
try {
commandEncoder85.copyBufferToTexture({
  /* bytesInLastRow: 1984 widthInBlocks: 124 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 4560 */
  offset: 4560,
  bytesPerRow: 15104,
  buffer: buffer33,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 15, y: 12, z: 10},
  aspect: 'all',
}, {width: 124, height: 299, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(16); };
} catch {}
let buffer60 = device0.createBuffer({
  size: 360,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture98 = device0.createTexture({
  size: {width: 1120, height: 1, depthOrArrayLayers: 54},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView107 = texture61.createView({format: 'r16uint', mipLevelCount: 1});
let computePassEncoder81 = commandEncoder85.beginComputePass();
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
});
} catch {}
let commandEncoder87 = device0.createCommandEncoder({});
let texture99 = device0.createTexture({
  size: [216, 1420, 1],
  mipLevelCount: 11,
  dimension: '2d',
  format: 'astc-12x10-unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView108 = texture79.createView({});
let renderPassEncoder15 = commandEncoder87.beginRenderPass({
  colorAttachments: [{
  view: textureView82,
  depthSlice: 136,
  clearValue: { r: -818.4, g: -809.7, b: 658.7, a: -864.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet14,
  timestampWrites: {querySet: querySet13, endOfPassWriteIndex: 26},
  maxDrawCount: 484601033,
});
try {
renderPassEncoder14.setBindGroup(0, bindGroup31);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle9]);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(6, buffer50, 0, 18);
} catch {}
let commandEncoder88 = device0.createCommandEncoder();
let computePassEncoder82 = commandEncoder88.beginComputePass();
try {
computePassEncoder66.setBindGroup(3, bindGroup32, new Uint32Array(105), 18, 0);
} catch {}
try {
computePassEncoder79.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer45, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 188, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(138).fill(122), /* required buffer size: 138 */
{offset: 138}, {width: 161, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise12;
} catch {}
let commandEncoder89 = device0.createCommandEncoder({});
let computePassEncoder83 = commandEncoder89.beginComputePass();
try {
computePassEncoder55.setBindGroup(0, bindGroup25, new Uint32Array(713), 66, 0);
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'film', transfer: 'iec6196624'} });
let autogeneratedBindGroupLayout0 = pipeline7.getBindGroupLayout(0);
let bindGroup48 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView77}]});
let querySet19 = device0.createQuerySet({type: 'occlusion', count: 439});
let texture100 = device0.createTexture({size: [142, 16, 146], dimension: '3d', format: 'rgba32float', usage: GPUTextureUsage.COPY_DST});
let sampler56 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'nearest',
});
try {
computePassEncoder52.setBindGroup(0, bindGroup18, new Uint32Array(3370), 808, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer57, 'uint16', 4, 3);
} catch {}
try {
  await promise14;
} catch {}
let buffer61 = device0.createBuffer({
  size: 392,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder90 = device0.createCommandEncoder();
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle13 = renderBundleEncoder13.finish({});
try {
computePassEncoder81.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline12);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let bindGroup49 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 0, resource: textureView16}]});
let textureView109 = texture72.createView({});
try {
computePassEncoder77.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup45);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer36, 'uint32', 28, 4);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer19, 4, 117);
} catch {}
try {
commandEncoder90.copyTextureToTexture({
  texture: texture30,
  mipLevel: 1,
  origin: {x: 2, y: 4, z: 0},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 3,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture69,
  mipLevel: 0,
  origin: {x: 6, y: 2, z: 18},
  aspect: 'all',
}, new Uint8Array(6_759_513).fill(55), /* required buffer size: 6_759_513 */
{offset: 67, bytesPerRow: 546, rowsPerImage: 121}, {width: 128, height: 38, depthOrArrayLayers: 103});
} catch {}
let bindGroup50 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView5}]});
let commandEncoder91 = device0.createCommandEncoder();
let textureView110 = texture68.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 19, arrayLayerCount: 1});
let sampler57 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 76.83,
  compare: 'not-equal',
  maxAnisotropy: 2,
});
try {
computePassEncoder83.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup48, new Uint32Array(2277), 422, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, buffer61, 60);
} catch {}
try {
commandEncoder91.copyTextureToTexture({
  texture: texture58,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture70,
  mipLevel: 0,
  origin: {x: 37, y: 13, z: 0},
  aspect: 'all',
},
{width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
canvas1.height = 76;
let textureView111 = texture61.createView({mipLevelCount: 2});
try {
computePassEncoder81.setBindGroup(0, bindGroup19, new Uint32Array(1542), 157, 0);
} catch {}
try {
computePassEncoder75.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup33);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup36, new Uint32Array(262), 14, 0);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline12);
} catch {}
try {
commandEncoder91.copyBufferToTexture({
  /* bytesInLastRow: 896 widthInBlocks: 112 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2688 */
  offset: 2688,
  buffer: buffer33,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 193, y: 0, z: 0},
  aspect: 'all',
}, {width: 112, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([]);
} catch {}
document.body.append(canvas1);
let buffer62 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder92 = device0.createCommandEncoder({});
let computePassEncoder84 = commandEncoder92.beginComputePass();
try {
computePassEncoder71.setBindGroup(3, bindGroup25);
} catch {}
try {
computePassEncoder66.setBindGroup(2, bindGroup28, new Uint32Array(3879), 287, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer61, 12, 65);
} catch {}
try {
commandEncoder90.copyBufferToBuffer(buffer47, 244, buffer38, 0, 20);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let texture101 = device0.createTexture({
  size: [510, 214, 1],
  format: 'rg8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let computePassEncoder85 = commandEncoder91.beginComputePass();
try {
computePassEncoder82.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer40, 'uint32', 0, 11);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer60, 0, 26);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
buffer45.unmap();
} catch {}
try {
commandEncoder90.clearBuffer(buffer41);
} catch {}
let img3 = await imageWithData(3, 5, '#10101010', '#20202020');
let buffer63 = device0.createBuffer({size: 104, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let querySet20 = device0.createQuerySet({type: 'timestamp', count: 2461});
try {
renderPassEncoder15.setScissorRect(47, 27, 63, 60);
} catch {}
try {
commandEncoder90.copyTextureToTexture({
  texture: texture89,
  mipLevel: 1,
  origin: {x: 0, y: 110, z: 0},
  aspect: 'stencil-only',
},
{
  texture: texture89,
  mipLevel: 1,
  origin: {x: 0, y: 91, z: 0},
  aspect: 'all',
},
{width: 510, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder93 = device0.createCommandEncoder({});
let texture102 = device0.createTexture({
  size: {width: 127, height: 53, depthOrArrayLayers: 67},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder16 = commandEncoder93.beginRenderPass({
  colorAttachments: [{view: textureView40, loadOp: 'clear', storeOp: 'store'}],
  timestampWrites: {querySet: querySet10, beginningOfPassWriteIndex: 1141},
});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthStencilFormat: 'depth32float', sampleCount: 4});
try {
computePassEncoder5.setBindGroup(2, bindGroup41, []);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder14.setViewport(121.83690530761783, 5.09786370720135, 1.9903361465339395, 3.043027400776144, 0.4782781375941172, 0.976961417926523);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer22, 'uint32', 4, 2);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup30);
} catch {}
try {
commandEncoder90.resolveQuerySet(querySet10, 791, 0, buffer34, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup51 = device0.createBindGroup({layout: veryExplicitBindGroupLayout12, entries: [{binding: 370, resource: textureView86}]});
let buffer64 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let computePassEncoder86 = commandEncoder90.beginComputePass({timestampWrites: {querySet: querySet15, endOfPassWriteIndex: 299}});
let sampler58 = device0.createSampler({addressModeV: 'repeat', minFilter: 'nearest', lodMaxClamp: 45.37});
try {
computePassEncoder52.end();
} catch {}
try {
computePassEncoder38.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer11, 'uint16', 6, 2);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(6, buffer19, 0, 69);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline1);
} catch {}
let pipeline14 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}});
let textureView112 = texture15.createView({baseMipLevel: 0, mipLevelCount: 1});
let renderPassEncoder17 = commandEncoder55.beginRenderPass({
  colorAttachments: [{
  view: textureView82,
  depthSlice: 243,
  clearValue: { r: 350.3, g: 116.5, b: 37.85, a: 620.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet5,
  timestampWrites: {querySet: querySet10},
  maxDrawCount: 12051896,
});
let sampler59 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 90.94});
let externalTexture12 = device0.importExternalTexture({source: videoFrame9, colorSpace: 'srgb'});
try {
computePassEncoder0.setBindGroup(0, bindGroup11, new Uint32Array(1638), 236, 0);
} catch {}
try {
computePassEncoder74.setPipeline(pipeline7);
} catch {}
let bindGroup52 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView16}]});
let buffer65 = device0.createBuffer({size: 17808, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder94 = device0.createCommandEncoder({});
let textureView113 = texture96.createView({});
let externalTexture13 = device0.importExternalTexture({source: videoFrame7});
try {
computePassEncoder24.setBindGroup(2, bindGroup36);
} catch {}
try {
computePassEncoder86.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup52);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle6, renderBundle13, renderBundle5]);
} catch {}
try {
renderPassEncoder7.setStencilReference(1439);
} catch {}
try {
renderPassEncoder7.setViewport(125.70462450714803, 145.28534244179224, 82.8505947113362, 73.94516875136536, 0.21016157198175678, 0.698869899968984);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer0, 'uint16', 10, 4);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup27);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer44, 'uint16', 6, 1);
} catch {}
try {
buffer30.unmap();
} catch {}
let recycledExplicitBindGroupLayout5 = pipeline2.getBindGroupLayout(0);
let commandEncoder95 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 12},
  mipLevelCount: 2,
  format: 'rg16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle14 = renderBundleEncoder14.finish({});
try {
computePassEncoder66.setBindGroup(2, bindGroup32);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle4, renderBundle4]);
} catch {}
try {
buffer44.unmap();
} catch {}
try {
commandEncoder94.copyTextureToBuffer({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 160 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 4064 */
  offset: 3904,
  bytesPerRow: 2048,
  buffer: buffer65,
}, {width: 10, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder95.clearBuffer(buffer65, 244);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup53 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout2, entries: [{binding: 0, resource: textureView77}]});
let externalTexture14 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder85.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: 850.4, g: -679.3, b: 467.8, a: 888.6, });
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer28, 'uint16', 30, 3);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer45);
} catch {}
try {
commandEncoder94.copyBufferToBuffer(buffer48, 0, buffer21, 0, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture71,
  mipLevel: 0,
  origin: {x: 35, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(217).fill(145), /* required buffer size: 217 */
{offset: 217}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas2 = document.createElement('canvas');
let offscreenCanvas2 = new OffscreenCanvas(107, 1024);
let buffer66 = device0.createBuffer({size: 112, usage: GPUBufferUsage.INDEX});
try {
computePassEncoder19.setBindGroup(2, bindGroup33, new Uint32Array(2607), 365, 0);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline12);
} catch {}
try {
commandEncoder95.copyBufferToTexture({
  /* bytesInLastRow: 256 widthInBlocks: 64 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1636 */
  offset: 1636,
  bytesPerRow: 28672,
  buffer: buffer33,
}, {
  texture: texture20,
  mipLevel: 0,
  origin: {x: 114, y: 0, z: 0},
  aspect: 'all',
}, {width: 64, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder94.copyTextureToBuffer({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 0, y: 32, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 2040 widthInBlocks: 510 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3572 */
  offset: 3572,
  bytesPerRow: 83712,
  buffer: buffer65,
}, {width: 510, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 35, height: 4, depthOrArrayLayers: 36}
*/
{
  source: videoFrame11,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture45,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 4},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup54 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 0, resource: textureView5}]});
let commandEncoder96 = device0.createCommandEncoder();
let textureView114 = texture79.createView({});
let computePassEncoder87 = commandEncoder95.beginComputePass({timestampWrites: {querySet: querySet4}});
try {
computePassEncoder53.setBindGroup(0, bindGroup17, new Uint32Array(53), 21, 0);
} catch {}
try {
externalTexture6.label = '\ued64\u3673\u02cc\u{1fdef}\u{1f77f}';
} catch {}
let buffer67 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let computePassEncoder88 = commandEncoder96.beginComputePass();
let renderPassEncoder18 = commandEncoder94.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  depthSlice: 26,
  clearValue: { r: -461.7, g: -748.9, b: 813.4, a: 312.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet20},
});
try {
computePassEncoder81.setBindGroup(2, bindGroup43);
} catch {}
try {
computePassEncoder31.setBindGroup(0, bindGroup29, new Uint32Array(382), 34, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup11);
} catch {}
try {
renderPassEncoder7.setScissorRect(33, 48, 21, 24);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer19, 24, 129);
} catch {}
let gpuCanvasContext4 = canvas2.getContext('webgpu');
await gc();
let commandEncoder97 = device0.createCommandEncoder({});
let texture104 = device0.createTexture({
  size: {width: 65, height: 40, depthOrArrayLayers: 57},
  format: 'astc-5x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView115 = texture57.createView({baseArrayLayer: 2, arrayLayerCount: 2});
let computePassEncoder89 = commandEncoder97.beginComputePass();
let sampler60 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 91.40,
});
let promise15 = shaderModule1.getCompilationInfo();
try {
buffer41.unmap();
} catch {}
let commandEncoder98 = device0.createCommandEncoder({});
let computePassEncoder90 = commandEncoder98.beginComputePass();
try {
computePassEncoder21.setBindGroup(0, bindGroup38, new Uint32Array(794), 18, 0);
} catch {}
try {
computePassEncoder84.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup15);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(18);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle13, renderBundle7]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer23, 'uint32', 0, 5);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline12);
} catch {}
try {
  await promise15;
} catch {}
let buffer68 = device0.createBuffer({size: 284, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder99 = device0.createCommandEncoder({});
let computePassEncoder91 = commandEncoder99.beginComputePass();
try {
computePassEncoder39.setBindGroup(1, bindGroup33, new Uint32Array(2214), 53, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup40, new Uint32Array(2311), 190, 0);
} catch {}
try {
renderPassEncoder5.setViewport(17.378712299591843, 1.6696549268152627, 16.933595227437834, 0.024851702589397673, 0.4679843239596071, 0.8798851935438554);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer17, 'uint16', 0, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
await gc();
let texture105 = device0.createTexture({
  size: [142, 16, 1],
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let texture106 = gpuCanvasContext2.getCurrentTexture();
let textureView116 = texture91.createView({});
try {
computePassEncoder75.setBindGroup(0, bindGroup0, []);
} catch {}
try {
computePassEncoder89.setBindGroup(1, bindGroup43, new Uint32Array(2683), 592, 0);
} catch {}
try {
computePassEncoder16.end();
} catch {}
try {
computePassEncoder89.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(452), 59, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline12);
} catch {}
let bindGroup55 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 5, resource: externalTexture11}]});
let commandEncoder100 = device0.createCommandEncoder({});
let computePassEncoder92 = commandEncoder16.beginComputePass();
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rg16float']});
try {
{ clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroups(2, 1, 1); };
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder9.setScissorRect(99, 13, 8, 37);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer31, 0);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup34);
} catch {}
let gpuCanvasContext5 = offscreenCanvas2.getContext('webgpu');
let commandEncoder101 = device0.createCommandEncoder({});
let texture107 = device0.createTexture({size: [1020, 428, 1], sampleCount: 1, format: 'rgba16uint', usage: GPUTextureUsage.COPY_SRC});
let textureView117 = texture15.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder70.setBindGroup(2, bindGroup47, new Uint32Array(2061), 242, 0);
} catch {}
try {
computePassEncoder50.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder18.setViewport(4.727387487818003, 2.526488492320639, 14.146545773236259, 1.2070517966967904, 0.3257979647659003, 0.7289297496867972);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer28, 'uint32', 36, 37);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(2, buffer44, 24);
} catch {}
try {
commandEncoder100.copyBufferToBuffer(buffer13, 72, buffer42, 20, 0);
} catch {}
try {
computePassEncoder34.pushDebugGroup('\u0a40');
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(168, 194);
let commandEncoder102 = device0.createCommandEncoder();
try {
computePassEncoder81.setBindGroup(3, bindGroup51, new Uint32Array(3438), 109, 0);
} catch {}
try {
renderPassEncoder5.beginOcclusionQuery(1514);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer17, 'uint32', 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 28, new BigUint64Array(7954), 2086, 0);
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
let bindGroup56 = device0.createBindGroup({layout: veryExplicitBindGroupLayout16, entries: [{binding: 370, resource: textureView84}]});
let commandEncoder103 = device0.createCommandEncoder({});
let texture108 = device0.createTexture({
  size: {width: 127},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder93 = commandEncoder100.beginComputePass();
let renderPassEncoder19 = commandEncoder102.beginRenderPass({
  colorAttachments: [{
  view: textureView82,
  depthSlice: 218,
  clearValue: { r: 462.0, g: 744.0, b: -25.30, a: -779.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet13, beginningOfPassWriteIndex: 24},
});
let externalTexture15 = device0.importExternalTexture({source: videoFrame12, colorSpace: 'display-p3'});
try {
computePassEncoder39.setBindGroup(0, bindGroup13, new Uint32Array(2198), 140, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup21);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup49, new Uint32Array(1573), 260, 0);
} catch {}
try {
renderPassEncoder5.endOcclusionQuery();
} catch {}
try {
commandEncoder101.copyTextureToTexture({
  texture: texture76,
  mipLevel: 0,
  origin: {x: 2, y: 4, z: 1},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 1,
  origin: {x: 206, y: 0, z: 0},
  aspect: 'all',
},
{width: 64, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let pipeline15 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{
  format: 'rgba32float',
  blend: {
    color: {operation: 'add', srcFactor: 'dst', dstFactor: 'dst-alpha'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'zero'},
  },
  writeMask: GPUColorWrite.ALPHA,
}],
},
  depthStencil: {
    format: 'depth32float',
    depthWriteEnabled: false,
    stencilWriteMask: 680676572,
    depthBias: -1802379881,
    depthBiasClamp: 0.0,
  },
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex2',
    constants: {},
    buffers: [{arrayStride: 592, attributes: [{format: 'float32x3', offset: 96, shaderLocation: 12}]}],
  },
  primitive: {topology: 'line-list', cullMode: 'none'},
});
let gpuCanvasContext6 = offscreenCanvas3.getContext('webgpu');
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let querySet21 = device0.createQuerySet({type: 'occlusion', count: 568});
let texture109 = device0.createTexture({
  size: {width: 510, height: 214, depthOrArrayLayers: 56},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView118 = texture60.createView({dimension: '2d', aspect: 'depth-only'});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({
  label: '\ub3a8\uab4d\u0bfc\u{1fd3a}\u778f\u{1fb9b}\u0f3b',
  colorFormats: ['rgba32float'],
  depthStencilFormat: 'depth32float',
  sampleCount: 4,
  depthReadOnly: true,
});
let sampler61 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 66.54});
try {
computePassEncoder53.setBindGroup(1, bindGroup27);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle4, renderBundle9, renderBundle4, renderBundle4, renderBundle4, renderBundle4, renderBundle9, renderBundle4]);
} catch {}
try {
commandEncoder103.copyTextureToBuffer({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 180 */
  offset: 180,
  bytesPerRow: 14336,
  buffer: buffer60,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 510, height: 214, depthOrArrayLayers: 1}
*/
{
  source: videoFrame10,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 96, y: 26, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
videoFrame0.close();
videoFrame2.close();
videoFrame3.close();
videoFrame5.close();
videoFrame6.close();
videoFrame8.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
videoFrame16.close();
}
async function worker0() {
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth32float-stencil8',
    'texture-compression-etc2',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
    'timestamp-query',
  ],
  requiredLimits: {
    maxVertexBuffers: 8,
    maxUniformBufferBindingSize: 1013787,
    maxStorageBufferBindingSize: 145970020,
    maxUniformBuffersPerShaderStage: 12,
    maxSampledTexturesPerShaderStage: 16,
  },
});
let commandEncoder0 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: [1, 180, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let commandEncoder1 = device0.createCommandEncoder();
let texture1 = device0.createTexture({
  size: {width: 1, height: 90, depthOrArrayLayers: 51},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture2 = device0.createTexture({
  size: {width: 1, height: 45, depthOrArrayLayers: 48},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder0 = commandEncoder0.beginComputePass();
let commandEncoder2 = device0.createCommandEncoder();
let sampler0 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'greater-equal',
  maxAnisotropy: 18,
});
let texture3 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 14},
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView0 = texture3.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1});
let computePassEncoder1 = commandEncoder2.beginComputePass();
try {
device0.queue.submit([]);
} catch {}
let commandEncoder3 = device0.createCommandEncoder({});
let texture4 = device0.createTexture({
  size: [9, 241, 1],
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder0 = commandEncoder3.beginRenderPass({
  colorAttachments: [{
  view: textureView0,
  clearValue: { r: 732.5, g: 860.4, b: 410.0, a: -317.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let imageData0 = new ImageData(48, 36);
let textureView1 = texture1.createView({baseMipLevel: 0, mipLevelCount: 1});
let texture5 = device0.createTexture({
  size: {width: 9, height: 241, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView2 = texture2.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder2 = commandEncoder1.beginComputePass();
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true});
let renderBundle0 = renderBundleEncoder0.finish();
let textureView3 = texture4.createView({aspect: 'all'});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder0.setVertexBuffer(7, undefined);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 7, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {binding: 18, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 21,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 22,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 40,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 66,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 133,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 310,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 420,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 522,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let commandEncoder4 = device0.createCommandEncoder({});
let textureView4 = texture4.createView({dimension: '2d-array'});
let computePassEncoder3 = commandEncoder4.beginComputePass();
let sampler1 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', compare: 'less-equal'});
try {
renderPassEncoder0.executeBundles([renderBundle0, renderBundle0, renderBundle0]);
} catch {}
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let commandEncoder5 = device0.createCommandEncoder({});
let sampler2 = device0.createSampler({addressModeU: 'mirror-repeat', magFilter: 'linear', minFilter: 'linear', lodMaxClamp: 67.42});
let textureView5 = texture0.createView({});
let renderPassEncoder1 = commandEncoder5.beginRenderPass({colorAttachments: [{view: textureView0, loadOp: 'clear', storeOp: 'discard'}]});
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 62, z: 0},
  aspect: 'all',
}, new Uint8Array(297).fill(82), /* required buffer size: 297 */
{offset: 297, bytesPerRow: 36}, {width: 1, height: 8, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 7, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {binding: 18, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 21,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 22,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 40,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 66,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 133,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 310,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 420,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 522,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let commandEncoder6 = device0.createCommandEncoder({});
let texture6 = device0.createTexture({
  size: [1, 90, 276],
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder2 = commandEncoder6.beginRenderPass({
  colorAttachments: [{
  view: textureView0,
  clearValue: { r: 122.2, g: -433.6, b: 52.48, a: -865.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let renderBundle1 = renderBundleEncoder1.finish({});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let commandEncoder7 = device0.createCommandEncoder({});
let sampler3 = device0.createSampler({addressModeV: 'repeat', maxAnisotropy: 1});
let renderPassEncoder3 = commandEncoder7.beginRenderPass({
  colorAttachments: [{
  view: textureView0,
  clearValue: { r: 983.8, g: 65.99, b: -532.5, a: -150.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 159410385,
});
let sampler4 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 27.20,
  lodMaxClamp: 42.86,
});
try {
renderPassEncoder1.setBlendConstant({ r: 942.4, g: -28.33, b: -966.7, a: -713.1, });
} catch {}
let commandEncoder8 = device0.createCommandEncoder({});
let texture7 = device0.createTexture({
  size: {width: 9, height: 241, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder4 = commandEncoder8.beginComputePass();
let textureView6 = texture7.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1});
let sampler5 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMinClamp: 74.08, lodMaxClamp: 93.02});
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'smpte432', transfer: 'log'} });
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let texture8 = device0.createTexture({
  size: [78, 1931, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder3.setViewport(33.63051633472102, 109.69503229564374, 77.04773265080469, 14.386383882236572, 0.7604788384487001, 0.9733871825857803);
} catch {}
await gc();
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  label: '\ue287\ud1ed',
  entries: [
    {
      binding: 331,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer0 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let textureView7 = texture6.createView({baseArrayLayer: 0});
let texture9 = device0.createTexture({size: [128], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer0, 0, 15);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let texture10 = device0.createTexture({
  size: {width: 1, height: 45, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture11 = device0.createTexture({size: [128], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
let computePassEncoder5 = commandEncoder9.beginComputePass();
try {
renderPassEncoder0.setVertexBuffer(4, buffer0, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
let commandEncoder10 = device0.createCommandEncoder({});
let texture12 = device0.createTexture({
  size: [9, 241, 1],
  mipLevelCount: 2,
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder4 = commandEncoder10.beginRenderPass({
  colorAttachments: [{
  view: textureView0,
  clearValue: { r: -248.2, g: 828.4, b: -903.1, a: 987.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder2.executeBundles([renderBundle1, renderBundle0]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder11 = device0.createCommandEncoder({});
let textureView8 = texture8.createView({});
let sampler6 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  compare: 'less',
});
let commandEncoder12 = device0.createCommandEncoder({});
let textureView9 = texture4.createView({});
let texture13 = device0.createTexture({
  size: [19, 482, 1],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder5 = commandEncoder12.beginRenderPass({
  colorAttachments: [{
  view: textureView0,
  clearValue: { r: -571.1, g: 572.0, b: 798.1, a: -301.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 227627894,
});
try {
renderPassEncoder2.setBlendConstant({ r: -54.26, g: 529.8, b: 324.1, a: -769.9, });
} catch {}
try {
buffer0.unmap();
} catch {}
try {
commandEncoder11.clearBuffer(buffer0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 13, z: 0},
  aspect: 'all',
}, new Uint8Array(19).fill(97), /* required buffer size: 19 */
{offset: 19, bytesPerRow: 84}, {width: 0, height: 70, depthOrArrayLayers: 0});
} catch {}
let texture14 = device0.createTexture({
  size: {width: 1, height: 180, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
await gc();
let buffer1 = device0.createBuffer({size: 96, usage: GPUBufferUsage.UNIFORM});
let textureView10 = texture6.createView({baseArrayLayer: 0});
let sampler7 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 99.97,
});
let buffer2 = device0.createBuffer({size: 100, usage: GPUBufferUsage.STORAGE});
let texture15 = device0.createTexture({
  size: [1, 360, 114],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView11 = texture12.createView({format: 'rgba32uint', mipLevelCount: 1});
try {
renderPassEncoder5.setViewport(111.44092781863355, 104.33452165734415, 2.247837929669597, 19.949295952653717, 0.30547228711852226, 0.6321445449889092);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer0, 16, 26);
} catch {}
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 7, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {binding: 18, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 21,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 22,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 40,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 66,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 133,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 310,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 420,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 522,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let sampler8 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 1,
});
let textureView12 = texture2.createView({baseMipLevel: 1, mipLevelCount: 1});
let renderPassEncoder6 = commandEncoder11.beginRenderPass({
  colorAttachments: [{
  view: textureView0,
  clearValue: { r: -482.8, g: -737.6, b: -695.1, a: -993.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler9 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 50.65, compare: 'always'});
try {
renderPassEncoder5.executeBundles([renderBundle0, renderBundle1, renderBundle0]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData1 = new ImageData(84, 48);
let commandEncoder13 = device0.createCommandEncoder();
let buffer3 = device0.createBuffer({size: 112, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture16 = device0.createTexture({size: [1, 45, 1], format: 'rgba32uint', usage: GPUTextureUsage.STORAGE_BINDING, viewFormats: []});
let computePassEncoder6 = commandEncoder13.beginComputePass();
try {
buffer0.unmap();
} catch {}
try {
computePassEncoder0.insertDebugMarker('\u0fce');
} catch {}
try {
device0.queue.submit([]);
} catch {}
let imageData2 = new ImageData(48, 20);
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'smpteSt4281', transfer: 'bt2020_12bit'} });
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
try {
buffer3.unmap();
} catch {}
let textureView13 = texture16.createView({dimension: '2d-array'});
let sampler10 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 79.63});
try {
renderPassEncoder1.executeBundles([renderBundle0, renderBundle1, renderBundle0, renderBundle1, renderBundle0, renderBundle0, renderBundle0, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
let commandEncoder14 = device0.createCommandEncoder({label: '\ubaa6\udb50\u0e08\u0937\u1ff5\u05e4\uece8\u64f9\u8d8c\u5375'});
let texture17 = device0.createTexture({
  size: {width: 39, height: 965, depthOrArrayLayers: 155},
  dimension: '3d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture18 = device0.createTexture({
  size: [1, 180, 443],
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView14 = texture8.createView({});
let computePassEncoder7 = commandEncoder14.beginComputePass();
try {
renderPassEncoder6.end();
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer0, 4, 3);
} catch {}
let textureView15 = texture8.createView({});
let computePassEncoder8 = commandEncoder11.beginComputePass();
try {
renderPassEncoder4.setScissorRect(4, 1, 40, 8);
} catch {}
let textureView16 = texture11.createView({aspect: 'all'});
let sampler11 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 59.20,
  maxAnisotropy: 14,
});
try {
renderPassEncoder0.setBlendConstant({ r: 369.0, g: 129.4, b: -438.5, a: -144.7, });
} catch {}
try {
renderPassEncoder4.setScissorRect(32, 4, 5, 1);
} catch {}
let imageData3 = new ImageData(20, 76);
let textureView17 = texture12.createView({dimension: '2d-array', mipLevelCount: 1});
let texture19 = device0.createTexture({
  size: {width: 78, height: 1931, depthOrArrayLayers: 875},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView18 = texture11.createView({dimension: '1d'});
let texture20 = device0.createTexture({size: [78, 1931, 1], format: 'depth24plus', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder5.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 0, new Uint32Array(17416), 4705, 20);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
adapter0.label = '\u6b7d\u{1f85f}\u5bca\u096b\ue1c6\u{1fe80}\u684a';
} catch {}
let buffer4 = device0.createBuffer({size: 96, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
try {
renderPassEncoder4.setVertexBuffer(3, buffer3);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 28, new BigUint64Array(1423), 252, 0);
} catch {}
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpte240m', transfer: 'iec61966-2-1'} });
let commandEncoder15 = device0.createCommandEncoder({});
let textureView19 = texture19.createView({mipLevelCount: 1});
let sampler12 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'always',
});
try {
renderPassEncoder1.executeBundles([renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder5.setViewport(88.2286665799596, 112.8096192912897, 34.32643375647666, 13.009618270048987, 0.14661742653143306, 0.4848604329401805);
} catch {}
let texture21 = device0.createTexture({
  size: [9, 241, 1],
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let commandEncoder16 = device0.createCommandEncoder({});
let texture22 = device0.createTexture({
  size: {width: 19, height: 482, depthOrArrayLayers: 35},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let bindGroup0 = device0.createBindGroup({layout: veryExplicitBindGroupLayout4, entries: [{binding: 0, resource: {buffer: buffer2}}]});
let querySet0 = device0.createQuerySet({type: 'timestamp', count: 724});
let textureView20 = texture22.createView({mipLevelCount: 1});
let computePassEncoder9 = commandEncoder15.beginComputePass();
let sampler13 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder8.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder5.setBindGroup(1, bindGroup0, new Uint32Array(1718), 265, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer5 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 123});
try {
computePassEncoder3.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer4, 0, 32);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 12, new DataView(new ArrayBuffer(30670)), 4747, 8);
} catch {}
let texture23 = device0.createTexture({
  size: {width: 19, height: 482, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView21 = texture9.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder0.setScissorRect(19, 15, 2, 7);
} catch {}
try {
computePassEncoder9.setBindGroup(0, bindGroup0, new Uint32Array(5619), 326, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle0, renderBundle1, renderBundle1]);
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder4.setBindGroup(2, bindGroup0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 7, y: 13, z: 35},
  aspect: 'all',
}, new Uint8Array(1_376_452).fill(124), /* required buffer size: 1_376_452 */
{offset: 26, bytesPerRow: 213, rowsPerImage: 154}, {width: 5, height: 149, depthOrArrayLayers: 42});
} catch {}
let textureView22 = texture19.createView({mipLevelCount: 1});
let computePassEncoder10 = commandEncoder16.beginComputePass();
let sampler14 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.27,
});
try {
computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(650), 36, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer3, 0, 4);
} catch {}
let commandEncoder18 = device0.createCommandEncoder({});
let texture24 = device0.createTexture({size: [78, 1931, 1], mipLevelCount: 2, format: 'depth24plus', usage: GPUTextureUsage.COPY_SRC});
let renderPassEncoder7 = commandEncoder17.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  depthSlice: 612,
  clearValue: { r: 248.9, g: -179.5, b: 984.8, a: 900.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle0, renderBundle0, renderBundle1]);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let textureView23 = texture7.createView({dimension: '2d-array'});
try {
computePassEncoder4.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle1, renderBundle0, renderBundle1, renderBundle1, renderBundle0, renderBundle1, renderBundle1]);
} catch {}
let buffer6 = device0.createBuffer({size: 120, usage: GPUBufferUsage.INDIRECT});
let renderPassEncoder8 = commandEncoder18.beginRenderPass({
  colorAttachments: [{view: textureView19, depthSlice: 695, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 296775157,
});
let sampler15 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 82.15, compare: 'equal', maxAnisotropy: 1});
try {
computePassEncoder8.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(121), 11, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer0, 0);
} catch {}
let textureView24 = texture13.createView({dimension: '2d-array', mipLevelCount: 1});
let sampler16 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', minFilter: 'nearest', lodMaxClamp: 95.14});
try {
computePassEncoder6.setBindGroup(0, bindGroup0);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 2, y: 47, z: 0},
  aspect: 'all',
}, new Uint8Array(139).fill(149), /* required buffer size: 139 */
{offset: 139, bytesPerRow: 96}, {width: 0, height: 132, depthOrArrayLayers: 0});
} catch {}
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 1648});
let sampler17 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.46,
  lodMaxClamp: 96.56,
});
try {
computePassEncoder9.setBindGroup(3, bindGroup0, new Uint32Array(1088), 100, 0);
} catch {}
let textureView25 = texture3.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 6});
try {
renderPassEncoder2.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup0, new Uint32Array(708), 12, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer3, 0, 7);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 0, y: 47, z: 0},
  aspect: 'all',
}, new Uint8Array(92).fill(29), /* required buffer size: 92 */
{offset: 92, bytesPerRow: 9}, {width: 4, height: 9, depthOrArrayLayers: 0});
} catch {}
let buffer7 = device0.createBuffer({size: 200, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let textureView26 = texture6.createView({aspect: 'all'});
try {
renderPassEncoder5.executeBundles([renderBundle0, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer4, 12);
} catch {}
let buffer8 = device0.createBuffer({
  size: 153,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let texture25 = device0.createTexture({
  size: [39],
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let externalTexture1 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder10.setBindGroup(3, bindGroup0, new Uint32Array(189), 46, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup0);
} catch {}
let imageData4 = new ImageData(4, 92);
try {
device0.queue.label = '\ufbd6\ub472\u{1f6b6}\ub5e3\u41f0\u8a19\u0d6d\u073a\u{1fcc9}\u{1f8fb}';
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 7, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {binding: 18, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 21,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 22,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 40,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 66,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 133,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 310,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 420,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 522,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout4, veryExplicitBindGroupLayout5]});
let commandEncoder19 = device0.createCommandEncoder();
let renderPassEncoder9 = commandEncoder19.beginRenderPass({
  colorAttachments: [{
  view: textureView0,
  clearValue: { r: 399.3, g: -893.4, b: -614.4, a: -984.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 584},
});
try {
computePassEncoder6.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder6.setBindGroup(0, bindGroup0, new Uint32Array(1242), 126, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(701), 11, 0);
} catch {}
let texture26 = device0.createTexture({
  size: [1, 180, 1],
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView27 = texture3.createView({dimension: '2d', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 9, arrayLayerCount: 1});
let sampler18 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.64,
});
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(352).fill(62), /* required buffer size: 352 */
{offset: 352, bytesPerRow: 35}, {width: 1, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder20 = device0.createCommandEncoder({});
let computePassEncoder11 = commandEncoder20.beginComputePass();
try {
renderPassEncoder8.setBindGroup(2, bindGroup0, new Uint32Array(1388), 184, 0);
} catch {}
try {
buffer7.unmap();
} catch {}
let commandEncoder21 = device0.createCommandEncoder({});
let textureView28 = texture4.createView({});
let computePassEncoder12 = commandEncoder21.beginComputePass();
try {
renderPassEncoder4.setVertexBuffer(6, buffer4);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 24, new Uint32Array(5757), 489, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 1, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(425).fill(15), /* required buffer size: 425 */
{offset: 425, bytesPerRow: 51}, {width: 0, height: 10, depthOrArrayLayers: 0});
} catch {}
let textureView29 = texture16.createView({});
let texture27 = device0.createTexture({
  size: {width: 19, height: 482, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder6.setBindGroup(1, bindGroup0);
} catch {}
let commandEncoder22 = device0.createCommandEncoder({});
let renderPassEncoder10 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  depthSlice: 236,
  clearValue: { r: 982.1, g: -202.3, b: 761.4, a: -530.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
device0.queue.writeBuffer(buffer4, 4, new Uint32Array(1071), 112, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(832).fill(219), /* required buffer size: 832 */
{offset: 832, bytesPerRow: 58}, {width: 1, height: 18, depthOrArrayLayers: 0});
} catch {}
let texture28 = device0.createTexture({
  label: '\u0b28\u0901\u7776\u0785\ucc96\u2eb6',
  size: {width: 1, height: 90, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder10.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup0, new Uint32Array(253), 130, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer4);
} catch {}
let commandEncoder23 = device0.createCommandEncoder();
let textureView30 = texture18.createView({label: '\u0a2c\u{1fcd1}\u0a99', aspect: 'all', baseArrayLayer: 0, arrayLayerCount: 1});
let computePassEncoder13 = commandEncoder23.beginComputePass();
try {
computePassEncoder4.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let commandEncoder24 = device0.createCommandEncoder({});
try {
computePassEncoder6.setBindGroup(0, bindGroup0, new Uint32Array(788), 32, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer7);
} catch {}
try {
computePassEncoder4.insertDebugMarker('\u042d');
} catch {}
try {
device0.queue.writeBuffer(buffer4, 12, new BigUint64Array(8489), 230, 0);
} catch {}
let computePassEncoder14 = commandEncoder24.beginComputePass();
try {
computePassEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(2426), 300, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup0, new Uint32Array(2095), 173, 0);
} catch {}
let commandEncoder25 = device0.createCommandEncoder({});
let textureView31 = texture2.createView({mipLevelCount: 1});
let computePassEncoder15 = commandEncoder25.beginComputePass();
try {
computePassEncoder7.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder10.setBindGroup(0, bindGroup0, new Uint32Array(472), 141, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup0, []);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup0, new Uint32Array(5060), 25, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer4);
} catch {}
let imageData5 = new ImageData(84, 92);
let texture29 = device0.createTexture({
  size: {width: 78, height: 1931, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView32 = texture0.createView({});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint']});
try {
renderPassEncoder8.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup0, new Uint32Array(1733), 133, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle0, renderBundle0, renderBundle0, renderBundle1]);
} catch {}
try {
renderPassEncoder9.setStencilReference(11);
} catch {}
try {
renderBundleEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(1218), 124, 0);
} catch {}
let promise0 = device0.queue.onSubmittedWorkDone();
await gc();
let texture30 = device0.createTexture({
  size: {width: 9, height: 241, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let sampler19 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 91.64,
  lodMaxClamp: 95.13,
});
let externalTexture2 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder11.setBindGroup(2, bindGroup0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(59).fill(162), /* required buffer size: 59 */
{offset: 59, bytesPerRow: 75}, {width: 1, height: 34, depthOrArrayLayers: 0});
} catch {}
let buffer9 = device0.createBuffer({size: 244, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
try {
renderBundleEncoder2.setVertexBuffer(2, undefined);
} catch {}
let imageBitmap0 = await createImageBitmap(imageData5);
let commandEncoder26 = device0.createCommandEncoder({});
let textureView33 = texture30.createView({aspect: 'depth-only', mipLevelCount: 1});
let sampler20 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 88.38,
  maxAnisotropy: 11,
});
try {
computePassEncoder3.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(1666), 90, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(2, bindGroup0, new Uint32Array(1350), 111, 0);
} catch {}
try {
  await buffer5.mapAsync(GPUMapMode.READ, 0, 8);
} catch {}
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let commandEncoder27 = device0.createCommandEncoder({});
let computePassEncoder16 = commandEncoder26.beginComputePass();
try {
computePassEncoder9.setBindGroup(1, bindGroup0, []);
} catch {}
try {
computePassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(540), 144, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup0, new Uint32Array(1423), 1_160, 0);
} catch {}
let commandEncoder28 = device0.createCommandEncoder({});
let renderBundle2 = renderBundleEncoder2.finish({});
try {
renderPassEncoder0.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle1, renderBundle0, renderBundle0, renderBundle2, renderBundle0]);
} catch {}
try {
renderPassEncoder0.setViewport(110.46625076587817, 71.24797686593972, 17.49572602752398, 42.70225457523071, 0.7884755728288326, 0.8718610190126719);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer0, 0, 37);
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 176 */
  offset: 176,
  bytesPerRow: 45312,
  buffer: buffer7,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 53, z: 0},
  aspect: 'all',
}, {width: 1, height: 16, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder28.resolveQuerySet(querySet1, 17, 5, buffer8, 0);
} catch {}
try {
commandEncoder27.insertDebugMarker('\u01d2');
} catch {}
let imageData6 = new ImageData(36, 8);
let textureView34 = texture4.createView({dimension: '2d-array', format: 'rgba8snorm'});
let computePassEncoder17 = commandEncoder28.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 380}});
let externalTexture3 = device0.importExternalTexture({source: videoFrame2});
try {
renderPassEncoder9.setBindGroup(1, bindGroup0, new Uint32Array(245), 81, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer4);
} catch {}
let buffer10 = device0.createBuffer({size: 236, usage: GPUBufferUsage.INDEX});
let commandEncoder29 = device0.createCommandEncoder({});
let renderPassEncoder11 = commandEncoder29.beginRenderPass({
  colorAttachments: [{
  view: textureView0,
  clearValue: { r: 852.8, g: -513.6, b: -146.2, a: 250.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler21 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 54.42,
});
try {
renderPassEncoder8.executeBundles([renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
await gc();
let textureView35 = texture18.createView({});
try {
computePassEncoder14.setBindGroup(2, bindGroup0, new Uint32Array(1099), 275, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer10, 'uint16', 10, 55);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
let buffer11 = device0.createBuffer({size: 72, usage: GPUBufferUsage.INDIRECT});
let commandEncoder30 = device0.createCommandEncoder({label: '\u788d\uab58\u8910\u935e\u0d41'});
let sampler22 = device0.createSampler({addressModeV: 'mirror-repeat'});
try {
computePassEncoder16.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder7.setBindGroup(2, bindGroup0, new Uint32Array(4062), 687, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle2]);
} catch {}
try {
buffer11.unmap();
} catch {}
let buffer12 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 90});
let textureView36 = texture1.createView({mipLevelCount: 1});
try {
renderPassEncoder1.executeBundles([renderBundle2, renderBundle2, renderBundle1, renderBundle2, renderBundle2]);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(2, buffer3, 0, 12);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let commandEncoder31 = device0.createCommandEncoder({});
let computePassEncoder18 = commandEncoder30.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 16}});
try {
computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(533), 109, 0);
} catch {}
try {
computePassEncoder3.end();
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer4, 24, 1);
} catch {}
try {
commandEncoder27.copyBufferToBuffer(buffer8, 12, buffer5, 8, 8);
} catch {}
let buffer13 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_DST});
let commandEncoder32 = device0.createCommandEncoder({});
let textureView37 = texture12.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(820), 240, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle2, renderBundle0, renderBundle2, renderBundle0, renderBundle2]);
} catch {}
try {
  await promise0;
} catch {}
let buffer14 = device0.createBuffer({size: 88, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let sampler23 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 58.51,
});
try {
renderPassEncoder1.setVertexBuffer(5, buffer0);
} catch {}
let commandBuffer0 = commandEncoder4.finish({});
let texture31 = device0.createTexture({
  size: {width: 19, height: 482, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView38 = texture5.createView({});
let computePassEncoder19 = commandEncoder27.beginComputePass();
try {
computePassEncoder15.setBindGroup(1, bindGroup0, new Uint32Array(1638), 171, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup0, new Uint32Array(968), 406, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle0, renderBundle1]);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(5, undefined);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder32.clearBuffer(buffer13);
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(44, 46);
let computePassEncoder20 = commandEncoder32.beginComputePass();
let renderPassEncoder12 = commandEncoder31.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: 680.1, g: 422.4, b: -47.65, a: 0.6614, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder9.setBindGroup(1, bindGroup0, new Uint32Array(2944), 336, 0);
} catch {}
try {
renderPassEncoder10.setBlendConstant({ r: -385.1, g: -984.9, b: 787.5, a: -270.3, });
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer9, 0);
} catch {}
let commandEncoder33 = device0.createCommandEncoder({});
let computePassEncoder21 = commandEncoder33.beginComputePass();
try {
computePassEncoder12.setBindGroup(2, bindGroup0);
} catch {}
let arrayBuffer0 = buffer5.getMappedRange(0, 0);
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0); };
} catch {}
try {
  await promise1;
} catch {}
let videoFrame3 = videoFrame0.clone();
let commandEncoder34 = device0.createCommandEncoder({});
let renderPassEncoder13 = commandEncoder34.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: -747.3, g: -558.4, b: -596.3, a: -368.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 400},
  maxDrawCount: 28140651,
});
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer10, 'uint16', 42, 105);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let buffer15 = device0.createBuffer({size: 68, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder35 = device0.createCommandEncoder({});
let texture32 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 14},
  format: 'rgba32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView39 = texture5.createView({dimension: '2d-array', baseMipLevel: 0, baseArrayLayer: 0});
let computePassEncoder22 = commandEncoder35.beginComputePass({timestampWrites: {querySet: querySet0}});
try {
computePassEncoder18.setBindGroup(2, bindGroup0, new Uint32Array(1063), 110, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 4, new BigUint64Array(25344), 3103, 0);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder36 = device0.createCommandEncoder();
let textureView40 = texture17.createView({baseMipLevel: 0});
let renderPassEncoder14 = commandEncoder36.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: 280.7, g: -509.7, b: -280.5, a: 565.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler24 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  lodMaxClamp: 71.46,
});
try {
renderPassEncoder4.setBindGroup(3, bindGroup0, new Uint32Array(3715), 2_236, 0);
} catch {}
let externalTexture4 = device0.importExternalTexture({source: videoFrame2});
let texture33 = device0.createTexture({size: [128, 128, 14], format: 'depth24plus', usage: GPUTextureUsage.COPY_DST});
let textureView41 = texture0.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 0});
try {
computePassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup0);
} catch {}
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout4]});
let commandEncoder37 = device0.createCommandEncoder({});
let computePassEncoder23 = commandEncoder37.beginComputePass({timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 645}});
try {
renderPassEncoder0.setBindGroup(1, bindGroup0, []);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup0, new Uint32Array(1257), 157, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer0, 8, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 3, y: 31, z: 0},
  aspect: 'all',
}, new Uint8Array(23).fill(177), /* required buffer size: 23 */
{offset: 23, bytesPerRow: 4}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let commandEncoder38 = device0.createCommandEncoder();
let computePassEncoder24 = commandEncoder38.beginComputePass();
try {
renderPassEncoder5.setVertexBuffer(4, undefined, 0, 606_853_149);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder13.setViewport(5.608885031085407, 4.242449512538215, 95.66840162213128, 80.8327978470468, 0.6583827197928024, 0.6892505384312457);
} catch {}
let commandEncoder39 = device0.createCommandEncoder({});
let texture34 = device0.createTexture({
  size: [1, 90, 1],
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder15 = commandEncoder39.beginRenderPass({
  colorAttachments: [{view: textureView0, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet3,
});
try {
computePassEncoder22.setBindGroup(2, bindGroup0, []);
} catch {}
try {
computePassEncoder18.setBindGroup(1, bindGroup0, new Uint32Array(246), 24, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup0, new Uint32Array(761), 125, 0);
} catch {}
try {
renderPassEncoder12.setScissorRect(14, 58, 7, 25);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer10, 'uint16', 2, 2);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer3, 28);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 44, new BigUint64Array(3829), 714, 0);
} catch {}
try {
computePassEncoder14.setBindGroup(2, bindGroup0, new Uint32Array(878), 33, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer3, 0, 5);
} catch {}
try {
buffer1.unmap();
} catch {}
let buffer16 = device0.createBuffer({size: 144, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
try {
computePassEncoder19.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer10, 'uint16', 16, 2);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer7, 68, 23);
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u09fc');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(63).fill(114), /* required buffer size: 63 */
{offset: 63, bytesPerRow: 16}, {width: 0, height: 106, depthOrArrayLayers: 0});
} catch {}
let commandEncoder40 = device0.createCommandEncoder({label: '\ue95b\u{1fb70}\u0caf\u{1fd86}\u86f1\uaf4e\u{1fafa}\u64dc\u{1fcb7}'});
let computePassEncoder25 = commandEncoder40.beginComputePass();
try {
computePassEncoder10.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup0, new Uint32Array(5788), 163, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer10, 'uint32', 20, 2);
} catch {}
try {
computePassEncoder16.pushDebugGroup('\u36e4');
} catch {}
let videoFrame4 = videoFrame2.clone();
let textureView42 = texture34.createView({aspect: 'depth-only', format: 'depth24plus'});
let sampler25 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 92.26,
  maxAnisotropy: 17,
});
let sampler26 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 83.65,
  maxAnisotropy: 1,
});
try {
renderPassEncoder14.setBindGroup(1, bindGroup0, new Uint32Array(795), 109, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer10, 'uint32', 4, 24);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(19); };
} catch {}
let buffer17 = device0.createBuffer({size: 4, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView43 = texture16.createView({});
let texture35 = device0.createTexture({
  size: {width: 9, height: 241, depthOrArrayLayers: 77},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView44 = texture12.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder7.setBindGroup(3, bindGroup0, new Uint32Array(2014), 409, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder13.setBlendConstant({ r: -306.6, g: 233.1, b: 478.6, a: -600.0, });
} catch {}
try {
renderPassEncoder10.setVertexBuffer(7, buffer0, 8);
} catch {}
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
let commandEncoder41 = device0.createCommandEncoder({});
let textureView45 = texture3.createView({dimension: 'cube', format: 'rg8sint', mipLevelCount: 1, baseArrayLayer: 1});
let sampler27 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 15,
});
try {
computePassEncoder11.setBindGroup(1, bindGroup0, new Uint32Array(2368), 563, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer10, 'uint32', 36, 0);
} catch {}
let buffer18 = device0.createBuffer({label: '\ubeea\u908c\u2f1e\uf394\u09be', size: 172, usage: GPUBufferUsage.STORAGE});
let commandEncoder42 = device0.createCommandEncoder({});
let sampler28 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', lodMaxClamp: 58.39});
try {
renderPassEncoder0.setVertexBuffer(5, buffer14, 8, 2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer8, 0, new Uint32Array(37324), 5260, 0);
} catch {}
let texture36 = device0.createTexture({
  size: [78],
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder9.setBindGroup(2, bindGroup0);
} catch {}
let buffer19 = device0.createBuffer({size: 47, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder43 = device0.createCommandEncoder({});
let texture37 = device0.createTexture({
  size: [78, 1931, 506],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder26 = commandEncoder43.beginComputePass();
try {
computePassEncoder1.setBindGroup(3, bindGroup0, new Uint32Array(1175), 44, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer10, 'uint16', 20, 11);
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
try {
computePassEncoder19.setBindGroup(1, bindGroup0, []);
} catch {}
try {
computePassEncoder23.setBindGroup(2, bindGroup0, new Uint32Array(256), 18, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer10, 'uint16', 212, 12);
} catch {}
try {
commandEncoder41.copyBufferToBuffer(buffer9, 24, buffer5, 0, 4);
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 80 */
  offset: 80,
  bytesPerRow: 4352,
  buffer: buffer8,
}, {
  texture: texture12,
  mipLevel: 1,
  origin: {x: 0, y: 8, z: 0},
  aspect: 'all',
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer4, 8, new Uint32Array(41268), 5919, 0);
} catch {}
videoFrame0.close();
videoFrame1.close();
videoFrame2.close();
videoFrame4.close();
}
async function worker1() {
let promise0 = navigator.gpu.requestAdapter({});
let promise1 = navigator.gpu.requestAdapter({});
let adapter0 = await navigator.gpu.requestAdapter({});
let promise2 = adapter0.requestDevice({
  defaultQueue: {},
  requiredLimits: {
    maxBindGroups: 4,
    maxVertexBuffers: 8,
    minUniformBufferOffsetAlignment: 256,
    maxUniformBufferBindingSize: 78996430,
    maxStorageBufferBindingSize: 144694078,
  },
});
let adapter1 = await promise0;
let promise3 = adapter1.requestDevice({
  defaultQueue: {label: '\ufed9\u69aa\u{1f6f0}\u0e99'},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
    'timestamp-query',
  ],
  requiredLimits: {
    maxDynamicStorageBuffersPerPipelineLayout: 4,
    maxUniformBufferBindingSize: 7703639,
    maxStorageBufferBindingSize: 135823854,
  },
});
let adapter2 = await navigator.gpu.requestAdapter({});
let promise4 = adapter2.requestDevice({
  defaultQueue: {},
  requiredLimits: {
    maxDynamicUniformBuffersPerPipelineLayout: 8,
    maxBindingsPerBindGroup: 1000,
    maxTextureDimension1D: 8192,
    maxVertexBuffers: 8,
    maxUniformBufferBindingSize: 10984026,
    maxStorageBufferBindingSize: 138748896,
    maxInterStageShaderVariables: 16,
  },
});
let promise5 = navigator.gpu.requestAdapter({});
let adapter3 = await promise5;
let promise6 = adapter3.requestDevice({
  defaultQueue: {},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'timestamp-query',
  ],
  requiredLimits: {
    maxColorAttachmentBytesPerSample: 32,
    maxUniformBufferBindingSize: 15253821,
    maxStorageBufferBindingSize: 169004002,
    maxUniformBuffersPerShaderStage: 12,
  },
});
let adapter4 = await navigator.gpu.requestAdapter({});
let device0 = await promise4;
let commandEncoder0 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: [127, 1, 23],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: [undefined]});
let textureView0 = texture0.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 3});
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(13_490).fill(56), /* required buffer size: 13_490 */
{offset: 130, bytesPerRow: 167, rowsPerImage: 20}, {width: 12, height: 0, depthOrArrayLayers: 5});
} catch {}
let textureView1 = texture0.createView({baseArrayLayer: 2, arrayLayerCount: 1});
let sampler0 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 88.73,
  lodMaxClamp: 92.92,
});
try {
commandEncoder0.copyTextureToTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder1 = device0.createCommandEncoder({});
try {
globalThis.someLabel = textureView0.label;
} catch {}
let sampler1 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 81.91,
  maxAnisotropy: 11,
});
let texture1 = device0.createTexture({
  size: {width: 510},
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView2 = texture0.createView({dimension: '2d', aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 12});
let computePassEncoder0 = commandEncoder0.beginComputePass();
let buffer0 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let computePassEncoder1 = commandEncoder1.beginComputePass();
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 197,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let buffer1 = device0.createBuffer({size: 412, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder2 = device0.createCommandEncoder({});
let textureView3 = texture0.createView({format: 'r32sint', baseArrayLayer: 8, arrayLayerCount: 4});
let computePassEncoder2 = commandEncoder2.beginComputePass();
try {
renderBundleEncoder0.setVertexBuffer(1, undefined, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 0, new Uint32Array(19393), 19393);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 197,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let texture2 = device0.createTexture({size: [64, 64, 35], dimension: '3d', format: 'rgba8sint', usage: GPUTextureUsage.COPY_DST});
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(62).fill(96), /* required buffer size: 62 */
{offset: 62, rowsPerImage: 1}, {width: 48, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder3 = device0.createCommandEncoder({});
let computePassEncoder3 = commandEncoder3.beginComputePass();
let sampler2 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 95.96});
try {
renderBundleEncoder0.setVertexBuffer(6, undefined, 0, 830_890_115);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '2d-array' },
    },
  ],
});
let textureView4 = texture0.createView({dimension: '2d'});
let textureView5 = texture2.createView({});
let renderBundle0 = renderBundleEncoder0.finish({});
try {
device0.queue.writeBuffer(buffer0, 4, new Int16Array(4232), 88, 0);
} catch {}
let buffer2 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder4 = device0.createCommandEncoder({});
let sampler3 = device0.createSampler({addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 53.38});
try {
computePassEncoder2.pushDebugGroup('\u07fd');
} catch {}
let textureView6 = texture0.createView({baseArrayLayer: 3, arrayLayerCount: 1});
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470bg', transfer: 'pq'} });
let sampler4 = device0.createSampler({label: '\u{1fccd}\ub0bf\u0bfb\ue6d6', addressModeW: 'mirror-repeat', lodMaxClamp: 85.42});
try {
computePassEncoder2.popDebugGroup();
} catch {}
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let textureView7 = texture1.createView({});
let computePassEncoder4 = commandEncoder4.beginComputePass();
let sampler5 = device0.createSampler({addressModeV: 'mirror-repeat', mipmapFilter: 'linear'});
try {
computePassEncoder3.end();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(206_406).fill(128), /* required buffer size: 206_406 */
{offset: 6, bytesPerRow: 480, rowsPerImage: 86}, {width: 88, height: 0, depthOrArrayLayers: 6});
} catch {}
try {
veryExplicitBindGroupLayout1.label = '\u{1f6b0}\u8591\u0480\uc594';
} catch {}
let texture3 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 1},
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder5 = commandEncoder3.beginComputePass();
let sampler6 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 74.36,
  compare: 'greater',
  maxAnisotropy: 5,
});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup0 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView1}]});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout0]});
let buffer3 = device0.createBuffer({size: 141, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder5 = device0.createCommandEncoder({});
let textureView8 = texture2.createView({label: '\u07cf\u{1f6f9}\u669b\u074d\u82b5\u{1fc1e}'});
let computePassEncoder6 = commandEncoder5.beginComputePass();
let textureView9 = texture2.createView({dimension: '3d', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(70), 1, 0);
} catch {}
let pipelineLayout2 = device0.createPipelineLayout({
  label: '\u{1fd6b}\uaa28\u00ee\u7d87\u4457\u224e\u7e6b\u0ae7',
  bindGroupLayouts: [veryExplicitBindGroupLayout1],
});
let buffer4 = device0.createBuffer({size: 96, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView10 = texture0.createView({dimension: '2d', format: 'r32sint', baseArrayLayer: 1});
try {
computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(2381), 257, 0);
} catch {}
await gc();
try {
computePassEncoder6.setBindGroup(0, bindGroup0, []);
} catch {}
try {
computePassEncoder1.setBindGroup(1, bindGroup0, new Uint32Array(2726), 479, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 4, new Uint32Array(11765), 892, 0);
} catch {}
let commandEncoder6 = device0.createCommandEncoder({});
let sampler7 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.80,
  maxAnisotropy: 4,
});
let computePassEncoder7 = commandEncoder6.beginComputePass();
let sampler8 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 83.06,
  maxAnisotropy: 14,
});
let texture4 = device0.createTexture({
  size: [255, 1, 44],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
adapter3.label = '\u0e19\u0852\u{1f8f1}\u8e23\u0e6e\ub529\u08a1\u03d1\ue15b';
} catch {}
let commandEncoder7 = device0.createCommandEncoder();
let texture5 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 35},
  dimension: '3d',
  format: 'rgb9e5ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView11 = texture3.createView({dimension: '2d-array'});
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout2]});
let textureView12 = texture0.createView({dimension: '2d', baseArrayLayer: 11});
let computePassEncoder8 = commandEncoder7.beginComputePass();
try {
computePassEncoder5.setBindGroup(1, bindGroup0);
} catch {}
let buffer5 = device0.createBuffer({
  size: 44,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder8 = device0.createCommandEncoder({});
try {
computePassEncoder1.setBindGroup(1, bindGroup0, new Uint32Array(1511), 168, 0);
} catch {}
try {
globalThis.someLabel = device0.queue.label;
} catch {}
let texture6 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 58},
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler9 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 78.93});
try {
buffer0.unmap();
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
},
{width: 39, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let textureView13 = texture6.createView({baseArrayLayer: 1, arrayLayerCount: 17});
let computePassEncoder9 = commandEncoder9.beginComputePass();
try {
computePassEncoder6.setBindGroup(1, bindGroup0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let buffer6 = device0.createBuffer({
  size: 40,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder10 = device0.createCommandEncoder({});
let computePassEncoder10 = commandEncoder8.beginComputePass();
let buffer7 = device0.createBuffer({size: 76, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder11 = device0.createCommandEncoder({});
try {
buffer0.unmap();
} catch {}
try {
commandEncoder11.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 69, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
},
{width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup1 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView1}]});
let commandEncoder12 = device0.createCommandEncoder({});
try {
device0.queue.writeBuffer(buffer0, 4, new BigUint64Array(3798), 638, 0);
} catch {}
let commandEncoder13 = device0.createCommandEncoder();
let sampler10 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 85.07,
  lodMaxClamp: 93.18,
  compare: 'not-equal',
  maxAnisotropy: 7,
});
let computePassEncoder11 = commandEncoder11.beginComputePass();
try {
computePassEncoder1.setBindGroup(2, bindGroup1);
} catch {}
try {
computePassEncoder4.setBindGroup(0, bindGroup1, new Uint32Array(1456), 295, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(174).fill(163), /* required buffer size: 174 */
{offset: 174, bytesPerRow: 12, rowsPerImage: 58}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder0.setBindGroup(0, bindGroup1);
} catch {}
let buffer8 = device0.createBuffer({size: 48, usage: GPUBufferUsage.STORAGE});
let commandEncoder14 = device0.createCommandEncoder({});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: externalTexture0}, {binding: 197, resource: sampler8}],
});
let commandEncoder15 = device0.createCommandEncoder({});
let texture7 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 881},
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture8 = device0.createTexture({size: [255], dimension: '1d', format: 'r32sint', usage: GPUTextureUsage.COPY_SRC});
let textureView14 = texture5.createView({mipLevelCount: 1});
let sampler11 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'repeat'});
let promise7 = device0.queue.onSubmittedWorkDone();
try {
  await promise7;
} catch {}
let commandEncoder16 = device0.createCommandEncoder();
let texture9 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 18},
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture10 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 14},
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder1.setBindGroup(1, bindGroup2, new Uint32Array(3217), 136, 0);
} catch {}
try {
commandEncoder13.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
},
{width: 33, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup3 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 197, resource: sampler7}, {binding: 1, resource: externalTexture0}],
});
let texture11 = device0.createTexture({
  size: [510, 1, 312],
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder12 = commandEncoder15.beginComputePass();
try {
device0.queue.writeBuffer(buffer0, 0, new Uint32Array(5194), 2686, 0);
} catch {}
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 223,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 301});
let texture12 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 16},
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder13 = commandEncoder10.beginComputePass();
try {
commandEncoder16.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer9 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let textureView15 = texture7.createView({});
let sampler12 = device0.createSampler({
  label: '\u{1fb59}\u{1fc85}\ub2b6\u0be9\uc023\u{1f98f}\ue8b5\u0a99\uf33b\u8421',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 94.93,
});
try {
computePassEncoder11.setBindGroup(3, bindGroup3);
} catch {}
try {
commandEncoder16.copyBufferToBuffer(buffer5, 0, buffer0, 0, 0);
} catch {}
await gc();
try {
commandEncoder14.clearBuffer(buffer0);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 0, new Uint32Array(720), 474, 0);
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let computePassEncoder14 = commandEncoder12.beginComputePass();
let computePassEncoder15 = commandEncoder14.beginComputePass();
try {
computePassEncoder9.setBindGroup(2, bindGroup3);
} catch {}
let commandEncoder18 = device0.createCommandEncoder({});
let bindGroup4 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 197, resource: sampler4}, {binding: 1, resource: externalTexture0}],
});
let commandEncoder19 = device0.createCommandEncoder({});
let texture13 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 32},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder16 = commandEncoder18.beginComputePass();
let sampler13 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 85.75,
});
try {
computePassEncoder7.setBindGroup(1, bindGroup2, new Uint32Array(2400), 725, 0);
} catch {}
try {
commandEncoder13.copyBufferToBuffer(buffer4, 8, buffer2, 40, 32);
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let bindGroup5 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView0}]});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise8;
} catch {}
let textureView16 = texture7.createView({});
let computePassEncoder17 = commandEncoder17.beginComputePass();
let sampler14 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 16,
});
try {
computePassEncoder12.setBindGroup(0, bindGroup2, new Uint32Array(840), 111, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer10 = device0.createBuffer({size: 368, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let textureView17 = texture2.createView({aspect: 'all', format: 'rgba8sint', mipLevelCount: 1});
try {
computePassEncoder2.setBindGroup(3, bindGroup3);
} catch {}
let texture14 = device0.createTexture({
  size: [63],
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
buffer3.unmap();
} catch {}
try {
commandEncoder19.copyBufferToBuffer(buffer6, 8, buffer10, 40, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 87, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder20 = device0.createCommandEncoder({});
let texture15 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  sampleCount: 1,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder18 = commandEncoder19.beginComputePass();
try {
commandEncoder20.copyTextureToTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer0, 0, new Uint32Array(5364), 262, 0);
} catch {}
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 49});
let computePassEncoder19 = commandEncoder16.beginComputePass();
try {
computePassEncoder8.setBindGroup(3, bindGroup2);
} catch {}
try {
commandEncoder20.copyBufferToBuffer(buffer4, 0, buffer2, 0, 24);
} catch {}
try {
commandEncoder13.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
},
{width: 45, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder14.insertDebugMarker('\u{1fb59}');
} catch {}
let commandEncoder21 = device0.createCommandEncoder({});
let texture16 = device0.createTexture({
  size: [255, 1, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder20 = commandEncoder13.beginComputePass();
let sampler15 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  lodMaxClamp: 99.98,
  compare: 'never',
});
try {
globalThis.someLabel = device0.queue.label;
} catch {}
let buffer11 = device0.createBuffer({size: 260, usage: GPUBufferUsage.UNIFORM});
try {
computePassEncoder10.setBindGroup(2, bindGroup0, new Uint32Array(988), 258, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'bt2020_10bit'} });
let commandEncoder22 = device0.createCommandEncoder({});
let computePassEncoder21 = commandEncoder22.beginComputePass();
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 49, y: 0, z: 23},
  aspect: 'all',
}, new Uint8Array(154).fill(132), /* required buffer size: 154 */
{offset: 154, rowsPerImage: 119}, {width: 88, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'smpte170m'} });
let buffer12 = device0.createBuffer({size: 428, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let textureView18 = texture9.createView({});
let computePassEncoder22 = commandEncoder20.beginComputePass();
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView19 = texture15.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6});
let computePassEncoder23 = commandEncoder21.beginComputePass();
try {
computePassEncoder2.setBindGroup(1, bindGroup4);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
computePassEncoder5.setBindGroup(2, bindGroup3);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 45, y: 0, z: 14},
  aspect: 'all',
}, new Uint8Array(15_212).fill(225), /* required buffer size: 15_212 */
{offset: 44, bytesPerRow: 158, rowsPerImage: 16}, {width: 36, height: 0, depthOrArrayLayers: 7});
} catch {}
await gc();
let commandEncoder23 = device0.createCommandEncoder({});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['r16sint']});
try {
renderBundleEncoder1.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer6, 'uint32', 8, 10);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(4, buffer2, 8, 6);
} catch {}
try {
commandEncoder23.copyBufferToBuffer(buffer5, 8, buffer2, 4, 4);
} catch {}
try {
commandEncoder23.copyBufferToTexture({
  /* bytesInLastRow: 408 widthInBlocks: 102 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 64 */
  offset: 64,
  bytesPerRow: 11520,
  buffer: buffer7,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 83, y: 0, z: 2},
  aspect: 'all',
}, {width: 102, height: 0, depthOrArrayLayers: 1});
} catch {}
let imageData0 = new ImageData(8, 48);
let texture17 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView20 = texture14.createView({});
let computePassEncoder24 = commandEncoder23.beginComputePass();
let sampler16 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 92.15,
  maxAnisotropy: 9,
});
try {
computePassEncoder1.setBindGroup(1, bindGroup4, []);
} catch {}
try {
computePassEncoder11.setBindGroup(2, bindGroup0, new Uint32Array(1416), 231, 0);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(5, buffer6, 0, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(1, buffer2);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(7, buffer6, 4, 1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 73, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(636_481).fill(40), /* required buffer size: 636_481 */
{offset: 1, bytesPerRow: 117, rowsPerImage: 20}, {width: 21, height: 0, depthOrArrayLayers: 273});
} catch {}
let commandEncoder24 = device0.createCommandEncoder();
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 267});
let sampler17 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 96.20});
try {
renderBundleEncoder1.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer9, 'uint32', 4, 15);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(6, buffer5, 0, 0);
} catch {}
await gc();
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

alias vec3b = vec3<bool>;

/* zero global variables used */
@must_use 
fn fn1(a0: array<vec4f, 1>) -> vec2u {
  var out: vec2u;
  var vf0: vec2f = unpack2x16snorm(vec4u(log2(vec4f(unconst_f32(-0.05418e19), unconst_f32(0.2225e14), unconst_f32(0.1862), unconst_f32(0.04695e-27))).xxzx)[2]);
  vf0 = vec2f(f32((unconst_bool(false) || unconst_bool(true))));
  out = vec2u(refract(vec2h(unconst_f16(-8719.9), unconst_f16(2696.7)), vec2h(unconst_f16(22901.1), unconst_f16(13444.7)), unconst_f16(10592.5)).rr);
  vf0 = atanh(vec3f(unconst_f32(-0.1189e-43), unconst_f32(0.2269), unconst_f32(0.07602))).br;
  var vf1: vec4f = a0[0];
  out ^= bitcast<vec2u>(vf0.yx);
  out -= vec2u(sqrt(vec3h(unconst_f16(22014.2), unconst_f16(5696.5), unconst_f16(10403.1))).xz.rr.gr.gg.xy);
  var vf2 = fn0(VertexOutput0(vec4u(vf0.grrr.xwzy), vf0.yyxx, vec2i(vf0)[1], vec2h(vf0.rr.xy)));
  let vf3: vec2f = vf2[unconst_u32(228099195)];
  vf1 = vec4f(sqrt(vec3h(unconst_f16(13831.9), unconst_f16(69.16), unconst_f16(20008.7))).gbbr.agag);
  var vf4: vec4f = a0[0];
  return out;
}

override override0: bool;

struct FragmentOutput0 {
  @location(3) @interpolate(flat, first) f0: u32,
}

struct VertexOutput0 {
  @location(10) f0: vec4u,
  @builtin(position) f1: vec4f,
  @location(2) f2: i32,
  @location(5) @interpolate(linear, either) f3: vec2h,
}

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

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

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

struct T0 {
  @align(32) @size(960) f0: array<array<vec2h, 16>>,
}

override override1: i32;

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

/* zero global variables used */
fn fn0(a0: VertexOutput0) -> mat2x2f {
  var out: mat2x2f;
  out = mat2x2f(vec2f(a0.f3), vec2f(a0.f3.yx));
  return out;
}

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

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

/* used global variables: et0 */
@vertex
fn vertex0(@location(6) @interpolate(flat, center) a0: u32) -> VertexOutput0 {
  var out: VertexOutput0;
  if bool(pack4xU8(vec4u(unconst_u32(802957496), unconst_u32(2721299685), unconst_u32(795006177), unconst_u32(649808328)))) {
  out.f3 = bitcast<vec2h>(a0);
  let vf5: f32 = asinh(unconst_f32(0.3236e9));
  out.f0 -= vec4u(round(vec3h(unconst_f16(12543.4), unconst_f16(45363.2), unconst_f16(125.6))).bgrb);
  if bool(textureDimensions(et0).x) {
  var vf6: bool = all(unconst_bool(true));
}
  var vf7: bool = (unconst_bool(false) || unconst_bool(false));
  out.f2 = vec4i(insertBits(unpack4xU8(bitcast<u32>(asinh(unconst_f32(0.4328e-30)))), insertBits(vec4u(unconst_u32(936943097), unconst_u32(285206327), unconst_u32(468347805), unconst_u32(53835892)), vec4u(unconst_u32(908430191), unconst_u32(2154247078), unconst_u32(64315484), unconst_u32(913655835)), unconst_u32(123167315), unconst_u32(303870278)), pack4x8snorm(unpack4x8snorm(unconst_u32(965171095))), unconst_u32(35002324)).barr)[1];
  _ = et0;
}
  out.f3 = bitcast<vec2h>(override1);
  while bool(pack4x8unorm(vec4f(unconst_f32(0.04267), unconst_f32(0.2817), unconst_f32(0.1349), unconst_f32(0.08566)))) {
  out.f2 = i32((unconst_i32(108156079) >= unconst_i32(841321846)));
  var vf8: vec2h = reflect(vec2h(unconst_f16(24260.7), unconst_f16(1343.2)), vec2h(unconst_f16(20753.9), unconst_f16(7912.5)));
  let vf9: u32 = pack4xI8Clamp(vec4i(unconst_i32(22323471), unconst_i32(-257089044), unconst_i32(62622671), unconst_i32(218094842)));
  var vf10: u32 = pack4xU8(vec4u(unconst_u32(830959834), unconst_u32(236402911), unconst_u32(235076004), unconst_u32(158121058)));
  loop {
  var vf11: vec2h = acosh(vec2h(smoothstep(unconst_f16(4912.3), unconst_f16(23280.6), f16(override0))));
  var vf12: vec3f = max(vec3f(unconst_f32(0.05585), unconst_f32(0.1769), unconst_f32(0.1347)), vec3f(unconst_f32(0.05404), unconst_f32(0.02095), unconst_f32(0.1118e-22)));
  var vf13: vec4f = tanh(vec4f(unconst_f32(0.7674e22), unconst_f32(0.3221), unconst_f32(-0.1509e-24), unconst_f32(0.04942)));
  break;
  _ = override0;
}
  break;
  _ = override0;
}
  out.f2 &= i32(override0);
  while bool(a0) {
  out.f0 = vec4u((vec4i(unconst_i32(365488373), unconst_i32(-75455782), unconst_i32(453628917), unconst_i32(77324090)) <= vec4i(unconst_i32(189705686), unconst_i32(915828560), unconst_i32(497665524), unconst_i32(67694691))).baar);
  out.f2 = vec3i((vec3h(unconst_f16(1847.3), unconst_f16(4121.5), unconst_f16(7576.0)) != vec3h(unconst_f16(16520.8), unconst_f16(9813.7), unconst_f16(2629.8)))).z;
}
  out.f3 *= bitcast<vec2h>(override1);
  return out;
  _ = override1;
  _ = override0;
  _ = et0;
}

/* zero global variables used */
@fragment
fn fragment0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  out.f0 &= u32(saturate(vec3h(unconst_f16(8731.1), unconst_f16(26444.6), unconst_f16(9678.0)))[2]);
  return out;
}

/* used global variables: et0 */
@compute @workgroup_size(3, 1, 1)
fn compute0() {
  var vf14: vec3h = atan(vec3h(unconst_f16(2601.7), unconst_f16(8443.6), unconst_f16(30450.9)));
  vf14 += ldexp(vf14.zxxz, vec4i(unconst_i32(-10351057), unconst_i32(628693765), unconst_i32(6940664), unconst_i32(516487715))).wzw;
  var vf15: u32 = pack2x16unorm(vec2f(unconst_f32(0.03995e31), unconst_f32(0.1111e-3)));
  _ = et0;
  _ = fn0(VertexOutput0(vec4u(vf14.yyzz.rabg), vec4f(vf14.xyxy.bbab), vec3i(vf14.xyz.rgg)[0], vf14.xy));
  loop {
  fn0(VertexOutput0(unpack4xU8(u32((unconst_bool(false) && unconst_bool(true)))), vec4f(f32((unconst_bool(false) && unconst_bool(true)))), i32((unconst_bool(false) && unconst_bool(true))), vec2h(f16((unconst_bool(false) && unconst_bool(true))))));
  var vf16: vec3<bool> = (vec3h(unconst_f16(22799.1), unconst_f16(6098.1), unconst_f16(2015.8)) > vec3h(unconst_f16(-3353.9), unconst_f16(19047.5), unconst_f16(1247.0)));
  var vf17 = fn0(VertexOutput0(insertBits(vec2u(unconst_u32(599533033), unconst_u32(1663705230)), vec2u(vf16.bg.rg.rg.gg), unconst_u32(82069348), unconst_u32(844559651)).yxyy, bitcast<vec4f>(insertBits(vec2u(unconst_u32(599533033), unconst_u32(1663705230)), vec2u(vf16.bg.rg.rg.gg), unconst_u32(82069348), unconst_u32(844559651)).ggrg), bitcast<vec2i>(insertBits(vec2u(unconst_u32(599533033), unconst_u32(1663705230)), vec2u(vf16.bg.rg.rg.gg), unconst_u32(82069348), unconst_u32(844559651)).yy.xx.yy)[0], vec2h(insertBits(vec2u(unconst_u32(599533033), unconst_u32(1663705230)), vec2u(vf16.bg.rg.rg.gg), unconst_u32(82069348), unconst_u32(844559651)).gr.rr.gr)));
  return;
  break;
}
  _ = et0;
}`,
});
let commandEncoder25 = device0.createCommandEncoder({});
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 477});
let textureView21 = texture15.createView({
  label: '\u3646\uc47e\u07f4\u187b\u{1ff57}\u360d\u587f\uffa8\u{1fee0}',
  dimension: 'cube-array',
  arrayLayerCount: 6,
});
let textureView22 = texture17.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1});
let renderPassEncoder0 = commandEncoder24.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  clearValue: { r: -642.5, g: 717.0, b: 62.78, a: -455.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
let renderBundle1 = renderBundleEncoder1.finish({});
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle1]);
} catch {}
try {
commandEncoder25.clearBuffer(buffer0);
} catch {}
let buffer13 = device0.createBuffer({
  size: 588,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder26 = device0.createCommandEncoder();
let querySet4 = device0.createQuerySet({type: 'occlusion', count: 720});
let texture18 = device0.createTexture({
  size: [63, 1, 56],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView23 = texture15.createView({dimension: '2d'});
let computePassEncoder25 = commandEncoder25.beginComputePass();
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let texture19 = device0.createTexture({
  size: {width: 127},
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder15.setBindGroup(3, bindGroup5);
} catch {}
try {
commandEncoder26.copyBufferToBuffer(buffer6, 4, buffer0, 0, 4);
} catch {}
try {
computePassEncoder16.insertDebugMarker('\u937a');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture20 = device0.createTexture({
  size: [510, 1, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView24 = texture9.createView({});
let computePassEncoder26 = commandEncoder26.beginComputePass();
try {
computePassEncoder1.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup1, new Uint32Array(580), 285, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle1]);
} catch {}
let commandEncoder27 = device0.createCommandEncoder({});
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 1265});
let texture21 = device0.createTexture({
  size: [510, 1, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView25 = texture21.createView({baseArrayLayer: 0});
try {
computePassEncoder24.setBindGroup(2, bindGroup2, new Uint32Array(1317), 216, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint16', 10, 4);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer3, 32);
} catch {}
let buffer14 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder28 = device0.createCommandEncoder({});
let texture22 = device0.createTexture({
  size: [255, 1, 18],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder1 = commandEncoder28.beginRenderPass({
  colorAttachments: [{view: textureView22, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet4,
  maxDrawCount: 320596042,
});
let sampler18 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 41.81,
  lodMaxClamp: 87.07,
  maxAnisotropy: 4,
});
try {
computePassEncoder9.setBindGroup(3, bindGroup2, new Uint32Array(3105), 243, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer2);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 28, new Int16Array(4283), 200, 48);
} catch {}
let texture23 = device0.createTexture({
  size: {width: 63},
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView26 = texture4.createView({});
try {
computePassEncoder14.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup2, []);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 4, new Uint32Array(13101), 944, 0);
} catch {}
try {
globalThis.someLabel = commandEncoder2.label;
} catch {}
let texture24 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture25 = device0.createTexture({
  size: [64, 64, 12],
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView27 = texture12.createView({baseMipLevel: 0});
let computePassEncoder27 = commandEncoder27.beginComputePass();
try {
computePassEncoder11.setBindGroup(2, bindGroup1, new Uint32Array(3468), 499, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer7, 'uint32', 16, 6);
} catch {}
let texture26 = device0.createTexture({
  size: [63, 1, 26],
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder1.executeBundles([renderBundle1]);
} catch {}
let texture27 = device0.createTexture({
  size: {width: 255},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView28 = texture23.createView({});
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder1.setViewport(8.542862513766714, 6.676362539804238, 52.76318257981568, 36.41750803871167, 0.46174105210019134, 0.7538383723490258);
} catch {}
let commandEncoder29 = device0.createCommandEncoder();
let commandBuffer0 = commandEncoder29.finish();
let textureView29 = texture24.createView({baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder18.setBindGroup(0, bindGroup5, new Uint32Array(4921), 100, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
let imageData1 = new ImageData(80, 56);
try {
computePassEncoder25.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder0.setViewport(49.788346974797975, 7.5737427637755275, 11.506043738859926, 0.572621241406843, 0.8240601287071182, 0.967632883258446);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer5, 0);
} catch {}
let texture28 = device0.createTexture({
  size: {width: 63, height: 1, depthOrArrayLayers: 128},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setVertexBuffer(4, buffer3, 0);
} catch {}
let buffer15 = device0.createBuffer({size: 127, usage: GPUBufferUsage.STORAGE});
let textureView30 = texture1.createView({aspect: 'all'});
let externalTexture1 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'srgb'});
try {
computePassEncoder13.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u{1f8bc}');
} catch {}
await gc();
try {
device0.queue.label = '\u3872\uead7\u11ee\u0eca\u0c5c\u{1facf}\u0d49\uaa3a\u0070\u{1f742}\u{1f970}';
} catch {}
let sampler19 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', magFilter: 'linear'});
try {
computePassEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(2308), 355, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(443);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer3);
} catch {}
let commandEncoder30 = device0.createCommandEncoder({});
let computePassEncoder28 = commandEncoder30.beginComputePass();
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: [undefined], sampleCount: 1, stencilReadOnly: true});
let renderBundle2 = renderBundleEncoder2.finish({});
try {
renderPassEncoder1.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer5, 0, 0);
} catch {}
try {
externalTexture0.label = '\u{1f75e}\u5b1e\u1802\u347f\u3674\u0217\u9b32';
} catch {}
let commandEncoder31 = device0.createCommandEncoder({});
let computePassEncoder29 = commandEncoder31.beginComputePass();
try {
computePassEncoder9.setBindGroup(1, bindGroup1);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer9, 'uint32', 0, 10);
} catch {}
let texture29 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView31 = texture8.createView({});
try {
computePassEncoder1.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 46},
  aspect: 'all',
}, new Uint8Array(196).fill(108), /* required buffer size: 196 */
{offset: 196}, {width: 290, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

struct T4 {
  @size(192) f0: T3,
}

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

override override2: i32;

@id(19839) override override6: bool;

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

override override9: f16;

var<workgroup> vw0: array<array<atomic<u32>, 5>, 1>;

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

struct VertexOutput1 {
  @location(0) f4: u32,
  @location(14) f5: vec2f,
  @location(10) f6: i32,
  @builtin(position) f7: vec4f,
  @location(9) @interpolate(linear, centroid) f8: vec4h,
}

override override3: bool;

struct T5 {
  @align(16) @size(16) f0: array<array<array<vec2i, 1>, 1>, 1>,
  @align(16) @size(80) f1: vec2i,
  @size(96) f2: vec4f,
  @align(8) @size(160) f3: vec2h,
  @align(16) @size(528) f4: array<vec2h, 8>,
}

@id(19284) override override8: i32;

struct FragmentOutput1 {
  @location(0) f0: i32,
  @builtin(sample_mask) f1: u32,
}

var<workgroup> vw1: f32;

struct T2 {
  @size(136) f0: array<array<vec2f, 3>>,
}

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

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

@id(21683) override override5: f16 = 1624.7;

override override7: i32;

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

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

struct T6 {
  @size(38) f0: vec2<bool>,
  @align(2) f1: array<array<bool, 1>, 13>,
}

var<workgroup> vw2: atomic<u32>;

@id(64049) override override4: i32;

struct T3 {
  @size(144) f0: array<array<array<vec4h, 1>, 1>>,
}

var<workgroup> vw3: array<array<vec2<bool>, 1>, 1>;

/* zero global variables used */
@vertex
fn vertex1(@location(8) @interpolate(flat, sample) a0: vec2i) -> VertexOutput1 {
  var out: VertexOutput1;
  out.f8 -= vec4h(f16(override6));
  out.f8 += vec4h(f16(sin(unconst_f32(0.01359e11))));
  out.f7 += vec4f(f32(tan(unconst_f16(746.0))));
  out.f6 = i32(override5);
  out.f8 -= vec4h(f16(override4));
  var vf18: i32 = override7;
  let vf19: i32 = override4;
  return out;
  _ = override7;
  _ = override6;
  _ = override4;
  _ = override5;
}

/* zero global variables used */
@fragment
fn fragment1() -> FragmentOutput1 {
  var out: FragmentOutput1;
  let vf20: vec2f = exp2(vec2f(unconst_f32(0.00506), unconst_f32(0.1048)));
  out = FragmentOutput1(bitcast<i32>(unpack2x16unorm(unconst_u32(2606860836)).g), pack2x16snorm(unpack2x16unorm(unconst_u32(2606860836))));
  out.f1 = vec4u(select(vec4i(unconst_i32(90046139), unconst_i32(16774221), unconst_i32(228522387), unconst_i32(76624675)), vec4i((vec4f(countLeadingZeros(vec4i(unconst_i32(469461169), unconst_i32(579915357), unconst_i32(961409109), unconst_i32(57805523)))) < vec4f(unconst_f32(0.02751e-12), unconst_f32(0.01552), unconst_f32(0.1399), unconst_f32(0.4290)))), unconst_bool(true)))[2];
  switch bitcast<i32>(pack2x16snorm(vec2f(unconst_f32(0.1170), unconst_f32(0.2821)))) { 
  default {
  out.f0 &= override7;
  return out;
  _ = override7;
}
  }
  let vf21: f32 = smoothstep(unconst_f32(0.1102e-15), unconst_f32(0.02706), unconst_f32(-0.01646));
  return out;
  _ = override7;
}

/* zero global variables used */
@compute @workgroup_size(1, 1, 1)
fn compute1() {
  vw1 = bitcast<f32>(atomicLoad(&(*&vw0)[unconst_u32(539668599)][unconst_u32(2524080052)]));
}

/* zero global variables used */
@compute @workgroup_size(1, 2, 1)
fn compute2() {
  let vf22: u32 = atomicLoad(&vw0[0][unconst_u32(1116354758)]);
  atomicAnd(&vw2, unconst_u32(188894822));
  atomicSub(&vw0[0][unconst_u32(194967682)], unconst_u32(475689429));
  let ptr0: ptr<workgroup, array<vec2<bool>, 1>> = &vw3[0];
}`,
});
let commandEncoder32 = device0.createCommandEncoder();
let texture30 = device0.createTexture({
  size: [510, 1, 77],
  sampleCount: 1,
  format: 'rgba8sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder30 = commandEncoder32.beginComputePass();
try {
renderPassEncoder0.setBindGroup(1, bindGroup2);
} catch {}
let imageData2 = new ImageData(28, 24);
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let textureView32 = texture26.createView({dimension: '2d', baseArrayLayer: 5});
try {
computePassEncoder1.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup2, new Uint32Array(605), 24, 0);
} catch {}
await gc();
let commandEncoder33 = device0.createCommandEncoder({});
let computePassEncoder31 = commandEncoder33.beginComputePass();
let sampler20 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'less-equal',
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer6, 8, 2);
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\ua6eb');
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte240m', transfer: 'iec6196624'} });
let buffer16 = device0.createBuffer({
  size: 24340,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
let commandEncoder34 = device0.createCommandEncoder({});
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 222});
let texture31 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 78},
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture32 = device0.createTexture({
  size: [255],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView33 = texture23.createView({format: 'rgba8sint', baseArrayLayer: 0});
let sampler21 = device0.createSampler({addressModeU: 'repeat', minFilter: 'nearest', mipmapFilter: 'linear'});
try {
computePassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(444), 114, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder0.setStencilReference(214);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer13, 24, new Uint32Array(1222).fill(11_533), 140, 0);
} catch {}
let buffer17 = device0.createBuffer({size: 256, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let querySet7 = device0.createQuerySet({type: 'occlusion', count: 1283});
let textureView34 = texture9.createView({});
try {
computePassEncoder16.setBindGroup(1, bindGroup2, new Uint32Array(1751), 338, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup5, []);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 114 widthInBlocks: 57 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 406 */
  offset: 406,
  bytesPerRow: 19200,
  rowsPerImage: 118,
  buffer: buffer16,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 57, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup6 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView1}]});
let texture33 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 59},
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder24.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(1955), 456, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle1]);
} catch {}
try {
commandEncoder34.copyBufferToBuffer(buffer14, 0, buffer16, 3852, 8);
} catch {}
let computePassEncoder32 = commandEncoder34.beginComputePass();
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 197, resource: sampler4}, {binding: 1, resource: externalTexture1}],
});
let texture34 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture35 = device0.createTexture({
  size: [64, 64, 12],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView35 = texture7.createView({});
try {
renderPassEncoder0.setIndexBuffer(buffer16, 'uint32', 2_316, 5_199);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
let commandEncoder35 = device0.createCommandEncoder({});
let texture36 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 14},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView36 = texture23.createView({format: 'rgba8sint'});
try {
computePassEncoder22.setBindGroup(1, bindGroup2, new Uint32Array(1890), 1_418, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer17, 0, 41);
} catch {}
try {
globalThis.someLabel = textureView28.label;
} catch {}
let bindGroup8 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 197, resource: sampler3}, {binding: 1, resource: externalTexture0}],
});
let buffer18 = device0.createBuffer({size: 456, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
try {
externalTexture0.label = '\u{1faa5}\u0996\u027e\u4701';
} catch {}
let textureView37 = texture36.createView({mipLevelCount: 1});
let sampler22 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 99.58,
  maxAnisotropy: 1,
});
try {
renderPassEncoder1.setIndexBuffer(buffer7, 'uint16', 32, 5);
} catch {}
try {
commandEncoder35.insertDebugMarker('\u90c0');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 2, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup9 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 197, resource: sampler13}, {binding: 1, resource: externalTexture0}],
});
let textureView38 = texture27.createView({});
let computePassEncoder33 = commandEncoder35.beginComputePass();
let sampler23 = device0.createSampler({addressModeU: 'repeat', compare: 'less-equal'});
let pipeline0 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}});
let externalTexture2 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder4.setBindGroup(2, bindGroup5);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup6, new Uint32Array(2894), 319, 0);
} catch {}
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r16sint']});
let renderBundle3 = renderBundleEncoder3.finish({});
try {
renderPassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(5685), 641, 0);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(178);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer6, 0);
} catch {}
try {
computePassEncoder14.insertDebugMarker('\ub6ac');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(0);
let sampler24 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 92.94,
});
try {
computePassEncoder20.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 33, y: 19 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 65, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture37 = device0.createTexture({
  size: [127, 1, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler25 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  compare: 'greater-equal',
});
try {
computePassEncoder26.setPipeline(pipeline0);
} catch {}
let commandEncoder36 = device0.createCommandEncoder({});
let computePassEncoder34 = commandEncoder36.beginComputePass();
let sampler26 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 88.28, maxAnisotropy: 1});
try {
computePassEncoder21.setBindGroup(2, bindGroup2, new Uint32Array(3355), 388, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup1, new Uint32Array(246), 64, 0);
} catch {}
try {
renderPassEncoder0.setScissorRect(27, 1, 1, 7);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint16', 2, 4);
} catch {}
let buffer19 = device0.createBuffer({size: 240, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder30.setBindGroup(1, bindGroup6, new Uint32Array(1536), 225, 0);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle1, renderBundle3, renderBundle1, renderBundle1, renderBundle3, renderBundle3, renderBundle3, renderBundle1]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint32', 0, 5);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer13, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 11},
  aspect: 'all',
}, new Uint8Array(97_527).fill(89), /* required buffer size: 97_527 */
{offset: 87, bytesPerRow: 174, rowsPerImage: 40}, {width: 34, height: 0, depthOrArrayLayers: 15});
} catch {}
let commandEncoder37 = device0.createCommandEncoder({});
let textureView39 = texture18.createView({});
try {
computePassEncoder29.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle3, renderBundle3, renderBundle3, renderBundle3]);
} catch {}
try {
buffer3.unmap();
} catch {}
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout0]});
let commandEncoder38 = device0.createCommandEncoder({});
let sampler27 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 97.63});
try {
computePassEncoder20.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(592);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
let bindGroup10 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView0}]});
let commandEncoder39 = device0.createCommandEncoder({});
let textureView40 = texture24.createView({arrayLayerCount: 4});
let renderPassEncoder2 = commandEncoder38.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  clearValue: { r: -862.0, g: 527.9, b: -210.4, a: 952.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet7,
});
let sampler28 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.71,
});
try {
computePassEncoder30.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer16, 'uint32', 3_060, 1_233);
} catch {}
try {
commandEncoder37.copyTextureToTexture({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture13,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 0},
  aspect: 'all',
},
{width: 32, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
try {
  await promise9;
} catch {}
let imageData3 = new ImageData(84, 16);
let buffer20 = device0.createBuffer({size: 332, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let texture38 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 64},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder35 = commandEncoder37.beginComputePass();
try {
computePassEncoder12.setBindGroup(0, bindGroup10);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup6, new Uint32Array(486), 140, 0);
} catch {}
let imageData4 = new ImageData(4, 8);
try {
computePassEncoder12.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder34.setPipeline(pipeline0);
} catch {}
try {
commandEncoder39.copyBufferToTexture({
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 720 */
  offset: 720,
  bytesPerRow: 7936,
  buffer: buffer16,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 4},
  aspect: 'all',
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder39.copyTextureToTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 3},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 4},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 13});
} catch {}
let commandEncoder40 = device0.createCommandEncoder({});
let textureView41 = texture31.createView({baseArrayLayer: 7, arrayLayerCount: 3});
let sampler29 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 99.37});
try {
computePassEncoder24.setBindGroup(0, bindGroup2, new Uint32Array(1003), 243, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer7, 0); };
} catch {}
try {
renderPassEncoder2.beginOcclusionQuery(721);
} catch {}
let buffer21 = device0.createBuffer({
  size: 156,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder41 = device0.createCommandEncoder({});
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 1065});
let texture39 = device0.createTexture({
  size: {width: 127},
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView42 = texture29.createView({dimension: 'cube'});
let computePassEncoder36 = commandEncoder40.beginComputePass();
let renderPassEncoder3 = commandEncoder39.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  clearValue: { r: -193.2, g: 361.3, b: 733.9, a: 107.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet5,
  maxDrawCount: 10591715,
});
try {
computePassEncoder33.setBindGroup(0, bindGroup2, []);
} catch {}
try {
computePassEncoder29.setBindGroup(1, bindGroup1, new Uint32Array(1967), 565, 0);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: 75.59, g: -280.1, b: 384.9, a: 361.7, });
} catch {}
let buffer22 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let texture40 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 72},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView43 = texture40.createView({});
let computePassEncoder37 = commandEncoder41.beginComputePass();
try {
computePassEncoder0.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup4, new Uint32Array(1425), 111, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle3, renderBundle1]);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let bindGroup11 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 197, resource: sampler7}, {binding: 1, resource: externalTexture0}],
});
try {
renderPassEncoder1.setBindGroup(3, bindGroup8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 47, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(61).fill(235), /* required buffer size: 61 */
{offset: 61}, {width: 61, height: 0, depthOrArrayLayers: 1});
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture0}, {binding: 197, resource: sampler17}],
});
let commandEncoder42 = device0.createCommandEncoder();
let computePassEncoder38 = commandEncoder42.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(2, 1, 2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer6, 0); };
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup11, new Uint32Array(1178), 162, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 44, 7);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer8.unmap();
} catch {}
let bindGroup13 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView1}]});
let commandEncoder43 = device0.createCommandEncoder({});
let texture41 = device0.createTexture({
  size: [510],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder32.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder26.setBindGroup(0, bindGroup8, new Uint32Array(126), 5, 0);
} catch {}
let commandEncoder44 = device0.createCommandEncoder({});
let texture42 = device0.createTexture({
  size: [510],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder39 = commandEncoder44.beginComputePass();
let renderPassEncoder4 = commandEncoder43.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  clearValue: { r: 896.7, g: -987.6, b: 236.9, a: -1.403, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 34596177,
});
let sampler30 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 94.89, compare: 'never'});
try {
computePassEncoder33.setBindGroup(2, bindGroup7, new Uint32Array(1228), 0, 0);
} catch {}
try {
computePassEncoder24.end();
} catch {}
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer7, 'uint16', 18, 14);
} catch {}
try {
commandEncoder23.copyTextureToBuffer({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 624 widthInBlocks: 156 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1436 */
  offset: 1436,
  bytesPerRow: 18688,
  buffer: buffer16,
}, {width: 156, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 197,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let texture43 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 33},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer10, 4); };
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup6, []);
} catch {}
try {
commandEncoder23.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2256 */
  offset: 2256,
  buffer: buffer16,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer0, 8, new BigUint64Array(8278), 2839, 0);
} catch {}
let computePassEncoder40 = commandEncoder23.beginComputePass();
let externalTexture3 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'});
try {
computePassEncoder10.setBindGroup(1, bindGroup8);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup5, new Uint32Array(694), 11, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 152,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let buffer23 = device0.createBuffer({
  size: 146,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder45 = device0.createCommandEncoder();
let computePassEncoder41 = commandEncoder45.beginComputePass();
let sampler31 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.43,
  compare: 'equal',
});
try {
renderPassEncoder2.end();
} catch {}
try {
renderPassEncoder1.setStencilReference(424);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer17, 0, 16);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
globalThis.someLabel = externalTexture3.label;
} catch {}
let bindGroup14 = device0.createBindGroup({
  label: '\u039f\u757c\ue074\u3dda\u098f\u7812\u0634\u{1f71c}\u070b\u6147\ub947',
  layout: veryExplicitBindGroupLayout5,
  entries: [{binding: 152, resource: textureView18}],
});
let commandEncoder46 = device0.createCommandEncoder({});
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 1138});
try {
computePassEncoder16.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder32.end();
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup3, new Uint32Array(105), 30, 0);
} catch {}
try {
commandEncoder46.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4412 */
  offset: 4412,
  buffer: buffer16,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup15 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 197, resource: sampler0}, {binding: 1, resource: externalTexture2}],
});
let commandEncoder47 = device0.createCommandEncoder({});
try {
computePassEncoder13.setBindGroup(1, bindGroup8);
} catch {}
try {
commandEncoder38.resolveQuerySet(querySet7, 221, 1, buffer12, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 46, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup16 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView0}]});
let commandEncoder48 = device0.createCommandEncoder();
let texture44 = device0.createTexture({
  size: [63, 1, 57],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView44 = texture22.createView({baseArrayLayer: 1, arrayLayerCount: 2});
try {
computePassEncoder4.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer6);
} catch {}
try {
commandEncoder47.copyTextureToBuffer({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 232 widthInBlocks: 58 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1660 */
  offset: 1660,
  bytesPerRow: 37376,
  buffer: buffer16,
}, {width: 58, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer24 = device0.createBuffer({size: 35, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let commandEncoder49 = device0.createCommandEncoder({});
let textureView45 = texture4.createView({aspect: 'all'});
let texture45 = device0.createTexture({
  size: {width: 63, height: 1, depthOrArrayLayers: 147},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView46 = texture43.createView({dimension: '3d', mipLevelCount: 1});
let computePassEncoder42 = commandEncoder48.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer12, 228); };
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup13, new Uint32Array(4330), 990, 0);
} catch {}
try {
renderPassEncoder0.setScissorRect(11, 4, 2, 7);
} catch {}
try {
commandEncoder39.copyTextureToBuffer({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1884 */
  offset: 1884,
  bytesPerRow: 57344,
  buffer: buffer16,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let recycledExplicitBindGroupLayout1 = pipeline0.getBindGroupLayout(0);
let buffer25 = device0.createBuffer({size: 68, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let commandEncoder50 = device0.createCommandEncoder({});
let textureView47 = texture12.createView({dimension: '3d'});
try {
computePassEncoder15.setBindGroup(2, bindGroup15, new Uint32Array(1456), 125, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup13, new Uint32Array(1320), 404, 0);
} catch {}
try {
renderPassEncoder1.setViewport(60.13784269369966, 40.248733403005616, 1.6072921362912982, 20.896948176910254, 0.8993339294994944, 0.9073805585646563);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer2, 8, 1);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
commandEncoder47.copyBufferToBuffer(buffer23, 40, buffer2, 8, 0);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 664 */
  offset: 664,
  bytesPerRow: 38656,
  buffer: buffer16,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 2},
  aspect: 'all',
}, {width: 18, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(113).fill(115), /* required buffer size: 113 */
{offset: 113, bytesPerRow: 79}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout2 = pipeline0.getBindGroupLayout(0);
let commandBuffer1 = commandEncoder38.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer23, 0); };
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(280);
} catch {}
let computePassEncoder43 = commandEncoder39.beginComputePass();
try {
computePassEncoder7.setBindGroup(1, bindGroup14, new Uint32Array(1902), 811, 0);
} catch {}
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup8, []);
} catch {}
try {
commandEncoder47.copyTextureToBuffer({
  texture: texture39,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 208 */
  offset: 208,
  bytesPerRow: 18688,
  rowsPerImage: 60,
  buffer: buffer20,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 77, y: 0, z: 6},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 213},
  aspect: 'all',
},
{width: 104, height: 0, depthOrArrayLayers: 287});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer26 = device0.createBuffer({size: 304, usage: GPUBufferUsage.COPY_DST});
let texture46 = device0.createTexture({
  size: [255],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView48 = texture38.createView({mipLevelCount: 1});
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpte240m', transfer: 'unspecified'} });
let bindGroup17 = device0.createBindGroup({layout: veryExplicitBindGroupLayout5, entries: [{binding: 152, resource: textureView27}]});
let commandEncoder51 = device0.createCommandEncoder({});
let querySet10 = device0.createQuerySet({type: 'occlusion', count: 123});
let textureView49 = texture1.createView({mipLevelCount: 1});
let renderPassEncoder5 = commandEncoder49.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  clearValue: { r: -745.5, g: 221.5, b: -787.7, a: -548.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder15.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer7, 'uint16', 2, 2);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer3, 0);
} catch {}
try {
commandEncoder50.copyBufferToTexture({
  /* bytesInLastRow: 856 widthInBlocks: 107 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1512 */
  offset: 1512,
  buffer: buffer16,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {width: 107, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder44 = commandEncoder47.beginComputePass();
try {
computePassEncoder38.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer9, 'uint16', 22, 34);
} catch {}
try {
commandEncoder50.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2344 */
  offset: 2344,
  bytesPerRow: 6912,
  rowsPerImage: 1167,
  buffer: buffer16,
}, {
  texture: texture19,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup18 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView6}]});
let commandEncoder52 = device0.createCommandEncoder({});
let commandBuffer2 = commandEncoder34.finish({});
let texture47 = device0.createTexture({
  size: [255],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView50 = texture15.createView({dimension: '2d'});
try {
commandEncoder46.resolveQuerySet(querySet0, 27, 0, buffer24, 0);
} catch {}
let texture48 = device0.createTexture({size: [64, 64, 12], format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder31.setBindGroup(3, bindGroup8);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer1, 196); };
} catch {}
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
commandEncoder51.copyBufferToBuffer(buffer6, 12, buffer10, 0, 4);
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 152,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let bindGroup19 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView0}]});
let buffer27 = device0.createBuffer({size: 106, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder53 = device0.createCommandEncoder({});
let textureView51 = texture27.createView({dimension: '1d', format: 'rgba8sint', mipLevelCount: 1});
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(232);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle1]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(386).fill(21), /* required buffer size: 386 */
{offset: 386}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder54 = device0.createCommandEncoder({});
let textureView52 = texture28.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderPassEncoder6 = commandEncoder53.beginRenderPass({
  colorAttachments: [{
  view: textureView39,
  depthSlice: 29,
  clearValue: { r: -756.9, g: -514.5, b: -667.7, a: -643.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 106242585,
});
try {
computePassEncoder21.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup3, []);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle3, renderBundle1]);
} catch {}
try {
commandEncoder50.copyTextureToTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture25,
  mipLevel: 1,
  origin: {x: 4, y: 26, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData5 = new ImageData(72, 44);
let renderBundleEncoder4 = device0.createRenderBundleEncoder({
  label: '\ud353\udad4\uf2b0\u04c3\u0b3f\ub3d7\uf09b',
  colorFormats: ['r16sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder1.setBindGroup(3, bindGroup11);
} catch {}
try {
computePassEncoder20.setBindGroup(0, bindGroup4, new Uint32Array(250), 62, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder6.setVertexBuffer(1, buffer17, 8);
} catch {}
try {
  await buffer4.mapAsync(GPUMapMode.WRITE, 0, 12);
} catch {}
try {
commandEncoder54.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1232 */
  offset: 1232,
  buffer: buffer16,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 20, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
computePassEncoder38.insertDebugMarker('\u5131');
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

requires pointer_composite_access;

diagnostic(info, xyz);

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

struct T2 {
  @align(4) @size(128) f0: f16,
  @size(1024) f1: array<atomic<u32>>,
}

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

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

@group(0) @binding(197) var sam2: sampler;

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

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

var<workgroup> vw5: u32;

struct T1 {
  @size(16) f0: i32,
  @size(44) f1: array<u32>,
}

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

struct S0 {
  @location(0) f0: u32,
}

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

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

var<workgroup> vw4: T0;

/* zero global variables used */
@fragment
fn fragment2(a0: S0) -> FragmentOutput2 {
  var out: FragmentOutput2;
  let vf23: vec4f = floor(vec4f(unconst_f32(0.3178e29), unconst_f32(0.1016e-13), unconst_f32(0.1058), unconst_f32(0.1054)));
  out.f0 = vec4i(exp(vec3f(unconst_f32(0.2258), unconst_f32(0.7495), unconst_f32(0.3114))).rbbg.xyzx.aaar);
  out.f0 = bitcast<vec4i>(vf23.wxxw.yyyw.bbrg.aagg);
  switch vec2i(exp(vec2f(unconst_f32(0.05750), unconst_f32(0.3625))).gg.gr).g { 
  default {
  var vf24: vec4h = faceForward(vec4h(unconst_f16(288.3), unconst_f16(16341.8), unconst_f16(45211.7), unconst_f16(10308.3)), vec4h(unconst_f16(-20955.9), unconst_f16(5415.2), unconst_f16(16232.5), unconst_f16(2051.1)), vec4h(f16(pack2x16float(vec2f(unconst_f32(0.5715), unconst_f32(0.1712))))));
  var vf25: vec2f = atanh(vec2f(unconst_f32(0.00810e24), unconst_f32(-0.1145)));
  out.f0 = vec4i(sinh(vec3f(unconst_f32(-0.00921), unconst_f32(0.2768), unconst_f32(0.1755e-29))).rbbb.zxyz);
  while bool(degrees(vec2f(unconst_f32(0.2523e-21), unconst_f32(0.1817e36)))[1]) {
  out = FragmentOutput2(vec4i(i32(a0.f0)));
}
  break;
}
  }
  out.f0 -= bitcast<vec4i>(atan(vec3f(unconst_f32(-0.1937), unconst_f32(0.2825), unconst_f32(0.2906))).rgbb);
  out.f0 *= vec4i(exp(vec3f(unconst_f32(0.07073e-14), unconst_f32(0.01996), unconst_f32(0.1660e-33))).zyzx);
  var vf26: vec4f = ceil(vec4f(unconst_f32(-0.06678e4), unconst_f32(0.1839e-30), unconst_f32(0.03751e-44), unconst_f32(0.1649)));
  vf26 += vec4f(ldexp(unconst_f32(0.09188e-4), i32(atanh(unconst_f16(45021.8)))));
  let vf27: vec4i = (vec4i(unconst_i32(20730861), unconst_i32(668875083), unconst_i32(283830593), unconst_i32(-336887882)) ^ vec4i(unconst_i32(245585810), unconst_i32(306767234), unconst_i32(760439873), unconst_i32(265125493)));
  return out;
}

/* used global variables: et2, sam2 */
@compute @workgroup_size(1, 1, 2)
fn compute3() {
  switch bitcast<i32>(pack2x16snorm(vec2f(unconst_f32(0.1138e9), unconst_f32(0.4565e-27)))) { 
  default {
  let ptr1: ptr<workgroup, array<vec2u, 1>> = &(*&vw4).f0;
  while bool(workgroupUniformLoad(&vw4).f0[0].r) {
  switch i32(pack4xI8(bitcast<vec4i>(insertBits(vec4u(unconst_u32(1395002379), unconst_u32(2675370170), unconst_u32(569870877), unconst_u32(1117305830)), vec4u(unconst_u32(79542027), unconst_u32(243688883), unconst_u32(1249725004), unconst_u32(210881543)), unconst_u32(1457458051), unconst_u32(133148072))))) { 
  default {
  vw4 = T0(array<vec2u, 1>(vec2u(u32(log(unconst_f16(12632.4))))));
  vw4 = T0(array<vec2u, 1>(vec2u(textureLoad(et2, vec2u((*&vw4).f0[pack4x8unorm(textureSampleBaseClampToEdge(et2, sam2, vec2f(unconst_f32(0.09549e-14), unconst_f32(0.05286))))][unconst_u32(275921403)])).rb)));
  let vf28: vec4f = quantizeToF16(vec4f(unconst_f32(0.08322), unconst_f32(0.05958), unconst_f32(0.1051), unconst_f32(0.2660)));
  _ = et2;
  _ = sam2;
}
  }
  var vf29: f16 = distance(unconst_f16(19621.0), unconst_f16(3957.3));
  _ = et2;
  _ = sam2;
}
  let vf30: vec2f = degrees(vec2f(unconst_f32(0.04594), unconst_f32(0.1796e21)));
  vw5 = bitcast<vec4u>(unpack4xI8(pack4x8snorm(unpack4x8snorm(unconst_u32(562206308)))))[2];
  while bool((*ptr1)[0][1]) {
  var vf31: bool = (unconst_bool(false) || unconst_bool(true));
  var vf32: vec3f = sinh(vec3f(unconst_f32(0.1941e-44), unconst_f32(-0.07968), unconst_f32(0.2561e12)));
}
  let vf33: vec2h = acos(vec2h(unconst_f16(2700.0), unconst_f16(5445.5)));
  _ = sam2;
  _ = et2;
}
  }
  vw4.f0[unconst_u32(518814170)] += vec2u(textureLoad(et2, vec2u(unconst_u32(954253980), unconst_u32(3660179951))).ag);
  let vf34: vec3<bool> =  !vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true));
  vw5 <<= vw4.f0[0][0];
  let vf35: vec4f = textureSampleBaseClampToEdge(et2, sam2, vec2f(unconst_f32(0.00796), unconst_f32(0.4375)));
  vw4 = T0(array<vec2u, 1>(bitcast<vec2u>(firstTrailingBit(vec4i(unconst_i32(44560744), unconst_i32(424598395), unconst_i32(1257179159), unconst_i32(487042518))).bb)));
  vw5 = (*&vw5);
  let vf36: u32 = (*&vw4).f0[0][unconst_u32(2483968596)];
  vw5 >>= vw4.f0[0][0];
  vw5 = (*&vw4).f0[unconst_u32(447754974)][unconst_u32(1877677741)];
  _ = sam2;
  _ = et2;
}

/* zero global variables used */
@compute @workgroup_size(1, 1, 2)
fn compute4() {
  {
  let ptr2: ptr<workgroup, array<vec2u, 1>> = &(*&vw4).f0;
}
  while bool((*&vw4).f0[unconst_u32(74145772)].g) {
  vw5 = vec4u(clamp(vec4h(unconst_f16(23225.7), unconst_f16(8980.3), unconst_f16(3640.9), unconst_f16(818.2)), vec4h(unconst_f16(11553.1), unconst_f16(8462.8), unconst_f16(4913.6), unconst_f16(9315.7)), vec4h(unconst_f16(16995.6), unconst_f16(6673.1), unconst_f16(1092.0), unconst_f16(6474.0))).rggb).b;
  vw4.f0[unconst_u32(73732631)] = unpack4xU8(unconst_u32(27670919)).rr;
  vw4 = T0(array<vec2u, 1>(vec2u((*&vw5))));
  break;
}
  vw5 = bitcast<vec4u>(unpack4x8unorm(unconst_u32(243821008)).xwzy)[1];
  var vf37: vec3f = asinh(vec3f(unconst_f32(0.2211), unconst_f32(0.03274e-7), unconst_f32(0.3241e-30)));
}`,
});
let buffer28 = device0.createBuffer({
  size: 0,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture49 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 32},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler32 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 76.55});
try {
renderPassEncoder4.setBindGroup(0, bindGroup14, new Uint32Array(104), 16, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer6, 'uint16', 0, 4);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(1, buffer3);
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 175, y: 0, z: 4},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 76, y: 0, z: 1},
  aspect: 'all',
},
{width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u9a3d');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(30).fill(245), /* required buffer size: 30 */
{offset: 30}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

enable f16;

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

@group(0) @binding(762) var<storage, read_write> buffer31: array<array<array<array<f16, 19>, 1>, 1>>;

override override11: u32 = 698417442;

@id(17003) override override16 = 0.00404;

var<workgroup> vw6: atomic<i32>;

override override17 = 0.04491e-22;

@id(1863) override override12: i32;

override override10: f16;

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

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

struct VertexOutput2 {
  @builtin(position) f9: vec4f,
}

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

struct FragmentOutput3 {
  @location(4) f0: vec2i,
}

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

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

override override20: u32;

@id(26739) override override19: f16 = 971.8;

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

@group(2) @binding(1) var st1: texture_storage_2d_array<r32sint, write>;

struct VertexOutput3 {
  @builtin(position) f10: vec4f,
  @location(0) @interpolate(flat, either) f11: u32,
  @location(2) f12: vec4i,
  @location(15) @interpolate(linear, centroid) f13: vec4f,
  @location(5) f14: vec4h,
  @location(7) @interpolate(perspective, centroid) f15: vec4h,
}

@id(45164) override override14 = 0.2129;

override override13: u32 = 857643815;

@group(0) @binding(3) var<uniform> buffer30: array<array<vec4f, 13>, 1>;

override override18: i32 = 112046592;

struct T1 {
  @align(16) @size(208) f0: vec2i,
}

@id(409) override override15: i32 = 780802146;

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

/* zero global variables used */
@vertex
fn vertex2(@location(10) a0: f16, @location(5) a1: u32, @location(2) a2: vec2h, @location(9) a3: vec4h, @location(8) a4: u32, @location(3) a5: vec2i) -> VertexOutput2 {
  var out: VertexOutput2;
  let vf38: bool = (unconst_f16(2058.2) > unconst_f16(8272.6));
  out.f9 = vec4f(f32(a0));
  out.f9 = vec4f(f32(saturate(unconst_f16(7440.8))));
  out.f9 = vec4f(f32(override10));
  let vf39: i32 = override12;
  switch i32(all((vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false)) | vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false))))) { 
  default {
  let vf40: f16 = override10;
  let vf41: f16 = override10;
  out = VertexOutput2(unpack4x8unorm((unconst_u32(164433439) >> unconst_u32(1456575018))));
  _ = override10;
}
  }
  var vf42: vec3<bool> = (vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false)) | vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true)));
  out.f9 = vec4f(f32((unconst_f16(19974.7) > unconst_f16(-61488.0))));
  return out;
  _ = override10;
  _ = override12;
}

/* zero global variables used */
@vertex
fn vertex3(@location(12) @interpolate(flat) a0: vec2h) -> VertexOutput3 {
  var out: VertexOutput3;
  for (var it0=u32(length(vec3f(unconst_f32(0.04306e7), unconst_f32(0.1052e-13), unconst_f32(0.06300)))); it0<(pack2x16snorm(pow(vec2f(smoothstep(vec2h(unconst_f16(26006.7), unconst_f16(3261.0)), vec2h(unconst_f16(9385.2), unconst_f16(6669.4)), vec2h(unconst_f16(4851.6), unconst_f16(-2733.1))).gg), pow(vec2f(unconst_f32(0.08811), unconst_f32(0.05435)), vec2f(unconst_f32(0.8087), unconst_f32(0.1898e8))))) & 0xfff); it0++) {
  let vf43: u32 = override11;
  _ = override11;
}
  let vf44: i32 = dot4I8Packed(unconst_u32(229472122), unconst_u32(419392500));
  let vf45: vec2u =  ~vec2u(unconst_u32(682443571), unconst_u32(84784805));
  let vf46: i32 = override12;
  var vf47: vec4i = reverseBits(vec4i(unconst_i32(681230198), unconst_i32(284098930), unconst_i32(267678656), unconst_i32(1367625525)));
  let vf48: vec2h = log(vec2h(unconst_f16(46860.8), unconst_f16(4396.1)));
  let vf49: vec4<bool> = (vec4u(unconst_u32(978875652), unconst_u32(415955390), unconst_u32(1987948230), unconst_u32(202268615)) <= vec4u(unconst_u32(1093396780), unconst_u32(24793226), unconst_u32(597001420), unconst_u32(489586365)));
  return out;
  _ = override12;
  _ = override11;
}

/* used global variables: buffer29, buffer30, st1 */
@fragment
fn fragment3() -> FragmentOutput3 {
  var out: FragmentOutput3;
  out.f0 *= vec2i(i32(buffer29[unconst_u32(332015359)][unconst_u32(265309132)][13][0]));
  let ptr3: ptr<storage, f16, read_write> = &buffer29[arrayLength(&buffer29)][4][13][0];
  out.f0 *= vec2i((*&buffer30)[0][12].wy);
  let ptr4: ptr<storage, f16, read_write> = &(*&buffer29)[unconst_u32(115381979)][unconst_u32(679953100)][13][unconst_u32(3016767303)];
  let ptr5: ptr<uniform, vec4f> = &(*&buffer30)[0][12];
  var vf50: vec4f = unpack4x8unorm(unconst_u32(798385354));
  let ptr6: ptr<storage, array<array<array<array<f16, 1>, 14>, 5>>, read_write> = &(*&buffer29);
  out.f0 = vec2i(i32((*&buffer29)[unconst_u32(423321878)][4][unconst_u32(125924959)][0]));
  out.f0 |= bitcast<vec2i>((*&buffer30)[0][12].rr);
  let ptr7: ptr<storage, array<f16, 1>, read_write> = &(*&buffer29)[arrayLength(&(*&buffer29))][4][unconst_u32(599879591)];
  textureStore(st1, vec2i(unconst_i32(245527790), unconst_i32(42600168)), unconst_i32(369563052), vec4i(vec4i(unconst_i32(1495860480), unconst_i32(4817673), unconst_i32(67295183), unconst_i32(565676))));
  return out;
  _ = buffer30;
  _ = buffer29;
  _ = st1;
}

/* used global variables: buffer31 */
@compute @workgroup_size(6, 1, 1)
fn compute5(@builtin(num_workgroups) a0: vec3u) {
  let ptr8: ptr<storage, f16, read_write> = &buffer31[unconst_u32(680467853)][0][u32(buffer31[arrayLength(&buffer31)][unconst_u32(2499951772)][unconst_u32(552095460)][18])][unconst_u32(25851139)];
  return;
  _ = buffer31;
}`,
});
let renderPassEncoder7 = commandEncoder49.beginRenderPass({colorAttachments: [{view: textureView39, depthSlice: 28, loadOp: 'clear', storeOp: 'discard'}]});
let sampler33 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 45.44,
  lodMaxClamp: 57.10,
  maxAnisotropy: 1,
});
try {
renderPassEncoder1.beginOcclusionQuery(202);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup10, new Uint32Array(599), 43, 0);
} catch {}
let computePassEncoder45 = commandEncoder54.beginComputePass();
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder41.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup0);
} catch {}
try {
renderBundleEncoder4.insertDebugMarker('\u0606');
} catch {}
await gc();
try {
bindGroup3.label = '\u1b0a\uc242\udf7b\u5565\u9ceb\u06e0\uff6b';
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [{binding: 1, resource: externalTexture0}, {binding: 197, resource: sampler9}],
});
let commandEncoder55 = device0.createCommandEncoder({});
let texture50 = device0.createTexture({
  size: {width: 63, height: 1, depthOrArrayLayers: 11},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView53 = texture12.createView({});
let computePassEncoder46 = commandEncoder46.beginComputePass();
try {
computePassEncoder13.setBindGroup(0, bindGroup9);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer6, 12); };
} catch {}
try {
computePassEncoder35.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -20.71, g: -859.5, b: -162.9, a: -888.7, });
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer22, 'uint32', 8, 0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup12);
} catch {}
try {
buffer6.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData5,
  origin: { x: 0, y: 9 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 34, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder56 = device0.createCommandEncoder({});
let textureView54 = texture11.createView({});
let computePassEncoder47 = commandEncoder50.beginComputePass();
let sampler34 = device0.createSampler({addressModeV: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 83.63});
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup4, new Uint32Array(98), 52, 0);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 136 widthInBlocks: 34 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 840 */
  offset: 840,
  rowsPerImage: 100,
  buffer: buffer16,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {width: 34, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '2d-array' },
    },
  ],
});
let recycledExplicitBindGroupLayout3 = pipeline0.getBindGroupLayout(0);
let texture51 = device0.createTexture({
  size: {width: 63},
  sampleCount: 1,
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView55 = texture42.createView({});
let computePassEncoder48 = commandEncoder51.beginComputePass();
let externalTexture4 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder34.setBindGroup(0, bindGroup20);
} catch {}
try {
computePassEncoder16.setBindGroup(1, bindGroup13, new Uint32Array(2071), 20, 0);
} catch {}
try {
computePassEncoder33.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer9, 'uint32', 28, 6);
} catch {}
let pipeline1 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}});
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'bt470bg', transfer: 'smpte170m'} });
let bindGroup21 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [{binding: 197, resource: sampler29}, {binding: 1, resource: externalTexture0}],
});
let texture52 = device0.createTexture({
  size: [63],
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView56 = texture10.createView({aspect: 'depth-only', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 3});
try {
renderPassEncoder1.setBindGroup(2, bindGroup20, new Uint32Array(833), 99, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer16, 'uint32', 708, 2_448);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
commandEncoder56.copyTextureToBuffer({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 880 widthInBlocks: 110 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3000 */
  offset: 3000,
  buffer: buffer16,
}, {width: 110, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer32 = device0.createBuffer({size: 71, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let texture53 = device0.createTexture({
  size: [63, 1, 31],
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView57 = texture31.createView({baseArrayLayer: 23, arrayLayerCount: 4});
let renderBundle4 = renderBundleEncoder5.finish({});
try {
computePassEncoder2.setBindGroup(0, bindGroup2, new Uint32Array(527), 107, 0);
} catch {}
try {
computePassEncoder31.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer22, 'uint32', 0, 6);
} catch {}
try {
commandEncoder55.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 560 */
  offset: 560,
  bytesPerRow: 7424,
  buffer: buffer16,
}, {
  texture: texture51,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 2, y: 15, z: 1},
  aspect: 'all',
}, new Uint8Array(42_758).fill(140), /* required buffer size: 42_758 */
{offset: 81, bytesPerRow: 89, rowsPerImage: 28}, {width: 23, height: 4, depthOrArrayLayers: 18});
} catch {}
let commandEncoder57 = device0.createCommandEncoder({});
let texture54 = device0.createTexture({
  size: [64, 64, 12],
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView58 = texture10.createView({aspect: 'depth-only', format: 'depth16unorm', baseArrayLayer: 2, arrayLayerCount: 5});
let renderPassEncoder8 = commandEncoder56.beginRenderPass({colorAttachments: [{view: textureView22, loadOp: 'clear', storeOp: 'store'}]});
try {
computePassEncoder15.setBindGroup(1, bindGroup18);
} catch {}
try {
computePassEncoder33.setBindGroup(0, bindGroup20, new Uint32Array(317), 115, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer7, 'uint32', 4, 16);
} catch {}
try {
buffer10.unmap();
} catch {}
let commandEncoder58 = device0.createCommandEncoder({});
let textureView59 = texture17.createView({dimension: 'cube-array', format: 'r16sint', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 6});
try {
computePassEncoder13.setBindGroup(3, bindGroup14);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup5, new Uint32Array(112), 11, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(2, bindGroup11);
} catch {}
try {
buffer18.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
let texture55 = device0.createTexture({size: {width: 64}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView60 = texture15.createView({arrayLayerCount: 1});
try {
renderPassEncoder0.beginOcclusionQuery(194);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup4, new Uint32Array(206), 30, 0);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
computePassEncoder47.insertDebugMarker('\u{1fabf}');
} catch {}
let imageBitmap0 = await createImageBitmap(imageData1);
let commandEncoder59 = device0.createCommandEncoder({});
let texture56 = device0.createTexture({size: [63], sampleCount: 1, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder49 = commandEncoder59.beginComputePass();
try {
renderPassEncoder7.setIndexBuffer(buffer9, 'uint16', 18, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(2, bindGroup21);
} catch {}
try {
commandEncoder57.copyBufferToTexture({
  /* bytesInLastRow: 116 widthInBlocks: 29 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 4688 */
  offset: 4688,
  bytesPerRow: 9216,
  buffer: buffer16,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 29, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder55.insertDebugMarker('\ue88c');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 1, y: 1 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer33 = device0.createBuffer({size: 95, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder60 = device0.createCommandEncoder({});
let textureView61 = texture26.createView({dimension: '2d'});
let texture57 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 116},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder50 = commandEncoder57.beginComputePass();
let sampler35 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 80.17,
  maxAnisotropy: 5,
});
let externalTexture5 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder17.setBindGroup(1, bindGroup19, new Uint32Array(3257), 1_895, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer6, 4); };
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup4, []);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup1, new Uint32Array(1123), 227, 0);
} catch {}
let sampler36 = device0.createSampler({
  label: '\u0ae0\u0fec\u0af2\u{1f87e}\u0016\u0258\ubb56\u04e9\u{1f7fc}\u{1f8be}',
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMaxClamp: 91.33,
});
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer10, 36); };
} catch {}
try {
computePassEncoder47.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer22, 'uint32', 0, 1);
} catch {}
try {
commandEncoder52.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 600 widthInBlocks: 75 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 672 */
  offset: 672,
  bytesPerRow: 23296,
  buffer: buffer16,
}, {width: 75, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder60.copyTextureToTexture({
  texture: texture46,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture44,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 7},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder55.resolveQuerySet(querySet10, 19, 0, buffer27, 0);
} catch {}
try {
globalThis.someLabel = externalTexture4.label;
} catch {}
let bindGroup22 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 197, resource: sampler21}, {binding: 1, resource: externalTexture3}],
});
let commandEncoder61 = device0.createCommandEncoder({});
let textureView62 = texture14.createView({});
let texture58 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 55},
  mipLevelCount: 6,
  sampleCount: 1,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundle5 = renderBundleEncoder4.finish({});
try {
renderPassEncoder0.setBindGroup(0, bindGroup1, []);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle3, renderBundle5, renderBundle3, renderBundle3]);
} catch {}
try {
buffer20.unmap();
} catch {}
try {
commandEncoder61.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 6436 */
  offset: 6436,
  bytesPerRow: 40704,
  buffer: buffer16,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 61, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeBuffer(buffer26, 92, new DataView(new ArrayBuffer(65536)), 46168, 28);
} catch {}
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 246,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let texture59 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 1},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder34.dispatchWorkgroupsIndirect(buffer9, 12);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup0);
} catch {}
let imageBitmap1 = await createImageBitmap(imageData4);
let buffer34 = device0.createBuffer({size: 64, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder62 = device0.createCommandEncoder({});
let computePassEncoder51 = commandEncoder62.beginComputePass();
try {
computePassEncoder20.end();
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer28, 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer19, 48, new Int16Array(1050), 84, 0);
} catch {}
let pipeline2 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}});
let recycledExplicitBindGroupLayout4 = pipeline1.getBindGroupLayout(0);
let commandBuffer3 = commandEncoder52.finish();
let textureView63 = texture7.createView({});
let computePassEncoder52 = commandEncoder58.beginComputePass();
try {
renderPassEncoder1.setBindGroup(2, bindGroup13, new Uint32Array(488), 69, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(5, undefined, 847_186_719, 2_213_402_865);
} catch {}
try {
commandEncoder61.clearBuffer(buffer20);
} catch {}
let bindGroup23 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [{binding: 1, resource: externalTexture2}, {binding: 197, resource: sampler22}],
});
let textureView64 = texture49.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 6});
try {
renderPassEncoder4.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup13, new Uint32Array(249), 0, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle4, renderBundle1, renderBundle5, renderBundle4]);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer16, 'uint16', 912, 3_689);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer34, 0, 27);
} catch {}
try {
commandEncoder55.copyTextureToTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder63 = device0.createCommandEncoder({});
let texture60 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  mipLevelCount: 2,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture61 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder9 = commandEncoder13.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: -774.8, g: 252.6, b: -872.1, a: -994.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 408832764,
});
try {
computePassEncoder37.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer28, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout7]});
let textureView65 = texture60.createView({dimension: 'cube', mipLevelCount: 1});
let renderPassEncoder10 = commandEncoder60.beginRenderPass({
  colorAttachments: [{view: textureView22, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 411505657,
});
try {
computePassEncoder25.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer20, 'uint32', 64, 42);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
buffer28.unmap();
} catch {}
try {
commandEncoder55.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 64 */
  offset: 64,
  bytesPerRow: 4352,
  rowsPerImage: 118,
  buffer: buffer33,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder64 = device0.createCommandEncoder();
let texture62 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder53 = commandEncoder55.beginComputePass();
try {
computePassEncoder35.setBindGroup(0, bindGroup18);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup14, new Uint32Array(1311), 384, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer16, 868, 19_562);
} catch {}
let texture63 = device0.createTexture({
  size: {width: 127},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder48.setBindGroup(1, bindGroup0);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer6, 'uint16', 20, 3);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer28, 0, 0);
} catch {}
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 46 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7456 */
  offset: 7456,
  bytesPerRow: 34304,
  buffer: buffer16,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 23, height: 20, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder64.copyTextureToTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 4},
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{width: 42, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet10, 0, 0, buffer1, 0);
} catch {}
let buffer35 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView66 = texture63.createView({dimension: '1d'});
try {
computePassEncoder45.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(67), 1, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer28, 0, 0);
} catch {}
let videoFrame6 = new VideoFrame(imageBitmap1, {timestamp: 0});
try {
globalThis.someLabel = externalTexture5.label;
} catch {}
try {
textureView10.label = '\u035e\u0816\uf91f\u59da\u9d65\u723b\uec6b\u0e42';
} catch {}
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3]});
let commandEncoder65 = device0.createCommandEncoder({});
let textureView67 = texture62.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let texture64 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 51},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: [undefined], depthReadOnly: true, stencilReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer9, 0); };
} catch {}
try {
computePassEncoder42.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder7.setBlendConstant({ r: -75.24, g: 753.6, b: -809.9, a: 917.4, });
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer34, 'uint32', 0, 18);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer16, 4_884, 7_356);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(0, buffer17, 0, 16);
} catch {}
let texture65 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 1},
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder46.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup22);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer22, 'uint16', 4, 2);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(4, buffer2, 0, 26);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(1, buffer6, 0);
} catch {}
let buffer36 = device0.createBuffer({
  size: 128,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture66 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView68 = texture27.createView({});
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup9, new Uint32Array(123), 2, 0);
} catch {}
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 644 */
  offset: 644,
  bytesPerRow: 19712,
  buffer: buffer16,
}, {
  texture: texture54,
  mipLevel: 1,
  origin: {x: 1, y: 7, z: 2},
  aspect: 'all',
}, {width: 1, height: 9, depthOrArrayLayers: 0});
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

enable f16;

requires pointer_composite_access;

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

var<private> vp17: array<array<vec2<bool>, 1>, 17> = array<array<vec2<bool>, 1>, 17>();

struct T8 {
  f0: vec2h,
  @size(36) f1: array<array<atomic<i32>, 1>>,
}

var<private> vp33 = frexp(vec2f(0.05625, 0.4813e-7));

var<private> vp37 = modf(vec2f(0.06494e-27, 0.07071e-31));

var<private> vp29: vec2i = vec2i(387454798, 283823019);

var<private> vp14: array<vec4f, 1> = array(vec4f(0.2035, 0.1109e35, 0.03554, 0.2245));

var<private> vp21: FragmentOutput4 = FragmentOutput4(vec4i(366860960, 94284271, 700625128, 375562295));

var<private> vp35: T6 = T6();

override override22: u32 = 17553473;

var<private> vp13: vec4f = vec4f(0.02955, 0.03248e-34, 0.01409e-11, -0.7599);

var<private> vp31 = array(modf(f16(-11235.7)));

var<private> vp7: FragmentOutput4 = FragmentOutput4();

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

var<private> vp23: vec4u = vec4u(725382958, 181979112, 185197400, 238017781);

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

var<private> vp32: array<vec2f, 1> = array<vec2f, 1>();

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

var<private> vp11 = frexp(vec2h(9058.9, 6249.1));

struct T1 {
  f0: array<u32, 64>,
  @size(256) f1: vec2<bool>,
  @size(256) f2: u32,
}

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

var<private> vp12: f16 = f16(31323.2);

var<private> vp22: array<FragmentOutput4, 1> = array<FragmentOutput4, 1>();

var<private> vp39 = modf(vec4f(0.07430, 0.5267, -0.1221e-39, 0.07838));

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

var<private> vp24: FragmentOutput4 = FragmentOutput4(vec4i(395165851, 150742731, 35155653, 37874337));

var<private> vp1: array<T6, 1> = array<T6, 1>();

var<private> vp2: mat4x2f = mat4x2f(0.02043, 0.2206, -0.1113, 0.1897e-6, 0.05762e3, 0.2038e4, 0.1290, 0.01949);

var<private> vp36: T6 = T6();

var<private> vp25 = array(frexp(vec2h(52589.0, 24153.2)));

var<private> vp18: FragmentOutput4 = FragmentOutput4();

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

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

@id(65026) override override21: u32 = 34471975;

var<private> vp8 = modf(f16(23692.4));

var<private> vp19 = array(modf(f16(36960.2)));

var<private> vp34: FragmentOutput4 = FragmentOutput4();

var<private> vp16: FragmentOutput4 = FragmentOutput4();

/* used global variables: buffer37, buffer38 */
fn fn1() -> FragmentOutput4 {
  var out: FragmentOutput4;
  fn0(array<array<vec4u, 1>, 1>(array<vec4u, 1>(vec4u(bitcast<u32>(vp30.f0[0][0])))));
  while bool((*&buffer37)[unconst_u32(1058845503)][9][0][unconst_u32(410363101)][0][0][6]) {
  let ptr11: ptr<private, vec4f> = &vp39.whole;
  let ptr12: ptr<storage, array<f16, 7>, read_write> = &buffer37[unconst_u32(1539024250)][unconst_u32(132688087)][unconst_u32(102920381)][unconst_u32(592390184)][0][unconst_u32(1094255786)];
  if bool((*&buffer37)[arrayLength(&(*&buffer37))][9][unconst_u32(68874356)][unconst_u32(768398511)][unconst_u32(476377079)][unconst_u32(64253590)][unconst_u32(260941668)]) {
  var vf51 = fn0(array<array<vec4u, 1>, 1>(array<vec4u, 1>(unpack4xU8(u32(buffer37[arrayLength(&buffer37)][9][unconst_u32(280970114)][0][unconst_u32(278028231)][unconst_u32(2041376878)][6])))));
  _ = buffer37;
}
  let ptr13: ptr<storage, array<f16, 7>, read_write> = &(*&buffer37)[unconst_u32(509781996)][9][0][0][unconst_u32(40560570)][unconst_u32(1683411979)];
  var vf52 = fn0(array<array<vec4u, 1>, 1>(array<vec4u, 1>(unpack4xU8(u32(buffer37[arrayLength(&buffer37)][9][0][unconst_u32(626987204)][0][unconst_u32(1727158392)][unconst_u32(1049223449)])))));
  vp38.f0[unconst_u32(226450553)][0] |= i32((*&buffer37)[unconst_u32(187303130)][unconst_u32(423513379)][0][unconst_u32(242366975)][unconst_u32(746679904)][0][unconst_u32(2364869497)]);
  return out;
  _ = buffer37;
}
  while bool((*&buffer37)[arrayLength(&(*&buffer37))][unconst_u32(203196835)][unconst_u32(11485107)][0][unconst_u32(1321431194)][0][unconst_u32(1313828128)]) {
  let ptr14: ptr<private, array<i32, 1>> = &vp38.f0[unconst_u32(97740031)];
  fn0(array<array<vec4u, 1>, 1>(array<vec4u, 1>(vec4u(u32(buffer37[unconst_u32(106065319)][unconst_u32(407121515)][0][u32((*&buffer37)[arrayLength(&(*&buffer37))][unconst_u32(1109482962)][unconst_u32(111474714)][unconst_u32(797260436)][unconst_u32(1126678789)][unconst_u32(304372376)][6])][0][0][6])))));
  return out;
  _ = buffer37;
}
  var vf53 = fn0(array<array<vec4u, 1>, 1>(array<vec4u, 1>(unpack4xU8(u32(buffer37[unconst_u32(1577822237)][unconst_u32(29793724)][0][0][unconst_u32(29228221)][unconst_u32(194801819)][6])))));
  var vf54 = fn0(array<array<vec4u, 1>, 1>(array<vec4u, 1>(unpack4xU8(bitcast<u32>(vp35.f0[0][0])))));
  var vf55: f32 = buffer38[unconst_u32(6198300)][u32(buffer37[arrayLength(&buffer37)][unconst_u32(151568324)][0][0][unconst_u32(257172677)][0][6])];
  return out;
  _ = buffer37;
  _ = buffer38;
}

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

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

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

@group(0) @binding(3) var<uniform> buffer38: array<vec4f, 13>;

var<private> vp38: T6 = T6(array(array(i32(714704777))));

var<private> vp28: vec2i = vec2i(572908765, 85461516);

struct T3 {
  @align(16) @size(208) f0: array<atomic<i32>>,
}

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

struct T6 {
  @size(40) f0: array<array<i32, 1>, 1>,
}

var<private> vp10 = frexp(vec2f(0.05183e-2, 0.00174e10));

var<private> vp3: array<array<f32, 1>, 56> = array<array<f32, 1>, 56>();

var<private> vp27: FragmentOutput4 = FragmentOutput4(vec4i(367304837, 398787255, 260417354, 1005668026));

var<private> vp41: array<FragmentOutput4, 1> = array<FragmentOutput4, 1>(FragmentOutput4(vec4i(1589604984, -143146179, 316545880, 81328006)));

var<private> vp5: FragmentOutput4 = FragmentOutput4(vec4i(-33672566, 134771056, 313901912, 86709032));

var<private> vp42: FragmentOutput4 = FragmentOutput4();

var<private> vp4: u32 = u32(281077530);

alias vec3b = vec3<bool>;

var<private> vp30: T6 = T6(array(array<i32, 1>()));

struct T7 {
  f0: T0,
}

var<private> vp20: mat4x2h = mat4x2h(20446.7, 11002.1, 1513.6, 14089.6, 1892.0, 5724.9, 23526.7, 7194.7);

var<private> vp26 = array(frexp(vec3h(4831.2, 41697.5, 1769.9)), frexp(vec3h(2966.1, 4042.1, 9404.4)), frexp(vec3h(13764.9, 24823.4, 22728.5)), frexp(vec3h(10160.3, 1170.6, 4496.1)));

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

var<private> vp43: FragmentOutput4 = FragmentOutput4(vec4i(269157061, 4932737, 92205487, 94926427));

/* zero global variables used */
fn fn0(a0: array<array<vec4u, 1>, 1>) -> vec4u {
  var out: vec4u;
  let ptr9: ptr<private, vec4i> = &vp41[unconst_u32(958089923)].f0;
  let ptr10: ptr<private, i32> = &vp9.f0[bitcast<vec4u>(vp41[unconst_u32(264560157)].f0).a][unconst_u32(1018743464)];
  return out;
}

var<private> vp40: vec2f = vec2f(0.1797e28, 0.00965);

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

struct T2 {
  @align(8) @size(208) f0: array<array<array<array<array<vec2h, 1>, 1>, 1>, 6>>,
}

/* zero global variables used */
@vertex
fn vertex4() -> @builtin(position) vec4f {
  var out: vec4f;
  loop {
  vp25[unconst_u32(385986205)].fract = bitcast<vec2h>(vp34.f0[unconst_u32(281149007)]);
  vp22[unconst_u32(1557236818)] = FragmentOutput4(bitcast<vec4i>(vp37.fract.yyxy));
  vp23 &= unpack4xU8(bitcast<u32>(vp15.f0[bitcast<u32>(vp0.f0[0][0])][unconst_u32(546329207)]));
  let ptr15: ptr<private, vec2<bool>> = &vp17[16][unconst_u32(991879801)];
  let ptr16: ptr<private, vec2i> = &vp11.exp;
  if bool(vp36.f0[0][unconst_u32(772586040)]) {
  let ptr17: ptr<private, i32> = &vp15.f0[0][unconst_u32(743459536)];
  var vf56: vec2f = sqrt(vec2f(unconst_f32(0.1177e-35), unconst_f32(0.1168e-44)));
  vp34.f0 |= vec4i(i32(vp19[0].whole));
  break;
}
  break;
}
  let ptr18: ptr<private, i32> = &vp36.f0[0][0];
  let ptr19: ptr<private, array<vec2<bool>, 1>> = &vp17[16];
  out -= bitcast<vec4f>(vp27.f0.xzxz);
  let ptr20: ptr<private, f16> = &vp19[0].fract;
  return out;
}

/* used global variables: buffer37 */
@fragment
fn fragment4(@location(14) a0: vec2f) -> FragmentOutput4 {
  var out: FragmentOutput4;
  vp28 |= vec2i(i32(buffer37[arrayLength(&buffer37)][9][unconst_u32(455620365)][unconst_u32(2457182638)][0][0][6]));
  loop {
  vp1[unconst_u32(540065116)].f0[unconst_u32(578411893)][unconst_u32(723521173)] += i32((*&buffer37)[unconst_u32(472338103)][9][unconst_u32(1154973828)][0][u32(vp1[0].f0[unconst_u32(58639196)][unconst_u32(70384808)])][0][6]);
  break;
  _ = buffer37;
}
  let ptr21: ptr<storage, array<array<array<f16, 7>, 1>, 1>, read_write> = &buffer37[arrayLength(&buffer37)][9][0][unconst_u32(861310050)];
  vp3[unconst_u32(17048546)][unconst_u32(740450592)] = f32(buffer37[arrayLength(&buffer37)][9][unconst_u32(829550268)][unconst_u32(557548094)][unconst_u32(1316605745)][0][6]);
  let ptr22: ptr<storage, array<f16, 7>, read_write> = &buffer37[arrayLength(&buffer37)][9][0][unconst_u32(969177015)][0][0];
  return out;
  _ = buffer37;
}

/* zero global variables used */
@compute @workgroup_size(4, 2, 1)
fn compute6() {
  var vf57 = fn0(array<array<vec4u, 1>, 1>(array<vec4u, 1>(unpack4xU8(u32(vp36.f0[0][0])))));
  if bool(vp35.f0[0][0]) {
  vp34.f0 -= vec4i(bitcast<i32>(vp3[55][0]));
  let ptr23: ptr<private, vec4i> = &vp24.f0;
  let ptr24: ptr<private, array<array<f32, 1>, 56>> = &vp3;
  vp1[0].f0[unconst_u32(574368946)][unconst_u32(28212648)] = vp22[vec2u(vp10.exp).r].f0.y;
  vp22[unconst_u32(1055549839)].f0 |= vec4i(vp9.f0[unconst_u32(247808946)][unconst_u32(1154431076)]);
  let ptr25: ptr<private, i32> = &vp35.f0[0][0];
}
  var vf58 = fn0(array<array<vec4u, 1>, 1>(array<vec4u, 1>(vec4u(bitcast<u32>(vp1[unconst_u32(28782346)].f0[0][0])))));
  vp13 *= vec4f(bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.1543e-12), unconst_f32(0.2512)))));
  vp26[unconst_u32(317035700)] = frexp(degrees(vec3h(unconst_f16(12420.8), unconst_f16(7342.0), unconst_f16(13884.9))));
  vp5.f0 *= vec4i(i32(vp31[0].fract));
}`,
});
let commandEncoder66 = device0.createCommandEncoder({});
let texture67 = device0.createTexture({
  size: [255, 1, 1],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView69 = texture14.createView({mipLevelCount: 1, baseArrayLayer: 0});
let renderPassEncoder11 = commandEncoder64.beginRenderPass({
  colorAttachments: [{
  view: textureView39,
  depthSlice: 6,
  clearValue: { r: -752.8, g: 551.3, b: -457.5, a: 958.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder7.setBindGroup(3, bindGroup6);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder1.setScissorRect(0, 9, 8, 2);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(6, buffer17);
} catch {}
let arrayBuffer0 = buffer4.getMappedRange(0, 0);
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 60 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3742 */
  offset: 3742,
  buffer: buffer16,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 56, y: 0, z: 0},
  aspect: 'all',
}, {width: 60, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let querySet11 = device0.createQuerySet({type: 'occlusion', count: 668});
let texture68 = device0.createTexture({
  size: [127, 1, 1],
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder54 = commandEncoder61.beginComputePass();
let sampler37 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 88.76,
});
try {
computePassEncoder9.setBindGroup(0, bindGroup15);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup15, new Uint32Array(637), 197, 0);
} catch {}
let commandEncoder68 = device0.createCommandEncoder({});
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 82});
let sampler38 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  lodMaxClamp: 71.07,
  compare: 'greater',
  maxAnisotropy: 1,
});
try {
computePassEncoder8.setBindGroup(2, bindGroup6);
} catch {}
try {
computePassEncoder22.setBindGroup(3, bindGroup1, new Uint32Array(3388), 506, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup21, new Uint32Array(122), 30, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer22, 'uint32', 4, 1);
} catch {}
try {
renderBundleEncoder6.setBindGroup(3, bindGroup8);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer23, 'uint16', 0, 41);
} catch {}
let commandEncoder69 = device0.createCommandEncoder({});
let texture69 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView70 = texture42.createView({arrayLayerCount: 1});
let computePassEncoder55 = commandEncoder66.beginComputePass();
let renderPassEncoder12 = commandEncoder68.beginRenderPass({
  colorAttachments: [{
  view: textureView39,
  depthSlice: 34,
  clearValue: { r: 105.3, g: -921.3, b: 125.3, a: -704.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 189081434,
});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
renderPassEncoder1.setIndexBuffer(buffer6, 'uint16', 0, 6);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(3, buffer13);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup2);
} catch {}
try {
commandEncoder69.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7672 */
  offset: 7672,
  buffer: buffer16,
}, {
  texture: texture68,
  mipLevel: 2,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder67.resolveQuerySet(querySet11, 189, 0, buffer28, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer19, 12, new Int16Array(8263), 155, 32);
} catch {}
let recycledExplicitBindGroupLayout5 = pipeline0.getBindGroupLayout(0);
let bindGroup24 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 1, resource: textureView0}]});
let computePassEncoder56 = commandEncoder69.beginComputePass();
try {
computePassEncoder52.setBindGroup(0, bindGroup10);
} catch {}
try {
computePassEncoder28.setBindGroup(3, bindGroup13, new Uint32Array(220), 34, 0);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup12, new Uint32Array(926), 214, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(6, buffer16, 0, 5_540);
} catch {}
try {
commandEncoder67.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1004 */
  offset: 1004,
  rowsPerImage: 235,
  buffer: buffer16,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup25 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 1, resource: textureView6}]});
let commandEncoder70 = device0.createCommandEncoder({});
let textureView71 = texture63.createView({});
let texture70 = device0.createTexture({size: [64, 64, 12], format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder57 = commandEncoder65.beginComputePass();
let renderPassEncoder13 = commandEncoder67.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: -6.683, g: 776.6, b: 349.5, a: 9.711, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet7,
});
let renderBundle6 = renderBundleEncoder6.finish({});
try {
renderBundleEncoder7.setBindGroup(0, bindGroup25, new Uint32Array(1392), 821, 0);
} catch {}
try {
commandEncoder63.copyTextureToTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture69,
  mipLevel: 1,
  origin: {x: 1, y: 3, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture71 = device0.createTexture({
  size: [64, 64, 12],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView72 = texture2.createView({});
let computePassEncoder58 = commandEncoder63.beginComputePass();
try {
computePassEncoder7.setBindGroup(1, bindGroup17);
} catch {}
try {
computePassEncoder43.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup6, new Uint32Array(292), 0, 0);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup3, new Uint32Array(1112), 148, 0);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(4, buffer36, 4);
} catch {}
let buffer40 = device0.createBuffer({size: 144, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let texture72 = device0.createTexture({
  size: {width: 63},
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder59 = commandEncoder70.beginComputePass();
let renderBundle7 = renderBundleEncoder7.finish({});
let sampler39 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  lodMaxClamp: 95.51,
});
try {
computePassEncoder27.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer20, 'uint32', 4, 76);
} catch {}
try {
buffer16.unmap();
} catch {}
let textureView73 = texture65.createView({arrayLayerCount: 1});
try {
renderPassEncoder4.setVertexBuffer(4, buffer16, 1_900, 1_452);
} catch {}
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpte240m', transfer: 'hlg'} });
let commandEncoder71 = device0.createCommandEncoder();
let texture73 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 3},
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder60 = commandEncoder71.beginComputePass();
let sampler40 = device0.createSampler({label: '\u498e\u{1fda8}\u00e9\u{1fcd3}\u219f\u{1ff39}\u0424\ubfa3\uc1fa', addressModeW: 'repeat'});
try {
computePassEncoder49.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle7]);
} catch {}
let buffer41 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder72 = device0.createCommandEncoder({});
let texture74 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView74 = texture7.createView({});
let computePassEncoder61 = commandEncoder72.beginComputePass();
try {
computePassEncoder42.setBindGroup(2, bindGroup13);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup21, new Uint32Array(336), 43, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer20, 'uint32', 8, 142);
} catch {}
try {
computePassEncoder46.insertDebugMarker('\u0abb');
} catch {}
let pipeline3 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3}});
let buffer42 = device0.createBuffer({label: '\u{1fe69}\u0e43', size: 512, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let texture75 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 876},
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder22.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup24);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup17, new Uint32Array(2352), 305, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle7]);
} catch {}
let arrayBuffer1 = buffer4.getMappedRange(8, 0);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup26 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 152, resource: textureView34}]});
let commandEncoder73 = device0.createCommandEncoder({});
let textureView75 = texture64.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 14, arrayLayerCount: 24});
try {
computePassEncoder58.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder13.beginOcclusionQuery(205);
} catch {}
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
commandEncoder73.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2474 */
  offset: 2474,
  buffer: buffer16,
}, {
  texture: texture19,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {width: 28, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder73.resolveQuerySet(querySet10, 2, 2, buffer1, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(448).fill(35), /* required buffer size: 448 */
{offset: 448}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(30); };
} catch {}
let bindGroup27 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [{binding: 246, resource: {buffer: buffer21}}, {binding: 0, resource: {buffer: buffer21, size: 64}}],
});
let computePassEncoder62 = commandEncoder73.beginComputePass();
let sampler41 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 51.64,
  compare: 'always',
  maxAnisotropy: 14,
});
let externalTexture6 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder50.setBindGroup(0, bindGroup10);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer23, 44); };
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer16, 'uint32', 1_164, 12_070);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup28 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [{binding: 0, resource: {buffer: buffer1}}, {binding: 246, resource: {buffer: buffer8}}],
});
let buffer43 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder74 = device0.createCommandEncoder();
let renderPassEncoder14 = commandEncoder74.beginRenderPass({
  colorAttachments: [{
  view: textureView39,
  depthSlice: 24,
  clearValue: { r: -921.2, g: 499.0, b: -841.7, a: 11.17, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 135894,
});
try {
computePassEncoder47.setBindGroup(0, bindGroup0, []);
} catch {}
try {
computePassEncoder26.setBindGroup(1, bindGroup16, new Uint32Array(337), 0, 0);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle7, renderBundle1]);
} catch {}
try {
device0.queue.writeBuffer(buffer19, 16, new Uint32Array(5288).fill(8_600), 407, 0);
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout0]});
let textureView76 = texture34.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder35.setBindGroup(3, bindGroup5, new Uint32Array(833), 132, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup26, new Uint32Array(2516), 513, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(9_604).fill(214), /* required buffer size: 9_604 */
{offset: 100, bytesPerRow: 44, rowsPerImage: 24}, {width: 6, height: 0, depthOrArrayLayers: 10});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture76 = device0.createTexture({
  size: [64, 64, 12],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler42 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', magFilter: 'nearest'});
try {
computePassEncoder39.setBindGroup(0, bindGroup23);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer1, 20); };
} catch {}
try {
computePassEncoder28.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup10, new Uint32Array(2369), 51, 0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer6, 4, 0);
} catch {}
try {
globalThis.someLabel = externalTexture2.label;
} catch {}
let buffer44 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let textureView77 = texture47.createView({format: 'r16sint'});
let sampler43 = device0.createSampler({
  label: '\u{1f6e5}\u{1f612}\u61fd\u0eea\u05aa\u0bbd\u2265\u{1fc67}\u04c1\u09cd',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 28.21,
  maxAnisotropy: 4,
});
try {
computePassEncoder50.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup22, new Uint32Array(2522), 351, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(1, buffer2, 0, 20);
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(27, 85);
let buffer45 = device0.createBuffer({size: 64, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let textureView78 = texture60.createView({dimension: 'cube', aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
let texture77 = device0.createTexture({
  size: [510, 1, 11],
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder9.setVertexBuffer(6, buffer17, 0, 4);
} catch {}
let bindGroup29 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 1, resource: textureView0}]});
let commandEncoder75 = device0.createCommandEncoder({});
let computePassEncoder63 = commandEncoder75.beginComputePass();
let promise10 = device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule2, entryPoint: 'compute4', constants: {}}});
let commandEncoder76 = device0.createCommandEncoder({});
let sampler44 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  lodMaxClamp: 84.43,
  compare: 'greater-equal',
});
try {
computePassEncoder43.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder54.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup3, new Uint32Array(2056), 1_474, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer22, 'uint32', 4, 24);
} catch {}
try {
commandEncoder76.resolveQuerySet(querySet5, 13, 8, buffer13, 0);
} catch {}
offscreenCanvas0.height = 401;
let texture78 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder15 = commandEncoder76.beginRenderPass({
  colorAttachments: [{view: textureView22, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 303113479,
});
let sampler45 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  lodMaxClamp: 81.91,
});
try {
computePassEncoder51.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer34, 'uint32', 0, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer22, 0, new Uint32Array(5203), 2, 0);
} catch {}
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'gamma28curve'} });
let bindGroup30 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 197, resource: sampler5}, {binding: 1, resource: externalTexture6}],
});
let textureView79 = texture75.createView({arrayLayerCount: 1});
try {
renderPassEncoder9.setBindGroup(0, bindGroup2, []);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup3, new Uint32Array(861), 34, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(47);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer17, 20, 9);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let autogeneratedBindGroupLayout0 = pipeline3.getBindGroupLayout(0);
let querySet13 = device0.createQuerySet({label: '\u{1f9a1}\u7be1\u080a\ub712\u3a1b', type: 'occlusion', count: 193});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: [undefined], depthReadOnly: true, stencilReadOnly: false});
try {
computePassEncoder15.setBindGroup(0, bindGroup12, new Uint32Array(1894), 152, 0);
} catch {}
try {
computePassEncoder39.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder52.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup26);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(1, buffer36, 0, 5);
} catch {}
let bindGroup31 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 152, resource: textureView24}]});
let querySet14 = device0.createQuerySet({type: 'occlusion', count: 532});
let renderBundle8 = renderBundleEncoder8.finish({});
try {
computePassEncoder40.setBindGroup(3, bindGroup17, new Uint32Array(45), 19, 0);
} catch {}
try {
computePassEncoder40.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup19, []);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer36, 'uint32', 36, 11);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(4, buffer40, 0, 5);
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
let texture79 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 72},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder16 = commandEncoder77.beginRenderPass({
  colorAttachments: [{
  view: textureView79,
  depthSlice: 754,
  clearValue: { r: -618.8, g: -116.9, b: -65.68, a: 431.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler46 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 65.37,
});
try {
computePassEncoder27.setBindGroup(3, bindGroup14, []);
} catch {}
try {
computePassEncoder53.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup20, new Uint32Array(616), 48, 0);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
let pipeline4 = device0.createRenderPipeline({
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule1,
  constants: {override7: 1},
  targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}],
},
  vertex: {module: shaderModule4, buffers: []},
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
let commandEncoder78 = device0.createCommandEncoder({});
let computePassEncoder64 = commandEncoder78.beginComputePass();
try {
computePassEncoder57.setBindGroup(1, bindGroup9);
} catch {}
try {
computePassEncoder39.setBindGroup(3, bindGroup17, new Uint32Array(873), 268, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(2, 1, 2); };
} catch {}
try {
computePassEncoder14.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup1, []);
} catch {}
try {
renderPassEncoder1.setViewport(50.707982446796265, 34.10509844274955, 2.9452784600811124, 20.024085115501975, 0.21031856915978353, 0.6190529236737831);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer6, 'uint16', 4, 6);
} catch {}
try {
buffer24.unmap();
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u{1fe05}');
} catch {}
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
let commandEncoder79 = device0.createCommandEncoder({});
let computePassEncoder65 = commandEncoder79.beginComputePass();
try {
computePassEncoder44.setBindGroup(0, bindGroup2);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer23, 20); };
} catch {}
try {
computePassEncoder65.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(2, buffer13);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 0,
  origin: {x: 35, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(189).fill(59), /* required buffer size: 189 */
{offset: 189}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView80 = texture65.createView({dimension: '2d-array'});
try {
computePassEncoder27.setBindGroup(1, bindGroup28, new Uint32Array(374), 24, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle7, renderBundle4, renderBundle5]);
} catch {}
let bindGroup32 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture6}, {binding: 197, resource: sampler3}],
});
try {
computePassEncoder11.setBindGroup(2, bindGroup27);
} catch {}
try {
computePassEncoder53.setBindGroup(0, bindGroup1, new Uint32Array(3560), 400, 0);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline4);
} catch {}
let imageData6 = new ImageData(120, 20);
let texture80 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 24},
  dimension: '2d',
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder64.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup18, new Uint32Array(1494), 17, 0);
} catch {}
let imageData7 = new ImageData(56, 16);
let texture81 = device0.createTexture({
  size: [255, 1, 95],
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder55.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(13);
} catch {}
try {
buffer13.unmap();
} catch {}
let bindGroup33 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 1, resource: textureView3}]});
let commandEncoder80 = device0.createCommandEncoder({});
let texture82 = device0.createTexture({
  size: [255, 1, 1],
  mipLevelCount: 1,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgba8sint'],
});
let renderPassEncoder17 = commandEncoder80.beginRenderPass({colorAttachments: [{view: textureView39, depthSlice: 21, loadOp: 'clear', storeOp: 'store'}]});
let sampler47 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 1.021,
  compare: 'never',
});
try {
computePassEncoder25.setBindGroup(1, bindGroup18, new Uint32Array(4980), 753, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup17, new Uint32Array(3246), 3_003, 0);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setViewport(38.1777093885329, 4.239584616383894, 22.489473980267363, 11.095796698381967, 0.29097378588135425, 0.32400257687730105);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer36);
} catch {}
try {
adapter0.label = '\u{1f68f}\u06c4\ua088\ud77b\u{1ff12}';
} catch {}
let bindGroup34 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView1}]});
let buffer46 = device0.createBuffer({size: 280, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder81 = device0.createCommandEncoder({});
let textureView81 = texture75.createView({arrayLayerCount: 1});
let computePassEncoder66 = commandEncoder81.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer10, 76); };
} catch {}
try {
computePassEncoder62.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup19);
} catch {}
let bindGroup35 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [{binding: 1, resource: externalTexture1}, {binding: 197, resource: sampler33}],
});
let textureView82 = texture54.createView({mipLevelCount: 1, arrayLayerCount: 4});
try {
computePassEncoder41.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup16, new Uint32Array(4455), 1_057, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder15.setViewport(18.95833949884465, 50.04923306957472, 8.25777835951583, 5.420402162189128, 0.5222300945721311, 0.9259607674759722);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
try {
globalThis.someLabel = bindGroup21.label;
} catch {}
let recycledExplicitBindGroupLayout6 = pipeline1.getBindGroupLayout(1);
let bindGroup36 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 1, resource: textureView0}]});
let commandEncoder82 = device0.createCommandEncoder({});
let textureView83 = texture37.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let sampler48 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 71.09,
});
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer6, 8); };
} catch {}
try {
computePassEncoder56.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder13.beginOcclusionQuery(860);
} catch {}
let buffer47 = device0.createBuffer({size: 580, usage: GPUBufferUsage.UNIFORM});
let commandEncoder83 = device0.createCommandEncoder();
let textureView84 = texture63.createView({});
try {
computePassEncoder34.setBindGroup(0, bindGroup35, new Uint32Array(1795), 929, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup20, new Uint32Array(575), 15, 0);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(6, buffer13, 0, 118);
} catch {}
try {
buffer46.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
await gc();
let offscreenCanvas1 = new OffscreenCanvas(24, 63);
let textureView85 = texture77.createView({arrayLayerCount: 4});
let computePassEncoder67 = commandEncoder82.beginComputePass();
let renderPassEncoder18 = commandEncoder83.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  clearValue: { r: 26.50, g: 608.1, b: -958.3, a: 998.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet8,
});
try {
computePassEncoder14.setBindGroup(2, bindGroup20, new Uint32Array(3047), 315, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup15, new Uint32Array(251), 9, 0);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle5, renderBundle3]);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(7, buffer46);
} catch {}
let offscreenCanvas2 = new OffscreenCanvas(45, 167);
let commandEncoder84 = device0.createCommandEncoder();
let querySet15 = device0.createQuerySet({type: 'occlusion', count: 1616});
let renderPassEncoder19 = commandEncoder84.beginRenderPass({
  colorAttachments: [{
  view: textureView79,
  depthSlice: 433,
  clearValue: { r: -205.3, g: -582.4, b: 922.4, a: -557.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder34.setBindGroup(0, bindGroup9);
} catch {}
try {
computePassEncoder33.end();
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup14, new Uint32Array(2553), 194, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer9, 'uint16', 14, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder57.pushDebugGroup('\u0756');
} catch {}
let gpuCanvasContext1 = offscreenCanvas1.getContext('webgpu');
let buffer48 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_DST});
try {
computePassEncoder18.setBindGroup(3, bindGroup16);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup18, new Uint32Array(148), 6, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 45, y: 3 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter2.label = '\u{1f86c}\u{1f8d8}';
} catch {}
let commandEncoder85 = device0.createCommandEncoder({});
let computePassEncoder68 = commandEncoder85.beginComputePass();
try {
computePassEncoder22.setBindGroup(3, bindGroup5, new Uint32Array(320), 57, 0);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer46, 68, 2);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer19, 4, new Uint32Array(18187), 6698, 16);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipelineLayout9 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout7, veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout0],
});
let buffer49 = device0.createBuffer({size: 322, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let textureView86 = texture76.createView({dimension: 'cube', format: 'rg8sint', mipLevelCount: 1});
let texture83 = device0.createTexture({
  size: [64, 64, 555],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView87 = texture54.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
try {
computePassEncoder44.setBindGroup(1, bindGroup19, new Uint32Array(151), 79, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer44, 56); };
} catch {}
try {
computePassEncoder66.setPipeline(pipeline2);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
commandEncoder56.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2544 */
  offset: 2544,
  bytesPerRow: 9984,
  buffer: buffer16,
}, {
  texture: texture37,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 1,
  origin: {x: 5, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(130).fill(23), /* required buffer size: 130 */
{offset: 130, bytesPerRow: 40}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte240m', transfer: 'bt1361ExtendedColourGamut'} });
let buffer50 = device0.createBuffer({size: 248, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let texture84 = device0.createTexture({
  size: [255, 1, 1],
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler49 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 91.22});
try {
computePassEncoder58.setBindGroup(3, bindGroup14);
} catch {}
try {
computePassEncoder39.setBindGroup(0, bindGroup7, new Uint32Array(3343), 665, 0);
} catch {}
try {
computePassEncoder57.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle4]);
} catch {}
try {
commandEncoder35.copyBufferToBuffer(buffer21, 20, buffer36, 4, 0);
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'film', transfer: 'gamma22curve'} });
let commandBuffer4 = commandEncoder35.finish();
let texture85 = device0.createTexture({
  size: [64, 64, 12],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder69 = commandEncoder56.beginComputePass();
try {
computePassEncoder28.setBindGroup(1, bindGroup11);
} catch {}
try {
computePassEncoder38.setBindGroup(1, bindGroup5, new Uint32Array(816), 155, 0);
} catch {}
try {
computePassEncoder68.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer23, 'uint32', 32, 8);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d-array' },
    },
  ],
});
let commandEncoder86 = device0.createCommandEncoder({});
let textureView88 = texture85.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 1});
let texture86 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 251},
  mipLevelCount: 2,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder70 = commandEncoder86.beginComputePass();
let sampler50 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.11,
  compare: 'equal',
  maxAnisotropy: 6,
});
try {
computePassEncoder31.setBindGroup(0, bindGroup17, new Uint32Array(95), 6, 0);
} catch {}
try {
computePassEncoder59.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(708);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer16, 'uint16', 396, 871);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(1, buffer5, 0, 9);
} catch {}
try {
computePassEncoder57.popDebugGroup();
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let buffer51 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder87 = device0.createCommandEncoder({});
let texture87 = device0.createTexture({
  size: {width: 63, height: 1, depthOrArrayLayers: 46},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder6.setBindGroup(3, bindGroup34, new Uint32Array(697), 32, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer16, 0, 8_654);
} catch {}
try {
commandEncoder87.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2248 */
  offset: 2248,
  rowsPerImage: 1078,
  buffer: buffer16,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder87.copyTextureToBuffer({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2216 */
  offset: 2216,
  buffer: buffer16,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView89 = texture87.createView({mipLevelCount: 1, arrayLayerCount: 1});
let texture88 = device0.createTexture({
  size: [510, 1, 15],
  mipLevelCount: 1,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder56.setBindGroup(0, bindGroup25);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup5, []);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup21, new Uint32Array(1512), 94, 0);
} catch {}
try {
renderPassEncoder18.setViewport(34.531047518891654, 39.33957530412783, 15.693359511227424, 6.6910743702639905, 0.7786316578140439, 0.9362240831525185);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer23, 'uint16', 54, 10);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(123).fill(207), /* required buffer size: 123 */
{offset: 123, rowsPerImage: 39}, {width: 28, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let querySet16 = device0.createQuerySet({type: 'occlusion', count: 1056});
let sampler51 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 3,
});
try {
computePassEncoder7.setBindGroup(0, bindGroup33, new Uint32Array(4323), 1_135, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder70.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup25);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer3, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer50, 32, new Uint32Array(556), 131, 4);
} catch {}
let buffer52 = device0.createBuffer({
  size: 0,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder88 = device0.createCommandEncoder({});
let renderPassEncoder20 = commandEncoder87.beginRenderPass({
  colorAttachments: [{
  view: textureView79,
  depthSlice: 793,
  clearValue: { r: 147.8, g: 680.1, b: -744.8, a: 925.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let externalTexture7 = device0.importExternalTexture({source: videoFrame10, colorSpace: 'srgb'});
try {
computePassEncoder35.setBindGroup(1, bindGroup19);
} catch {}
try {
computePassEncoder59.setBindGroup(0, bindGroup20, new Uint32Array(8359), 4_522, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
commandEncoder88.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1062 */
  offset: 1062,
  bytesPerRow: 24064,
  buffer: buffer16,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 3},
  aspect: 'all',
}, {width: 2, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 2 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 81, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup37 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [{binding: 0, resource: {buffer: buffer17}}, {binding: 246, resource: {buffer: buffer21, offset: 0}}],
});
let texture89 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder71 = commandEncoder88.beginComputePass();
try {
renderPassEncoder14.setIndexBuffer(buffer20, 'uint32', 52, 23);
} catch {}
let imageData8 = new ImageData(12, 76);
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 26, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 30,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 298,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 446,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false },
    },
  ],
});
let bindGroup38 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [{binding: 1, resource: externalTexture5}, {binding: 197, resource: sampler0}],
});
try {
computePassEncoder35.setBindGroup(1, bindGroup0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer23, 48); };
} catch {}
try {
device0.queue.writeTexture({
  texture: texture78,
  mipLevel: 1,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(1).fill(199), /* required buffer size: 1 */
{offset: 1}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData9 = new ImageData(20, 36);
let bindGroup39 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [{binding: 6, resource: textureView88}, {binding: 0, resource: textureView89}],
});
let buffer53 = device0.createBuffer({size: 184, usage: GPUBufferUsage.INDIRECT});
let commandEncoder89 = device0.createCommandEncoder();
let texture90 = device0.createTexture({
  size: {width: 63, height: 1, depthOrArrayLayers: 1},
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView90 = texture45.createView({label: '\u{1f93a}\u6922\ue805\u5218', format: 'r16sint', mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder72 = commandEncoder89.beginComputePass();
try {
renderPassEncoder18.setPipeline(pipeline4);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext2 = offscreenCanvas2.getContext('webgpu');
let bindGroup40 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [{binding: 0, resource: {buffer: buffer34}}, {binding: 246, resource: {buffer: buffer5}}],
});
let commandEncoder90 = device0.createCommandEncoder({});
let renderPassEncoder21 = commandEncoder90.beginRenderPass({
  colorAttachments: [{
  view: textureView79,
  depthSlice: 629,
  clearValue: { r: 80.79, g: -506.8, b: 727.8, a: -301.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet4,
});
let sampler52 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 90.47});
try {
computePassEncoder15.end();
} catch {}
try {
computePassEncoder69.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder16.setBlendConstant({ r: 755.1, g: -917.4, b: 461.3, a: -757.3, });
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer16);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 163, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(42_602).fill(7), /* required buffer size: 42_602 */
{offset: 14, bytesPerRow: 26, rowsPerImage: 42}, {width: 6, height: 0, depthOrArrayLayers: 40});
} catch {}
let buffer54 = device0.createBuffer({size: 36, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let renderPassEncoder22 = commandEncoder14.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: 62.72, g: 454.0, b: 725.1, a: 433.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet9,
  maxDrawCount: 45946401,
});
try {
renderPassEncoder6.setVertexBuffer(1, buffer17, 40, 3);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline5 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule1,
  constants: {override7: 1},
  targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex2',
    constants: {override10: 1, 1_863: 1},
    buffers: [
      {
        arrayStride: 372,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 48, shaderLocation: 8},
          {format: 'unorm16x2', offset: 224, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 24, shaderLocation: 9},
          {format: 'uint32', offset: 32, shaderLocation: 5},
          {format: 'unorm16x2', offset: 32, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 184,
        stepMode: 'instance',
        attributes: [{format: 'sint32x2', offset: 24, shaderLocation: 3}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16'},
});
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt709', transfer: 'bt2020_10bit'} });
let buffer55 = device0.createBuffer({size: 152, usage: GPUBufferUsage.INDEX, mappedAtCreation: false});
let textureView91 = texture4.createView({});
try {
renderPassEncoder14.setBindGroup(0, bindGroup39, new Uint32Array(364), 91, 0);
} catch {}
let texture91 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 1},
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView92 = texture70.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 4});
let sampler53 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.28,
});
try {
computePassEncoder41.setBindGroup(0, bindGroup2, new Uint32Array(42), 9, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let querySet17 = device0.createQuerySet({type: 'occlusion', count: 462});
let texture92 = device0.createTexture({
  size: [64, 64, 248],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView93 = texture49.createView({baseArrayLayer: 5, arrayLayerCount: 9});
let sampler54 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 78.63});
try {
computePassEncoder9.setBindGroup(1, bindGroup26);
} catch {}
try {
computePassEncoder27.setBindGroup(1, bindGroup20, new Uint32Array(3632), 2_269, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup23, new Uint32Array(1173), 676, 0);
} catch {}
let imageData10 = new ImageData(60, 4);
let commandEncoder91 = device0.createCommandEncoder({});
let textureView94 = texture30.createView({dimension: '2d', baseArrayLayer: 4});
let texture93 = device0.createTexture({
  size: [127, 1, 86],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView95 = texture36.createView({mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder73 = commandEncoder91.beginComputePass();
try {
renderPassEncoder15.executeBundles([renderBundle5]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let buffer56 = device0.createBuffer({
  size: 244,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder92 = device0.createCommandEncoder({});
try {
computePassEncoder22.setBindGroup(0, bindGroup15, new Uint32Array(4436), 189, 0);
} catch {}
try {
computePassEncoder34.end();
} catch {}
try {
computePassEncoder72.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup16, new Uint32Array(672), 3, 0);
} catch {}
try {
commandEncoder92.copyTextureToBuffer({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2112 */
  offset: 2112,
  bytesPerRow: 8960,
  buffer: buffer16,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 3, y: 21, z: 1},
  aspect: 'all',
}, new Uint8Array(6_935).fill(80), /* required buffer size: 6_935 */
{offset: 19, bytesPerRow: 75, rowsPerImage: 78}, {width: 1, height: 15, depthOrArrayLayers: 2});
} catch {}
let bindGroup41 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [{binding: 6, resource: textureView88}, {binding: 0, resource: textureView89}],
});
try {
computePassEncoder37.setBindGroup(0, bindGroup13);
} catch {}
try {
computePassEncoder52.setBindGroup(2, bindGroup34, new Uint32Array(806), 277, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup4, new Uint32Array(121), 1, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer36);
} catch {}
let bindGroup42 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [{binding: 197, resource: sampler53}, {binding: 1, resource: externalTexture7}],
});
let buffer57 = device0.createBuffer({size: 25, usage: GPUBufferUsage.QUERY_RESOLVE});
let sampler55 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', mipmapFilter: 'linear'});
try {
computePassEncoder63.setBindGroup(3, bindGroup17);
} catch {}
try {
computePassEncoder67.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer9, 'uint16', 6, 0);
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpteRp431', transfer: 'iec61966-2-1'} });
let autogeneratedBindGroupLayout1 = pipeline2.getBindGroupLayout(0);
let commandEncoder93 = device0.createCommandEncoder({});
try {
computePassEncoder54.setBindGroup(3, bindGroup39);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData9,
  origin: { x: 7, y: 2 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer58 = device0.createBuffer({size: 536, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder94 = device0.createCommandEncoder();
let computePassEncoder74 = commandEncoder94.beginComputePass();
let renderPassEncoder23 = commandEncoder93.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: -590.8, g: 100.5, b: -756.0, a: 761.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
computePassEncoder67.setBindGroup(0, bindGroup17, new Uint32Array(3468), 125, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer49, 'uint16', 2, 6);
} catch {}
try {
buffer43.unmap();
} catch {}
try {
commandEncoder92.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1156 */
  offset: 1156,
  buffer: buffer16,
}, {
  texture: texture89,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder95 = device0.createCommandEncoder();
let texture94 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 557},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder75 = commandEncoder92.beginComputePass();
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], stencilReadOnly: true});
let renderBundle9 = renderBundleEncoder10.finish({});
try {
computePassEncoder45.setBindGroup(2, bindGroup40, new Uint32Array(5279), 16, 0);
} catch {}
try {
computePassEncoder60.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder15.setViewport(20.122465756977654, 59.23852200952336, 8.764914881442422, 0.005006938590236801, 0.9458222614215074, 0.9495258342078475);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 14, 0);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(5, buffer13, 0, 52);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer23, 'uint16', 72, 17);
} catch {}
try {
commandEncoder95.copyBufferToTexture({
  /* bytesInLastRow: 280 widthInBlocks: 35 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 360 */
  offset: 360,
  bytesPerRow: 6656,
  buffer: buffer18,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 57, y: 0, z: 0},
  aspect: 'all',
}, {width: 35, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap1,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup43 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [{binding: 1, resource: externalTexture0}, {binding: 197, resource: sampler4}],
});
let commandEncoder96 = device0.createCommandEncoder();
let textureView96 = texture38.createView({mipLevelCount: 4});
try {
computePassEncoder29.setBindGroup(0, bindGroup22, new Uint32Array(566), 154, 0);
} catch {}
try {
computePassEncoder44.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle9]);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer36, 'uint16', 56, 4);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(3, buffer13, 0);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer22, 'uint32', 0, 5);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline5);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 4, new DataView(new ArrayBuffer(10207)), 1801, 64);
} catch {}
let pipeline6 = await promise10;
let bindGroup44 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 1, resource: textureView0}]});
let textureView97 = texture19.createView({});
let sampler56 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.94,
  maxAnisotropy: 7,
});
try {
renderPassEncoder16.executeBundles([renderBundle9]);
} catch {}
try {
renderPassEncoder19.setViewport(36.602527382097406, 41.766324059370056, 14.200387929418493, 1.7408430560626278, 0.23294224447494993, 0.6513669347699147);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer9, 'uint16', 6, 1);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(2, buffer28, 0, 0);
} catch {}
try {
buffer17.unmap();
} catch {}
let textureView98 = texture53.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 4});
let computePassEncoder76 = commandEncoder96.beginComputePass();
let externalTexture8 = device0.importExternalTexture({source: videoFrame1});
try {
renderPassEncoder14.setBindGroup(2, bindGroup40, new Uint32Array(3844), 583, 0);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(2, buffer2, 0, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 1, y: 4, z: 1},
  aspect: 'all',
}, new Uint8Array(86).fill(157), /* required buffer size: 86 */
{offset: 86, bytesPerRow: 38}, {width: 3, height: 21, depthOrArrayLayers: 0});
} catch {}
try {
  await promise11;
} catch {}
let bindGroup45 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture3}, {binding: 197, resource: sampler55}],
});
let texture95 = device0.createTexture({size: [63, 1, 1], mipLevelCount: 4, format: 'rgba8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView99 = texture0.createView({dimension: '2d', format: 'r32sint', baseArrayLayer: 2});
let sampler57 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 91.67});
try {
computePassEncoder75.setBindGroup(1, bindGroup45, new Uint32Array(218), 71, 0);
} catch {}
try {
computePassEncoder61.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup2, new Uint32Array(707), 49, 0);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer22, 'uint16', 0, 11);
} catch {}
try {
commandEncoder36.copyBufferToBuffer(buffer5, 0, buffer10, 88, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture96 = gpuCanvasContext1.getCurrentTexture();
let textureView100 = texture3.createView({format: 'r32float', baseMipLevel: 0});
let renderBundle10 = renderBundleEncoder9.finish({});
try {
computePassEncoder67.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup20, new Uint32Array(4018), 1_057, 0);
} catch {}
try {
renderPassEncoder14.setBlendConstant({ r: -809.1, g: -423.8, b: 133.1, a: -861.1, });
} catch {}
try {
renderPassEncoder6.draw(174, 147, 956_701_530, 1_583_581_758);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer40, 56);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, buffer2);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
let commandEncoder97 = device0.createCommandEncoder({});
let textureView101 = texture93.createView({dimension: '3d', format: 'r16sint', mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder77 = commandEncoder36.beginComputePass();
let sampler58 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 77.94});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer40, 0); };
} catch {}
try {
renderPassEncoder23.setScissorRect(16, 0, 208, 0);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(4, undefined);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup46 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [{binding: 1, resource: externalTexture0}, {binding: 197, resource: sampler21}],
});
let computePassEncoder78 = commandEncoder97.beginComputePass();
let renderPassEncoder24 = commandEncoder95.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: 444.2, g: -49.21, b: -398.7, a: 812.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 71889619,
});
try {
computePassEncoder37.setBindGroup(3, bindGroup40, new Uint32Array(7319), 3_310, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer49, 28);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let buffer59 = device0.createBuffer({size: 116, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let textureView102 = texture50.createView({});
try {
computePassEncoder78.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle5, renderBundle5]);
} catch {}
try {
renderPassEncoder6.draw(314, 315, 1_056_527_320, 385_401_698);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer7, 8);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout5]});
let commandEncoder98 = device0.createCommandEncoder({});
let textureView103 = texture22.createView({dimension: '2d'});
let computePassEncoder79 = commandEncoder98.beginComputePass();
try {
renderPassEncoder15.setBindGroup(3, bindGroup46, new Uint32Array(1283), 227, 0);
} catch {}
try {
renderPassEncoder6.end();
} catch {}
try {
device0.queue.writeBuffer(buffer59, 12, new Uint32Array(16009), 1061, 0);
} catch {}
let textureView104 = texture65.createView({dimension: '2d-array'});
let texture97 = device0.createTexture({
  size: {width: 255},
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder80 = commandEncoder53.beginComputePass();
try {
computePassEncoder29.setBindGroup(1, bindGroup29);
} catch {}
try {
computePassEncoder55.insertDebugMarker('\u12a9');
} catch {}
let imageData11 = new ImageData(44, 28);
let buffer60 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let texture98 = device0.createTexture({
  size: [255, 1, 11],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture99 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 554},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
let renderBundle11 = renderBundleEncoder11.finish({});
try {
computePassEncoder9.end();
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup43);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline4);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let bindGroup47 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture8}, {binding: 197, resource: sampler27}],
});
let buffer61 = device0.createBuffer({size: 365, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let textureView105 = texture98.createView({arrayLayerCount: 2});
let computePassEncoder81 = commandEncoder9.beginComputePass();
let sampler59 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 70.12,
});
try {
computePassEncoder25.setBindGroup(3, bindGroup36, []);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup22, new Uint32Array(630), 51, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(30);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer22, 'uint32', 4, 4);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline4);
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 23,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 205,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let texture100 = device0.createTexture({
  label: '\ub69f\u9bd3\u1527\u32a8\u0f46',
  size: [63, 1, 82],
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView106 = texture39.createView({});
try {
renderPassEncoder15.setBindGroup(2, bindGroup23);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline4);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let imageBitmap2 = await createImageBitmap(imageData8);
let sampler60 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 87.82,
});
try {
computePassEncoder72.setBindGroup(1, bindGroup2);
} catch {}
try {
computePassEncoder75.setPipeline(pipeline2);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let pipeline7 = await device0.createComputePipelineAsync({layout: pipelineLayout10, compute: {module: shaderModule0, constants: {}}});
let imageBitmap3 = await createImageBitmap(imageData9);
let bindGroup48 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [{binding: 197, resource: sampler54}, {binding: 1, resource: externalTexture3}],
});
let sampler61 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 94.63,
  compare: 'not-equal',
});
try {
computePassEncoder53.setBindGroup(1, bindGroup10);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(3); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroupsIndirect(buffer7, 20); };
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup13, new Uint32Array(5918), 1_283, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline4);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let bindGroup49 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture4}, {binding: 197, resource: sampler24}],
});
let commandEncoder99 = device0.createCommandEncoder({});
let texture101 = device0.createTexture({
  size: [127, 1, 103],
  mipLevelCount: 2,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView107 = texture82.createView({dimension: '2d-array'});
let computePassEncoder82 = commandEncoder99.beginComputePass();
try {
computePassEncoder26.end();
} catch {}
try {
commandEncoder26.copyBufferToTexture({
  /* bytesInLastRow: 14 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1322 */
  offset: 1322,
  bytesPerRow: 4608,
  buffer: buffer16,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder26.copyTextureToBuffer({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 154 widthInBlocks: 77 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1544 */
  offset: 1544,
  bytesPerRow: 16896,
  buffer: buffer16,
}, {width: 77, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 4, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup50 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [{binding: 6, resource: textureView88}, {binding: 0, resource: textureView89}],
});
let commandEncoder100 = device0.createCommandEncoder({});
let texture102 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView108 = texture12.createView({});
let computePassEncoder83 = commandEncoder100.beginComputePass();
try {
computePassEncoder81.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer36, 'uint32', 0, 32);
} catch {}
let buffer62 = device0.createBuffer({size: 120, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder101 = device0.createCommandEncoder({});
let computePassEncoder84 = commandEncoder26.beginComputePass();
try {
computePassEncoder29.setBindGroup(0, bindGroup30, new Uint32Array(1806), 1_806, 0);
} catch {}
try {
computePassEncoder71.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup16);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup29, new Uint32Array(79), 6, 0);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle9, renderBundle9, renderBundle9]);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(6, undefined, 0);
} catch {}
let buffer63 = device0.createBuffer({size: 116, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder102 = device0.createCommandEncoder({});
let computePassEncoder85 = commandEncoder101.beginComputePass();
try {
computePassEncoder76.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup32);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup21, new Uint32Array(231), 70, 0);
} catch {}
try {
  await buffer43.mapAsync(GPUMapMode.READ);
} catch {}
try {
commandEncoder102.insertDebugMarker('\u57e8');
} catch {}
let computePassEncoder86 = commandEncoder102.beginComputePass();
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: [undefined], depthReadOnly: true, stencilReadOnly: true});
let sampler62 = device0.createSampler({
  label: '\u0a33\u{1f95e}\u0798\u6676\u0859',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 89.36,
});
try {
computePassEncoder85.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup22);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer56, 'uint16', 16, 37);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup30, new Uint32Array(2008), 47, 0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer17, 12);
} catch {}
try {
renderPassEncoder11.pushDebugGroup('\u7f99');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture74,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(40).fill(217), /* required buffer size: 40 */
{offset: 40}, {width: 50, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(14); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroups(4, 1); };
} catch {}
try {
computePassEncoder83.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup22);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup12, new Uint32Array(2052), 34, 0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(7, buffer2);
} catch {}
await gc();
try {
computePassEncoder37.label = '\u3b70\u0a5f';
} catch {}
let autogeneratedBindGroupLayout2 = pipeline2.getBindGroupLayout(0);
let bindGroup51 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 1, resource: textureView6}]});
let buffer64 = device0.createBuffer({
  size: 212,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder103 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder87 = commandEncoder103.beginComputePass();
let sampler63 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMaxClamp: 88.66,
});
let externalTexture9 = device0.importExternalTexture({source: videoFrame12});
try {
renderPassEncoder18.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder0.setScissorRect(24, 4, 13, 21);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup49, new Uint32Array(169), 1, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer55, 'uint32', 24, 12);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(6, buffer5);
} catch {}
let texture104 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 35},
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder87.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.setBindGroup(1, bindGroup11);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup41);
} catch {}
let texture105 = device0.createTexture({size: {width: 255}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder51.setBindGroup(1, bindGroup38);
} catch {}
try {
computePassEncoder78.setBindGroup(1, bindGroup14, new Uint32Array(4673), 1_586, 0);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup29, new Uint32Array(3156), 823, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer23, 'uint16', 16, 130);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup52 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: externalTexture3}, {binding: 197, resource: sampler33}],
});
let texture106 = device0.createTexture({
  size: [510, 1, 1],
  mipLevelCount: 2,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder50.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle10, renderBundle10]);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup38);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer49.unmap();
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'opaque',
});
} catch {}
let commandEncoder104 = device0.createCommandEncoder();
let renderPassEncoder25 = commandEncoder104.beginRenderPass({
  colorAttachments: [{view: textureView39, depthSlice: 39, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet9,
});
let sampler64 = device0.createSampler({addressModeU: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 97.77});
try {
computePassEncoder58.setBindGroup(0, bindGroup43, []);
} catch {}
try {
computePassEncoder80.setBindGroup(2, bindGroup13, new Uint32Array(645), 179, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup1);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup48);
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
let buffer65 = device0.createBuffer({size: 128, usage: GPUBufferUsage.UNIFORM});
let commandEncoder105 = device0.createCommandEncoder({});
let textureView109 = texture87.createView({baseMipLevel: 0});
let renderPassEncoder26 = commandEncoder105.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  clearValue: { r: 373.5, g: -64.15, b: -549.4, a: -646.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet17,
});
let sampler65 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  compare: 'equal',
});
try {
computePassEncoder47.setBindGroup(2, bindGroup27);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle9]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint32', 12, 0);
} catch {}
try {
renderPassEncoder11.popDebugGroup();
} catch {}
let bindGroup53 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 1, resource: externalTexture2}, {binding: 197, resource: sampler9}],
});
let textureView110 = texture98.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1});
let texture107 = device0.createTexture({
  size: {width: 255, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder66.setBindGroup(1, bindGroup34);
} catch {}
try {
computePassEncoder80.setBindGroup(3, bindGroup15, new Uint32Array(2117), 110, 0);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(2, buffer16, 0, 365);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup8);
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(230, 49);
let textureView111 = texture90.createView({});
let renderBundle12 = renderBundleEncoder12.finish({});
let sampler66 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMaxClamp: 99.51,
});
try {
computePassEncoder13.end();
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup35, new Uint32Array(1666), 10, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer41.unmap();
} catch {}
try {
computePassEncoder17.insertDebugMarker('\u529a');
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let texture108 = device0.createTexture({
  size: {width: 63, height: 1, depthOrArrayLayers: 17},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder27 = commandEncoder10.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  clearValue: { r: 930.6, g: -453.7, b: 493.4, a: 638.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 313015875,
});
let sampler67 = device0.createSampler({addressModeV: 'repeat', minFilter: 'nearest', lodMaxClamp: 62.12, compare: 'less-equal'});
let externalTexture10 = device0.importExternalTexture({source: videoFrame10});
try {
computePassEncoder73.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer22, 'uint32', 0, 9);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline5);
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
let commandEncoder106 = device0.createCommandEncoder({});
let querySet18 = device0.createQuerySet({type: 'occlusion', count: 1644});
let computePassEncoder88 = commandEncoder106.beginComputePass();
try {
computePassEncoder27.setBindGroup(1, bindGroup30, new Uint32Array(2561), 2_561, 0);
} catch {}
try {
computePassEncoder86.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup9, []);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer50, 'uint16', 4, 107);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline5);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let arrayBuffer2 = buffer43.getMappedRange(0, 0);
try {
computePassEncoder80.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup4, new Uint32Array(360), 81, 0);
} catch {}
try {
renderPassEncoder10.setBlendConstant({ r: -328.6, g: -281.6, b: -746.8, a: -833.4, });
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer28, 0);
} catch {}
let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout6]});
try {
renderPassEncoder24.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup11, new Uint32Array(6335), 275, 0);
} catch {}
try {
renderPassEncoder26.setBlendConstant({ r: 865.9, g: 404.4, b: 639.7, a: -505.4, });
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer56, 'uint32', 60, 8);
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
let buffer66 = device0.createBuffer({size: 626, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder107 = device0.createCommandEncoder({});
let computePassEncoder89 = commandEncoder107.beginComputePass();
let sampler68 = device0.createSampler({addressModeV: 'mirror-repeat', compare: 'equal'});
try {
computePassEncoder77.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup45);
} catch {}
try {
renderPassEncoder26.beginOcclusionQuery(369);
} catch {}
try {
renderPassEncoder26.endOcclusionQuery();
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder108 = device0.createCommandEncoder({});
let computePassEncoder90 = commandEncoder108.beginComputePass();
try {
computePassEncoder82.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder35.pushDebugGroup('\u799b');
} catch {}
try {
device0.queue.submit([]);
} catch {}
let recycledExplicitBindGroupLayout7 = pipeline6.getBindGroupLayout(0);
let bindGroup54 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [{binding: 1, resource: externalTexture0}, {binding: 197, resource: sampler55}],
});
let buffer67 = device0.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC});
let texture109 = device0.createTexture({
  label: '\u91ba\ud5d3',
  size: {width: 127, height: 1, depthOrArrayLayers: 978},
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler69 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat'});
try {
computePassEncoder58.setBindGroup(0, bindGroup10, []);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeBuffer(buffer32, 0, new DataView(new ArrayBuffer(4016)), 83, 20);
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture9}, {binding: 197, resource: sampler12}],
});
let sampler70 = device0.createSampler({
  label: '\uf3f5\u0ee9\u0aa7\u81b3\u{1faee}\ucdf5',
  addressModeV: 'repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 91.99,
});
try {
computePassEncoder90.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup10, []);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup45, new Uint32Array(1161), 84, 0);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer40, 20);
} catch {}
try {
computePassEncoder35.popDebugGroup();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(102); };
} catch {}
let textureView112 = texture36.createView({mipLevelCount: 1});
let sampler71 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.55,
  compare: 'always',
});
try {
computePassEncoder88.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder27.end();
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer12, 4);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer23, 16);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer16);
} catch {}
let buffer68 = device0.createBuffer({
  label: '\u3733\u0288\ue29f\u3054\u0cbc',
  size: 56,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT,
});
try {
{ clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroupsIndirect(buffer56, 136); };
} catch {}
try {
computePassEncoder89.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup33);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup36, new Uint32Array(2975), 32, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle9, renderBundle9, renderBundle9, renderBundle9, renderBundle9]);
} catch {}
try {
renderPassEncoder0.draw(186, 35, 531_307_410, 767_671_740);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer7, 16);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer23, 'uint16', 12, 29);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer13);
} catch {}
let commandEncoder109 = device0.createCommandEncoder({});
let textureView113 = texture55.createView({});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], stencilReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroups(5); };
} catch {}
try {
renderPassEncoder0.draw(146, 157, 88_867_865, 1_558_872_952);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer61, 52);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer6, 4);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(3, buffer28, 0, 0);
} catch {}
try {
commandEncoder10.copyBufferToTexture({
  /* bytesInLastRow: 14 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1598 */
  offset: 1598,
  rowsPerImage: 525,
  buffer: buffer16,
}, {
  texture: texture51,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer2, 4, new Uint32Array(9984), 203, 0);
} catch {}
let pipeline8 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, constants: {}}});
let gpuCanvasContext3 = offscreenCanvas3.getContext('webgpu');
await gc();
let autogeneratedBindGroupLayout3 = pipeline8.getBindGroupLayout(0);
let texture110 = device0.createTexture({
  size: {width: 64},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder91 = commandEncoder109.beginComputePass();
try {
computePassEncoder74.setBindGroup(1, bindGroup11);
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer34, 'uint16', 2, 9);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline4);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
try {
  await promise17;
} catch {}
await gc();
let computePassEncoder92 = commandEncoder10.beginComputePass();
let sampler72 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 89.31,
  compare: 'less',
});
try {
computePassEncoder76.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder79.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder0.draw(125, 180, 1_382_637_937, 54_472_827);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer23, 4);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer61, 0);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder22.insertDebugMarker('\u8f98');
} catch {}
let promise18 = device0.createComputePipelineAsync({layout: pipelineLayout10, compute: {module: shaderModule0}});
let buffer69 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder110 = device0.createCommandEncoder({});
let computePassEncoder93 = commandEncoder110.beginComputePass();
let renderBundle13 = renderBundleEncoder13.finish({});
try {
computePassEncoder17.setBindGroup(0, bindGroup47, []);
} catch {}
try {
computePassEncoder59.setBindGroup(2, bindGroup0, new Uint32Array(1682), 101, 0);
} catch {}
try {
computePassEncoder92.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setStencilReference(25);
} catch {}
try {
renderPassEncoder0.drawIndexed(0, 35, 0, 791_797_970, 179_816_991);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(5, buffer2);
} catch {}
try {
renderPassEncoder15.insertDebugMarker('\u{1ffc6}');
} catch {}
let buffer70 = device0.createBuffer({size: 200, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder111 = device0.createCommandEncoder({});
let texture111 = device0.createTexture({
  size: [255, 1, 596],
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder25.beginOcclusionQuery(191);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer7, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer45, 'uint16', 4, 7);
} catch {}
try {
commandEncoder111.copyBufferToBuffer(buffer67, 0, buffer35, 8, 0);
} catch {}
try {
commandEncoder111.copyBufferToTexture({
  /* bytesInLastRow: 510 widthInBlocks: 255 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4704 */
  offset: 4704,
  bytesPerRow: 17664,
  rowsPerImage: 733,
  buffer: buffer16,
}, {
  texture: texture84,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {width: 255, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer60, 12, new Uint32Array(152), 32, 16);
} catch {}
let promise19 = device0.createComputePipelineAsync({layout: pipelineLayout7, compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}});
await gc();
let imageData12 = new ImageData(4, 36);
let commandEncoder112 = device0.createCommandEncoder({});
let texture112 = device0.createTexture({
  size: [510, 1, 47],
  dimension: '2d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder94 = commandEncoder112.beginComputePass();
try {
computePassEncoder74.setBindGroup(3, bindGroup42, new Uint32Array(1958), 521, 0);
} catch {}
try {
computePassEncoder4.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder91.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder0.drawIndexed(0, 76, 0, 392_716_243, 945_264_965);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer9, 8);
} catch {}
try {
commandEncoder111.copyTextureToBuffer({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 98, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 296 widthInBlocks: 37 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1208 */
  offset: 1208,
  bytesPerRow: 9984,
  buffer: buffer16,
}, {width: 37, height: 0, depthOrArrayLayers: 1});
} catch {}
let bindGroup56 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [{binding: 6, resource: textureView88}, {binding: 0, resource: textureView89}],
});
let commandEncoder113 = device0.createCommandEncoder({});
let computePassEncoder95 = commandEncoder111.beginComputePass();
try {
computePassEncoder22.setBindGroup(0, bindGroup52, new Uint32Array(295), 19, 0);
} catch {}
try {
computePassEncoder95.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup35, new Uint32Array(230), 8, 0);
} catch {}
try {
renderPassEncoder18.setScissorRect(6, 3, 26, 4);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer62, 20);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer20, 'uint16', 78, 10);
} catch {}
try {
buffer49.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer20, 40, new Int16Array(5749), 559, 4);
} catch {}
let bindGroup57 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 1, resource: textureView6}]});
let buffer71 = device0.createBuffer({size: 12, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder114 = device0.createCommandEncoder({});
let texture113 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 17},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView114 = texture42.createView({});
let renderPassEncoder28 = commandEncoder113.beginRenderPass({
  colorAttachments: [{
  view: textureView79,
  depthSlice: 854,
  clearValue: { r: 960.2, g: -10.53, b: -218.0, a: -239.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 133452705,
});
let sampler73 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', lodMaxClamp: 76.71});
try {
computePassEncoder93.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder0.draw(380, 91, 902_842_626, 1_221_530_559);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer50, 'uint16', 22, 16);
} catch {}
let pipeline9 = device0.createRenderPipeline({
  layout: pipelineLayout10,
  fragment: {module: shaderModule1, constants: {override7: 1}, targets: [{format: 'r16sint', writeMask: 0}]},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex3',
    constants: {1_863: 1},
    buffers: [{arrayStride: 1376, attributes: [{format: 'unorm8x2', offset: 644, shaderLocation: 12}]}],
  },
  primitive: {topology: 'point-list', cullMode: 'back'},
});
let texture114 = device0.createTexture({
  size: {width: 64},
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder96 = commandEncoder114.beginComputePass();
try {
renderPassEncoder11.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup49, new Uint32Array(1560), 123, 0);
} catch {}
try {
renderPassEncoder0.end();
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 136 widthInBlocks: 34 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1672 */
  offset: 1672,
  bytesPerRow: 15616,
  buffer: buffer16,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, {width: 34, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap4 = await createImageBitmap(videoFrame6);
let commandEncoder115 = device0.createCommandEncoder({});
let querySet19 = device0.createQuerySet({type: 'occlusion', count: 453});
let texture115 = device0.createTexture({
  size: [63, 1, 79],
  mipLevelCount: 2,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8sint'],
});
let textureView115 = texture109.createView({});
let renderPassEncoder29 = commandEncoder24.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: -954.3, g: 175.3, b: -895.8, a: -427.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder39.end();
} catch {}
try {
renderPassEncoder25.endOcclusionQuery();
} catch {}
try {
commandEncoder115.copyBufferToBuffer(buffer36, 4, buffer16, 6700, 48);
} catch {}
let textureView116 = texture106.createView({dimension: '2d-array', format: 'rgba8sint', mipLevelCount: 1});
let renderPassEncoder30 = commandEncoder115.beginRenderPass({
  label: '\u1ca6\u3e10\u8df2\u{1fff6}\uf951\u{1f649}\u0ee3\u2020\u{1ffde}\u4c6a\u{1fad6}',
  colorAttachments: [{
  view: textureView83,
  clearValue: { r: -285.3, g: -922.1, b: -63.71, a: -373.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer62, 60); };
} catch {}
try {
commandEncoder44.copyBufferToBuffer(buffer41, 0, buffer63, 4, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer19, 28, new Uint32Array(10581), 1189, 0);
} catch {}
let commandEncoder116 = device0.createCommandEncoder({});
let texture116 = device0.createTexture({
  size: [510, 1, 40],
  sampleCount: 1,
  dimension: '2d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder94.setPipeline(pipeline6);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'film', transfer: 'smpteSt4281'} });
let buffer72 = device0.createBuffer({size: 134, usage: GPUBufferUsage.COPY_DST});
let computePassEncoder97 = commandEncoder116.beginComputePass();
try {
computePassEncoder10.setBindGroup(2, bindGroup16, new Uint32Array(5612), 31, 0);
} catch {}
try {
renderPassEncoder29.setBindGroup(3, bindGroup38, new Uint32Array(5154), 384, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData10,
  origin: { x: 4, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData13 = new ImageData(32, 76);
let sampler74 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 76.84});
try {
computePassEncoder6.setBindGroup(0, bindGroup43);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup49);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup13, new Uint32Array(904), 145, 0);
} catch {}
try {
commandEncoder44.copyBufferToTexture({
  /* bytesInLastRow: 510 widthInBlocks: 255 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4988 */
  offset: 4988,
  bytesPerRow: 46080,
  buffer: buffer16,
}, {
  texture: texture84,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {width: 255, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
globalThis.someLabel = externalTexture5.label;
} catch {}
let bindGroup58 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout7,
  entries: [{binding: 197, resource: sampler63}, {binding: 1, resource: externalTexture4}],
});
let commandEncoder117 = device0.createCommandEncoder({});
let renderPassEncoder31 = commandEncoder44.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: -588.1, g: 65.57, b: -60.37, a: -603.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet9,
});
try {
computePassEncoder91.setBindGroup(0, bindGroup36, new Uint32Array(3268), 2_784, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture117 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 1020},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder49.setBindGroup(0, bindGroup40);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(3, buffer36);
} catch {}
try {
querySet19.destroy();
} catch {}
let pipeline10 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule2, entryPoint: 'compute4'}});
let commandEncoder118 = device0.createCommandEncoder({});
try {
computePassEncoder97.setBindGroup(0, bindGroup51);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup41);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer55, 'uint16', 30, 4);
} catch {}
try {
commandEncoder117.copyBufferToBuffer(buffer14, 40, buffer20, 64, 16);
} catch {}
try {
commandEncoder117.copyTextureToBuffer({
  texture: texture46,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 194 widthInBlocks: 97 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1950 */
  offset: 1950,
  bytesPerRow: 17152,
  buffer: buffer16,
}, {width: 97, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder70.pushDebugGroup('\uc661');
} catch {}
let buffer73 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder119 = device0.createCommandEncoder({});
let texture118 = device0.createTexture({size: [63, 1, 6], format: 'rgba8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let computePassEncoder98 = commandEncoder118.beginComputePass();
let sampler75 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 86.91});
try {
computePassEncoder70.setBindGroup(1, bindGroup42, new Uint32Array(1010), 82, 0);
} catch {}
try {
computePassEncoder2.end();
} catch {}
try {
computePassEncoder56.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup11, new Uint32Array(686), 50, 0);
} catch {}
try {
commandEncoder117.resolveQuerySet(querySet9, 43, 2, buffer64, 0);
} catch {}
let pipeline11 = await promise19;
let computePassEncoder99 = commandEncoder2.beginComputePass();
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true});
try {
computePassEncoder69.setBindGroup(0, bindGroup20);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder88.setPipeline(pipeline6);
} catch {}
try {
computePassEncoder74.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup6, new Uint32Array(559), 17, 0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(292);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(2, buffer17, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup13);
} catch {}
try {
commandEncoder44.label = '\uece1\u083c\u38e3\u3e40\u56e0\u{1fe8c}';
} catch {}
let textureView117 = texture109.createView({});
let computePassEncoder100 = commandEncoder117.beginComputePass();
try {
computePassEncoder97.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup41, new Uint32Array(407), 91, 0);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.setVertexBuffer(4, buffer28, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup27, []);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup46, new Uint32Array(2106), 286, 0);
} catch {}
try {
commandEncoder119.copyTextureToTexture({
  texture: texture46,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture56,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData14 = new ImageData(8, 44);
let commandEncoder120 = device0.createCommandEncoder({});
let textureView118 = texture71.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 6});
let renderBundle14 = renderBundleEncoder14.finish({});
try {
computePassEncoder6.setBindGroup(0, bindGroup43, new Uint32Array(1719), 3, 0);
} catch {}
try {
computePassEncoder98.setPipeline(pipeline10);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(34); };
} catch {}
let buffer74 = device0.createBuffer({size: 168, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
let textureView119 = texture23.createView({});
let renderPassEncoder32 = commandEncoder120.beginRenderPass({
  colorAttachments: [{
  view: textureView98,
  clearValue: { r: 484.8, g: 178.7, b: 798.4, a: -949.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 44434827,
});
try {
computePassEncoder6.end();
} catch {}
try {
device0.queue.writeBuffer(buffer72, 4, new Uint32Array(2426), 172, 0);
} catch {}
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }},
    {binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: true }},
    {
      binding: 762,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 39, hasDynamicOffset: false },
    },
  ],
});
let commandEncoder121 = device0.createCommandEncoder({});
let texture119 = device0.createTexture({
  size: {width: 63, height: 1, depthOrArrayLayers: 14},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder101 = commandEncoder119.beginComputePass();
try {
computePassEncoder59.end();
} catch {}
try {
renderPassEncoder26.setScissorRect(2, 9, 8, 21);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer6, 'uint32', 0, 5);
} catch {}
try {
buffer6.unmap();
} catch {}
try {
commandEncoder70.copyBufferToTexture({
  /* bytesInLastRow: 76 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 864 */
  offset: 864,
  buffer: buffer16,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 66, y: 0, z: 0},
  aspect: 'all',
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder70.popDebugGroup();
} catch {}
let recycledExplicitBindGroupLayout8 = pipeline10.getBindGroupLayout(0);
let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout12]});
let buffer75 = device0.createBuffer({size: 504, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let texture120 = device0.createTexture({
  size: [127, 1, 29],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView120 = texture116.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 19});
let renderPassEncoder33 = commandEncoder121.beginRenderPass({
  colorAttachments: [{
  view: textureView90,
  depthSlice: 116,
  clearValue: { r: -726.1, g: -833.0, b: -83.66, a: 292.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
{ clearResourceUsages(device0, computePassEncoder69); computePassEncoder69.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder69.end();
} catch {}
try {
renderPassEncoder30.setVertexBuffer(7, buffer40, 0, 9);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC, alphaMode: 'premultiplied'});
} catch {}
let autogeneratedBindGroupLayout4 = pipeline3.getBindGroupLayout(0);
let bindGroup59 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 1, resource: textureView0}]});
let commandEncoder122 = device0.createCommandEncoder();
let texture121 = device0.createTexture({size: [510], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let computePassEncoder102 = commandEncoder56.beginComputePass();
let renderPassEncoder34 = commandEncoder122.beginRenderPass({
  colorAttachments: [{view: textureView115, depthSlice: 25, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 355484026,
});
let sampler76 = device0.createSampler({lodMaxClamp: 69.29});
try {
renderPassEncoder10.setVertexBuffer(3, buffer60);
} catch {}
try {
buffer56.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let buffer76 = device0.createBuffer({size: 480, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let texture122 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder103 = commandEncoder5.beginComputePass();
let renderPassEncoder35 = commandEncoder70.beginRenderPass({
  colorAttachments: [{view: textureView83, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet12,
});
let sampler77 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 83.85,
  maxAnisotropy: 13,
});
try {
computePassEncoder101.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder35.setBindGroup(3, bindGroup59);
} catch {}
try {
renderPassEncoder26.executeBundles([renderBundle11, renderBundle1]);
} catch {}
let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout9]});
let textureView121 = texture50.createView({aspect: 'all'});
try {
renderPassEncoder25.end();
} catch {}
try {
renderPassEncoder14.setBlendConstant({ r: -966.4, g: -599.0, b: -135.0, a: -536.5, });
} catch {}
try {
globalThis.someLabel = externalTexture10.label;
} catch {}
let buffer77 = device0.createBuffer({
  label: '\u91cd\u8dcf\u0e29\u{1f628}\u96af\u{1f9fc}\u{1f684}\u{1f6cf}\ud5cf',
  size: 264,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE,
});
let texture123 = device0.createTexture({
  size: [127],
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder104 = commandEncoder104.beginComputePass();
try {
computePassEncoder22.setBindGroup(0, bindGroup22);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer69, 'uint16', 12, 29);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture97,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(308).fill(13), /* required buffer size: 308 */
{offset: 308}, {width: 44, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(18); };
} catch {}
let texture124 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 1},
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture125 = device0.createTexture({size: [255, 1, 1], format: 'rgba8sint', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
try {
computePassEncoder103.setPipeline(pipeline7);
} catch {}
let texture126 = device0.createTexture({
  label: '\u7592\u{1f89c}\u3293\u8a8b\udf05\uaa8c\u8853\u{1ffa7}\u0d06\u0214',
  size: {width: 255, height: 1, depthOrArrayLayers: 19},
  mipLevelCount: 1,
  dimension: '2d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView122 = texture101.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 8});
try {
computePassEncoder76.setBindGroup(1, bindGroup37, new Uint32Array(1406), 352, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder41); computePassEncoder41.dispatchWorkgroupsIndirect(buffer53, 8); };
} catch {}
try {
computePassEncoder99.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup31);
} catch {}
try {
renderPassEncoder16.setScissorRect(2, 0, 12, 5);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer9, 'uint16', 0, 12);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(0, buffer17, 24, 38);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 0, new DataView(new ArrayBuffer(829)), 109, 0);
} catch {}
try {
computePassEncoder63.setBindGroup(2, bindGroup28);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup47, new Uint32Array(509), 83, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer17, 96, 17);
} catch {}
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 23,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 205,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
try {
computePassEncoder41.end();
} catch {}
try {
computePassEncoder84.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, buffer70, 20, 10);
} catch {}
try {
commandEncoder45.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 44 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1798 */
  offset: 1798,
  buffer: buffer16,
}, {width: 22, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(55); };
} catch {}
let buffer78 = device0.createBuffer({size: 284, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, mappedAtCreation: false});
let commandEncoder123 = device0.createCommandEncoder({});
let textureView123 = texture61.createView({dimension: 'cube-array', arrayLayerCount: 6});
try {
computePassEncoder104.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder10.setBlendConstant({ r: -366.1, g: -338.7, b: 602.1, a: -343.4, });
} catch {}
try {
renderPassEncoder30.setVertexBuffer(5, buffer3);
} catch {}
let pipeline12 = await promise18;
try {
  await promise14;
} catch {}
let buffer79 = device0.createBuffer({size: 40, usage: GPUBufferUsage.UNIFORM});
let computePassEncoder105 = commandEncoder123.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder102.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder34.setBindGroup(3, bindGroup53);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer76, 'uint16', 78, 1);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(3, buffer13, 0, 58);
} catch {}
try {
commandEncoder45.copyBufferToTexture({
  /* bytesInLastRow: 226 widthInBlocks: 113 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4262 */
  offset: 4262,
  bytesPerRow: 27648,
  buffer: buffer16,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
}, {width: 113, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder45.copyTextureToTexture({
  texture: texture83,
  mipLevel: 1,
  origin: {x: 2, y: 1, z: 18},
  aspect: 'all',
},
{
  texture: texture27,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST});
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires pointer_composite_access;

enable f16;

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

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

/* zero global variables used */
fn fn4(a0: ptr<function, VertexOutput4>) {
  if bool((vec4u(unconst_u32(933909282), unconst_u32(2023763554), unconst_u32(222173942), unconst_u32(407273721)) ^ vec4u(unconst_u32(141903103), unconst_u32(2362781381), unconst_u32(208176258), unconst_u32(79349611))).x) {
  while bool(faceForward(vec2h(unconst_f16(21759.0), unconst_f16(-8716.3)), vec2h(unconst_f16(4584.2), unconst_f16(-6991.3)), vec2h(unconst_f16(9651.6), unconst_f16(-336.6))).y) {
  var vf60: vec4f = unpack4x8unorm(unconst_u32(213607576));
  let vf61: vec3f = inverseSqrt(vec3f(unconst_f32(0.3136), unconst_f32(0.02273), unconst_f32(0.1677e-6)));
}
  loop {
  let vf62: vec2f = (vec2f(unconst_f32(0.05871e-2), unconst_f32(0.2831e30)) / unconst_f32(0.06635e-37));
  break;
}
  let vf63: u32 = pack2x16snorm(vec2f(unconst_f32(0.00966e24), unconst_f32(0.03714e-33)));
  (*a0).f16 = (*a0).f16;
}
  vp44 = VertexOutput4(vec4f((*a0).f16[unconst_u32(458281456)]));
  switch vec4i((vec4u(unconst_u32(373877525), unconst_u32(515834094), unconst_u32(639094613), unconst_u32(52391971)) ^ vec4u(unconst_u32(49149446), unconst_u32(412525549), unconst_u32(1302992795), unconst_u32(57301902))))[2] { 
  default {
  (*a0).f16 -= cross(vec3f(unconst_f32(0.1009), unconst_f32(0.5153e-11), unconst_f32(0.7369e-45)), (*a0).f16.bab).yxzy;
  break;
}
  }
  let ptr29: ptr<function, VertexOutput4> = &(*a0);
  (*a0).f16 = vec4f(asinh(vec3h(unconst_f16(27285.6), unconst_f16(3802.4), unconst_f16(21007.4))).brgb.wzzx.agab);
  var vf64: vec3f = ldexp(vec3f(unconst_f32(0.01142), unconst_f32(0.2191), unconst_f32(0.1261e-12)), vec3i(i32((*a0).f16[unconst_u32(210741102)])));
  let ptr30: ptr<function, vec4f> = &(*a0).f16;
  vf64 = vp44.f16.bra;
  return;
}

struct FragmentOutput5 {
  @location(0) @interpolate(flat, center) f0: vec4i,
  @location(1) @interpolate(flat) f1: i32,
}

struct T6 {
  f0: T2,
}

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

/* zero global variables used */
fn fn0(a0: sampler) -> T6 {
  var out: T6;
  let ptr26: ptr<private, vec4f> = &vp44.f16;
  vp44 = VertexOutput4(cross(vec3f(unconst_f32(0.05342), unconst_f32(-0.1418e35), unconst_f32(0.04845)), vec3f(unconst_f32(0.2490), unconst_f32(0.05899), unconst_f32(0.2085))).yxxy);
  vp44.f16 += cos(vec4f(unconst_f32(0.1024), unconst_f32(-0.03223), unconst_f32(0.00710e32), unconst_f32(0.07154e-30)));
  out = T6(T2(bool(dot(vec2f(unconst_f32(0.01788e9), unconst_f32(0.3567e-4)), vec2f(unconst_f32(0.1506), unconst_f32(0.04124))))));
  return out;
}

/* zero global variables used */
fn fn2() {
  loop {
  vp44.f16 = unpack4x8snorm(pack2x16float(vec2f(unconst_f32(0.1306), unconst_f32(0.3325))));
  break;
}
}

struct VertexOutput5 {
  @location(2) @interpolate(linear) f17: f16,
  @location(0) @interpolate(flat, center) f18: vec4h,
  @builtin(position) f19: vec4f,
  @location(13) f20: f16,
}

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

var<private> vp44: VertexOutput4 = VertexOutput4(vec4f(0.1869, 0.06844e-10, -0.3691, 0.4662));

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

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

/* used global variables: sam3 */
fn fn5(a0: i32, a1: texture_external) {
  let vf65: bool = (bool(ldexp(vec2f(unconst_f32(0.4634), unconst_f32(-0.2021e29)), vec2i(unconst_i32(86432995), unconst_i32(326577167)))[1]) || unconst_bool(false));
  var vf66 = fn0(sam3);
  vf66 = T6(T2(vf66.f0.f0));
  vp44.f16 = vec4f(vec4f(unconst_f32(0.1079e-10), unconst_f32(-0.1648e-32), unconst_f32(0.04540e-29), unconst_f32(0.1853e25)));
  _ = sam3;
}

/* zero global variables used */
fn fn1(a0: ptr<function, array<T6, 1>>) {
  if (*a0)[0].f0.f0 {
  let ptr27: ptr<private, VertexOutput4> = &vp44;
  var vf59: vec2h = asin(vec2h(unconst_f16(8375.3), unconst_f16(12729.1)));
  (*a0)[unconst_u32(299549693)].f0.f0 = (*a0)[0].f0.f0;
  switch bitcast<vec2i>(tan(vp44.f16.wy).gr).y { 
  default {
  (*a0)[u32((unconst_f32(0.2478) >= unconst_f32(0.03748)))].f0.f0 = bool(ceil(vec2h(unconst_f16(1713.8), unconst_f16(384.0))).r);
  break;
}
  }
  (*a0)[u32((*a0)[0].f0.f0)].f0.f0 = (*a0)[unconst_u32(706382727)].f0.f0;
  loop {
  break;
}
}
  (*a0)[unconst_u32(686675033)] = T6(T2((*a0)[vec3u(reflect(vec3h(f16((*a0)[0].f0.f0)), vec3h(unconst_f16(11031.8), unconst_f16(2129.5), unconst_f16(11634.0)))).z].f0.f0));
  (*a0)[unconst_u32(4498505)].f0.f0 = (*a0)[unconst_u32(123757026)].f0.f0;
  let ptr28: ptr<private, vec4f> = &vp44.f16;
  return;
}

/* zero global variables used */
@must_use 
fn fn3() -> VertexOutput5 {
  var out: VertexOutput5;
  out.f18 += vec4h(extractBits(vec3i(unconst_i32(298896626), unconst_i32(77477643), unconst_i32(684419685)), unconst_u32(53355795), unconst_u32(142490)).brgg.zxxx);
  out.f18 = vec4h(f16(pack4xU8(vec4u(unconst_u32(567367896), unconst_u32(416727190), unconst_u32(584561623), unconst_u32(439084716)))));
  return out;
}

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

struct T3 {
  @size(1024) f0: T2,
}

struct T4 {
  @size(32) f0: T0,
}

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

struct T1 {
  @align(32) @size(224) f0: array<u32>,
}

@group(0) @binding(197) var sam3: sampler;

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

struct T5 {
  @align(32) @size(480) f0: atomic<u32>,
  @size(960) f1: array<atomic<u32>>,
}

/* used global variables: et3, sam3 */
@vertex
fn vertex5(@location(10) @interpolate(linear) a0: f32) -> VertexOutput4 {
  var out: VertexOutput4;
  _ = et3;
  out.f16 = bitcast<vec4f>(textureDimensions(et3).xyyx.abrg);
  out.f16 -= vec4f(floor(unconst_f32(0.1723e-6)));
  if bool(textureDimensions(et3)[1]) {
  out.f16 = textureSampleBaseClampToEdge(et3, sam3, vec2f(unconst_f32(0.5929), unconst_f32(0.4741e-9)));
  _ = sam3;
  _ = et3;
}
  return out;
  _ = sam3;
  _ = et3;
}

/* used global variables: sam3 */
@vertex
fn vertex6(@location(6) @interpolate(flat) a0: f32, @location(3) @interpolate(flat, first) a1: i32) -> VertexOutput5 {
  var out: VertexOutput5;
  out.f17 = vec4h((vec4h(unconst_f16(5401.4), unconst_f16(-4965.5), unconst_f16(42822.3), unconst_f16(30605.3)) <= vec4h(unconst_f16(47590.3), unconst_f16(9403.1), unconst_f16(32559.7), unconst_f16(12896.6))))[0];
  out.f18 += vec4h(vp44.f16);
  loop {
  fn2();
  out.f20 -= f16(a1);
  var vf67: i32 = a1;
  _ = sam3;
  vp44.f16 = vec4f(vp44.f16[unconst_u32(610058886)]);
  while bool(determinant(mat4x4f(unconst_f32(0.1148), unconst_f32(0.1394), unconst_f32(0.5940e25), unconst_f32(0.2874e7), unconst_f32(0.1939), unconst_f32(0.00395e9), unconst_f32(0.01448e20), unconst_f32(0.1458e5), unconst_f32(0.3372), unconst_f32(0.05623e-13), unconst_f32(0.1517), unconst_f32(0.07800), unconst_f32(0.04532e31), unconst_f32(0.06392e-24), unconst_f32(0.1679e-17), unconst_f32(0.05585)))) {
  out.f20 -= degrees(vec2h(unpack4xI8(unconst_u32(20510265)).gb.gr)).x;
  let vf68: i32 = a1;
  var vf69: vec4<bool> = (vec4f(unconst_f32(0.09749e-43), unconst_f32(0.1583e-12), unconst_f32(0.2147), unconst_f32(0.2769e-27)) >= vec4f(unconst_f32(0.1423), unconst_f32(-0.3294), unconst_f32(0.1630), unconst_f32(0.3369e-8)));
  out.f20 = vec4h(vp44.f16).z;
  break;
}
  break;
  _ = sam3;
}
  vp44.f16 *= vec4f(bitcast<f32>(a1));
  out.f18 = vec4h(atan(vec4f(unconst_f32(0.00227e-34), unconst_f32(0.1447), unconst_f32(0.5177e-10), unconst_f32(0.1118e-37))));
  return out;
  _ = sam3;
}

/* zero global variables used */
@fragment
fn fragment5() -> FragmentOutput5 {
  var out: FragmentOutput5;
  vp44.f16 = unpack2x16unorm(unconst_u32(3131257159)).yyyy;
  out.f0 = vec4i(step(vec4h(unconst_f16(6382.6), unconst_f16(5581.6), unconst_f16(5768.0), unconst_f16(10510.2)), vec4h(unconst_f16(3406.6), unconst_f16(33757.1), unconst_f16(10010.8), unconst_f16(-1546.2))).zxyz.bbbg);
  return out;
}

/* used global variables: et3, sam3 */
@compute @workgroup_size(2, 1, 1)
fn compute7() {
  vp44.f16 = textureSampleBaseClampToEdge(et3, sam3, vec2f(unconst_f32(-0.5830e35), unconst_f32(0.05548e17)));
  var vf70 = fn3();
  vp44 = VertexOutput4(vec4f(f32(insertBits(vec4i(sin(vec4h(unconst_f16(6176.8), unconst_f16(6724.3), unconst_f16(-32171.1), unconst_f16(14347.3))))[0], unconst_i32(35252492), unconst_u32(141392331), unconst_u32(169012482)))));
  vp44.f16 += vec4f(vf70.f18.wwyy);
  _ = fn3();
  _ = sam3;
  _ = et3;
}`,
});
let buffer80 = device0.createBuffer({
  size: 36,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder124 = device0.createCommandEncoder({label: '\u{1fe39}\u{1fe62}\u{1fbc1}\u7ccb\u7ace\u0ba5\u01d1\u2f2c\u954f'});
let texture127 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 8},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView124 = texture45.createView({mipLevelCount: 1});
let computePassEncoder106 = commandEncoder124.beginComputePass();
try {
computePassEncoder84.setBindGroup(2, bindGroup41, []);
} catch {}
try {
computePassEncoder63.setBindGroup(3, bindGroup16, new Uint32Array(983), 95, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup6, new Uint32Array(1497), 113, 0);
} catch {}
try {
renderPassEncoder1.drawIndexed(0, 0, 1, -1_771_456_001);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer68, 4);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let textureView125 = texture111.createView({format: 'rgba8sint'});
let renderPassEncoder36 = commandEncoder45.beginRenderPass({
  colorAttachments: [{
  view: textureView22,
  clearValue: { r: 646.7, g: 651.2, b: 138.2, a: -784.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet3,
});
let sampler78 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  lodMaxClamp: 98.98,
});
try {
computePassEncoder97.setBindGroup(0, bindGroup22);
} catch {}
try {
computePassEncoder88.setBindGroup(1, bindGroup59, new Uint32Array(1433), 227, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder100.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup42);
} catch {}
try {
renderPassEncoder28.executeBundles([renderBundle9, renderBundle13]);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer78, 'uint32', 96, 11);
} catch {}
let bindGroup60 = device0.createBindGroup({layout: autogeneratedBindGroupLayout3, entries: [{binding: 762, resource: {buffer: buffer63}}]});
let commandEncoder125 = device0.createCommandEncoder({});
let texture128 = device0.createTexture({
  size: {width: 127, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8sint'],
});
try {
computePassEncoder66.setBindGroup(1, bindGroup44);
} catch {}
try {
computePassEncoder28.setBindGroup(0, bindGroup46, new Uint32Array(2137), 988, 0);
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup60);
} catch {}
try {
renderPassEncoder1.drawIndexed(0, 0, 0, -2_038_380_857);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer68, 8);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer53, 16);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView126 = texture85.createView({arrayLayerCount: 1});
let texture129 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 57},
  mipLevelCount: 4,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder52.setBindGroup(3, bindGroup14);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder76); computePassEncoder76.dispatchWorkgroupsIndirect(buffer64, 16); };
} catch {}
try {
computePassEncoder96.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder36.setStencilReference(472);
} catch {}
try {
renderPassEncoder1.draw(76, 0, 201_513_900, 0);
} catch {}
let computePassEncoder107 = commandEncoder125.beginComputePass();
let sampler79 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 44.15,
  lodMaxClamp: 66.33,
});
try {
computePassEncoder68.setBindGroup(1, bindGroup5, new Uint32Array(640), 33, 0);
} catch {}
try {
computePassEncoder22.end();
} catch {}
try {
computePassEncoder106.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle13, renderBundle13]);
} catch {}
try {
renderPassEncoder36.setViewport(34.1476830094679, 9.61206710620121, 27.840980387358826, 46.14948483074534, 0.5750981141294669, 0.8433552867987159);
} catch {}
try {
renderPassEncoder1.draw(71, 0, 578_409_453);
} catch {}
try {
renderPassEncoder1.drawIndexed(0, 0, 1, 346_233_205);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer53, 8);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder20.copyBufferToTexture({
  /* bytesInLastRow: 58 widthInBlocks: 29 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1312 */
  offset: 1312,
  rowsPerImage: 1216,
  buffer: buffer16,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
}, {width: 29, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder37.insertDebugMarker('\u0b13');
} catch {}
let bindGroup61 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 762, resource: {buffer: buffer21, size: 40}}],
});
let commandEncoder126 = device0.createCommandEncoder({});
let texture130 = gpuCanvasContext2.getCurrentTexture();
let textureView127 = texture35.createView({label: '\ucdb4\ua70e', dimension: '2d', baseArrayLayer: 1});
let computePassEncoder108 = commandEncoder20.beginComputePass();
let renderPassEncoder37 = commandEncoder126.beginRenderPass({
  colorAttachments: [{
  view: textureView81,
  depthSlice: 130,
  clearValue: { r: 299.2, g: 249.8, b: 648.3, a: 706.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder107.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup17, new Uint32Array(4253), 977, 0);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer64, 196);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer55, 'uint32', 68, 0);
} catch {}
let buffer81 = device0.createBuffer({size: 892, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder127 = device0.createCommandEncoder({});
let texture131 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 209},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder40.setBindGroup(0, bindGroup34);
} catch {}
try {
computePassEncoder105.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup9, new Uint32Array(2845), 763, 0);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer1, 20);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer54, 'uint32', 0, 4);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(3, buffer70, 0, 9);
} catch {}
try {
commandEncoder127.copyTextureToTexture({
  texture: texture101,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 26},
  aspect: 'all',
},
{
  texture: texture89,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
},
{width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline13 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule1, entryPoint: 'compute2', constants: {}}});
let computePassEncoder109 = commandEncoder127.beginComputePass();
let sampler80 = device0.createSampler({
  label: '\u8624\u2c6b\u0f37\u94aa\u0faf\u0b19\uad38\u0d39\ue986',
  addressModeV: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 45.15,
  lodMaxClamp: 70.00,
});
try {
computePassEncoder74.setBindGroup(0, bindGroup29);
} catch {}
try {
computePassEncoder107.setBindGroup(1, bindGroup58, new Uint32Array(192), 96, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup57);
} catch {}
try {
renderPassEncoder1.end();
} catch {}
try {
renderPassEncoder20.setVertexBuffer(6, buffer17, 0, 84);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture87,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 8},
  aspect: 'all',
}, new Uint8Array(2_832).fill(106), /* required buffer size: 2_832 */
{offset: 192, bytesPerRow: 132, rowsPerImage: 20}, {width: 19, height: 0, depthOrArrayLayers: 2});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 23, y: 0 },
  flipY: false,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder128 = device0.createCommandEncoder({});
let texture132 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder38 = commandEncoder28.beginRenderPass({
  colorAttachments: [{
  view: textureView39,
  depthSlice: 6,
  clearValue: { r: -150.8, g: 895.2, b: 477.6, a: 14.34, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 793518862,
});
try {
computePassEncoder19.setBindGroup(3, bindGroup41);
} catch {}
try {
computePassEncoder63.setBindGroup(3, bindGroup13, new Uint32Array(2355), 346, 0);
} catch {}
try {
computePassEncoder79.end();
} catch {}
try {
computePassEncoder109.setPipeline(pipeline8);
} catch {}
try {
commandEncoder128.copyTextureToBuffer({
  texture: texture124,
  mipLevel: 0,
  origin: {x: 195, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 44 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1676 */
  offset: 1676,
  bytesPerRow: 16640,
  buffer: buffer16,
}, {width: 22, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise12;
} catch {}
let imageData15 = new ImageData(204, 12);
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let commandEncoder129 = device0.createCommandEncoder({});
try {
computePassEncoder18.setBindGroup(0, bindGroup35);
} catch {}
try {
computePassEncoder108.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder34.setBindGroup(1, bindGroup12);
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup44, new Uint32Array(775), 54, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, undefined, 2_144_830_642, 77_044_192);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture133 = device0.createTexture({
  size: {width: 510, height: 1, depthOrArrayLayers: 379},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView128 = texture25.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 8});
let renderPassEncoder39 = commandEncoder98.beginRenderPass({
  colorAttachments: [{
  view: textureView115,
  depthSlice: 216,
  clearValue: { r: 104.5, g: -112.4, b: 967.8, a: 106.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder14.setBindGroup(1, bindGroup15);
} catch {}
try {
computePassEncoder4.setBindGroup(0, bindGroup24, new Uint32Array(368), 162, 0);
} catch {}
try {
computePassEncoder76.end();
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(44);
} catch {}
try {
renderPassEncoder36.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder33.setPipeline(pipeline9);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  alphaMode: 'opaque',
});
} catch {}
let promise20 = device0.queue.onSubmittedWorkDone();
let bindGroup62 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 762, resource: {buffer: buffer2}}]});
let sampler81 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
renderPassEncoder26.setBindGroup(0, bindGroup42);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder19.setScissorRect(4, 3, 47, 31);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let bindGroup63 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture6}, {binding: 197, resource: sampler58}],
});
let sampler82 = device0.createSampler({
  addressModeU: 'repeat',
  mipmapFilter: 'linear',
  lodMinClamp: 20.98,
  compare: 'greater',
  maxAnisotropy: 1,
});
try {
renderPassEncoder19.setVertexBuffer(1, buffer74, 0, 10);
} catch {}
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'pq'} });
let commandEncoder130 = device0.createCommandEncoder({});
let computePassEncoder110 = commandEncoder96.beginComputePass();
try {
computePassEncoder110.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer20, 'uint32', 8, 4);
} catch {}
try {
commandEncoder129.copyBufferToBuffer(buffer73, 4, buffer13, 520, 4);
} catch {}
try {
commandEncoder128.clearBuffer(buffer48);
} catch {}
try {
computePassEncoder74.insertDebugMarker('\u05ef');
} catch {}
let computePassEncoder111 = commandEncoder129.beginComputePass();
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
renderPassEncoder38.setBindGroup(0, bindGroup8, new Uint32Array(857), 67, 0);
} catch {}
try {
renderPassEncoder28.executeBundles([renderBundle9]);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer55, 'uint16', 46, 15);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline9);
} catch {}
try {
  await buffer58.mapAsync(GPUMapMode.READ);
} catch {}
try {
  await promise15;
} catch {}
let textureView129 = texture122.createView({dimension: 'cube-array', arrayLayerCount: 6});
try {
renderPassEncoder16.setBlendConstant({ r: 115.8, g: 281.9, b: -777.5, a: 807.9, });
} catch {}
try {
  await promise16;
} catch {}
let recycledExplicitBindGroupLayout9 = pipeline13.getBindGroupLayout(0);
let bindGroup64 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [{binding: 1, resource: externalTexture8}, {binding: 197, resource: sampler60}],
});
let buffer82 = device0.createBuffer({size: 640, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let renderPassEncoder40 = commandEncoder128.beginRenderPass({
  colorAttachments: [{
  view: textureView122,
  clearValue: { r: 438.6, g: 727.7, b: 772.2, a: 325.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
{ clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroupsIndirect(buffer68, 0); };
} catch {}
try {
computePassEncoder111.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(43);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer76, 'uint16', 4, 45);
} catch {}
try {
commandEncoder130.copyBufferToTexture({
  /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 248 */
  offset: 248,
  bytesPerRow: 51712,
  rowsPerImage: 324,
  buffer: buffer42,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 5},
  aspect: 'all',
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture5.label = '\ud539\u602a\u0ee0\u{1fbdd}\u0428\u01e7\ua135\u33b4\u{1fa49}';
} catch {}
let commandEncoder131 = device0.createCommandEncoder({});
try {
renderPassEncoder30.setBindGroup(3, bindGroup57, new Uint32Array(1810), 34, 0);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(3, buffer6, 0, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer68, 12, new Uint32Array(110), 34, 0);
} catch {}
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {binding: 5, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let buffer83 = device0.createBuffer({size: 280, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let commandEncoder132 = device0.createCommandEncoder({});
let textureView130 = texture85.createView({dimension: 'cube', mipLevelCount: 1});
let renderPassEncoder41 = commandEncoder132.beginRenderPass({
  colorAttachments: [{view: textureView117, depthSlice: 328, loadOp: 'clear', storeOp: 'store'}],
  maxDrawCount: 24680718,
});
try {
renderPassEncoder38.setBindGroup(0, bindGroup50);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(7, buffer3, 0, 10);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline5);
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT, colorSpace: 'srgb'});
} catch {}
try {
computePassEncoder109.setBindGroup(2, bindGroup36, new Uint32Array(374), 0, 0);
} catch {}
try {
renderPassEncoder37.setBindGroup(3, bindGroup25);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup58, new Uint32Array(1583), 515, 0);
} catch {}
try {
commandEncoder131.copyBufferToBuffer(buffer44, 36, buffer32, 0, 8);
} catch {}
try {
commandEncoder131.copyBufferToTexture({
  /* bytesInLastRow: 36 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1066 */
  offset: 1066,
  rowsPerImage: 43,
  buffer: buffer16,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 35, y: 0, z: 0},
  aspect: 'all',
}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder133 = device0.createCommandEncoder();
let renderPassEncoder42 = commandEncoder130.beginRenderPass({
  colorAttachments: [{
  view: textureView115,
  depthSlice: 966,
  clearValue: { r: 926.8, g: 782.6, b: -299.5, a: -714.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder42.setBindGroup(1, bindGroup8, []);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer56, 'uint32', 48, 66);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup33, new Uint32Array(4879), 288, 0);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline9);
} catch {}
try {
commandEncoder131.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 380 */
  offset: 380,
  bytesPerRow: 54528,
  buffer: buffer18,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 2},
  aspect: 'all',
}, {width: 40, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 2, y: 9, z: 33},
  aspect: 'all',
}, new Uint8Array(125_191).fill(146), /* required buffer size: 125_191 */
{offset: 117, bytesPerRow: 110, rowsPerImage: 20}, {width: 1, height: 18, depthOrArrayLayers: 57});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise13;
} catch {}
let commandEncoder134 = device0.createCommandEncoder({});
let computePassEncoder112 = commandEncoder134.beginComputePass();
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true, stencilReadOnly: false});
try {
computePassEncoder18.setBindGroup(1, bindGroup0, new Uint32Array(237), 25, 0);
} catch {}
try {
computePassEncoder112.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(7, buffer6, 4);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup25);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer16, 'uint16', 7_518, 918);
} catch {}
try {
commandEncoder131.copyTextureToTexture({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture47,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
let buffer84 = device0.createBuffer({size: 432, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder135 = device0.createCommandEncoder({});
let texture134 = device0.createTexture({
  label: '\u641e\u7285\u{1f606}\ub0a5\ubc9d',
  size: {width: 63, height: 1, depthOrArrayLayers: 3},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView131 = texture61.createView({baseArrayLayer: 4, arrayLayerCount: 2});
let renderPassEncoder43 = commandEncoder135.beginRenderPass({
  colorAttachments: [{
  view: textureView124,
  depthSlice: 138,
  clearValue: { r: -671.8, g: 924.6, b: -82.22, a: -955.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 41911893,
});
let sampler83 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', minFilter: 'linear', mipmapFilter: 'linear'});
let externalTexture11 = device0.importExternalTexture({source: videoFrame12});
try {
{ clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroupsIndirect(buffer49, 36); };
} catch {}
try {
computePassEncoder29.end();
} catch {}
try {
renderPassEncoder41.setVertexBuffer(2, buffer36, 36);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer3, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder31.copyBufferToTexture({
  /* bytesInLastRow: 38 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1754 */
  offset: 1754,
  bytesPerRow: 6144,
  buffer: buffer16,
}, {
  texture: texture19,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(150); };
} catch {}
let commandEncoder136 = device0.createCommandEncoder({});
let querySet20 = device0.createQuerySet({type: 'occlusion', count: 1794});
let computePassEncoder113 = commandEncoder31.beginComputePass();
try {
computePassEncoder75.setBindGroup(1, bindGroup48);
} catch {}
try {
computePassEncoder1.setBindGroup(3, bindGroup50, new Uint32Array(638), 133, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline5);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder131.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 12 */
  offset: 12,
  bytesPerRow: 2816,
  buffer: buffer23,
}, {
  texture: texture94,
  mipLevel: 1,
  origin: {x: 11, y: 0, z: 112},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture135 = device0.createTexture({
  label: '\u{1fe17}\u68c7',
  size: {width: 64, height: 64, depthOrArrayLayers: 12},
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder114 = commandEncoder133.beginComputePass();
let sampler84 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 97.13,
});
try {
computePassEncoder113.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup54, new Uint32Array(2445), 204, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 127, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 2 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup45);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer36, 'uint32', 4, 72);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer17, 24);
} catch {}
let buffer85 = device0.createBuffer({size: 228, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder137 = device0.createCommandEncoder({label: '\uaea5\u2674\u3f2a\u{1fcee}\uc4c0'});
let textureView132 = texture85.createView({dimension: 'cube'});
let texture136 = device0.createTexture({
  size: {width: 63, height: 1, depthOrArrayLayers: 1},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder115 = commandEncoder137.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroupsIndirect(buffer23, 4); };
} catch {}
try {
renderPassEncoder28.executeBundles([renderBundle9]);
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup54, new Uint32Array(431), 23, 0);
} catch {}
try {
renderBundleEncoder15.draw(255, 58, 525_805_478, 21_373_677);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(1, buffer74);
} catch {}
try {
commandEncoder131.copyTextureToBuffer({
  texture: texture125,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 348 */
  offset: 348,
  bytesPerRow: 21248,
  buffer: buffer10,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise20;
} catch {}
let textureView133 = texture69.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 6});
try {
computePassEncoder114.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup21, new Uint32Array(1595), 34, 0);
} catch {}
try {
renderPassEncoder12.setBlendConstant({ r: -875.9, g: -589.4, b: -250.8, a: -376.7, });
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer7, 'uint32', 20, 15);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer23, 'uint16', 14, 24);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
  await promise21;
} catch {}
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame5.close();
videoFrame7.close();
videoFrame10.close();
videoFrame11.close();
videoFrame13.close();
videoFrame14.close();
}

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

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