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

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

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

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

const videoUrls = [

];

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

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

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

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

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


async function window0() {
let adapter0 = await navigator.gpu.requestAdapter();
let device0 = await adapter0.requestDevice({
  defaultQueue: {},
  requiredFeatures: [
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'timestamp-query',
  ],
  requiredLimits: {
    maxVertexBufferArrayStride: 2048,
    maxTextureDimension2D: 8192,
    maxUniformBufferBindingSize: 57063186,
    maxStorageBufferBindingSize: 159775376,
  },
});
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 328,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let buffer0 = device0.createBuffer({
  size: 26970,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder0 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: [180, 80, 48],
  mipLevelCount: 1,
  format: 'astc-5x4-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture1 = device0.createTexture({
  size: {width: 90, height: 40, depthOrArrayLayers: 159},
  format: 'rg8snorm',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
device0.queue.writeBuffer(buffer0, 1348, new DataView(new ArrayBuffer(8271)), 2330, 848);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let buffer1 = device0.createBuffer({size: 1333, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder1 = device0.createCommandEncoder({});
let textureView0 = texture0.createView({dimension: '2d'});
let texture2 = device0.createTexture({
  size: {width: 180, height: 80, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'astc-4x4-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder0 = commandEncoder0.beginComputePass({});
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  label: '\u7c78\u29ff\u628c\u0119\uac6c\ucf97',
  entries: [
    {
      binding: 328,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let bindGroup0 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView0}]});
let texture3 = device0.createTexture({
  size: {width: 90, height: 1, depthOrArrayLayers: 1},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView1 = texture3.createView({dimension: '2d-array', baseArrayLayer: 0});
let computePassEncoder1 = commandEncoder1.beginComputePass({});
let sampler0 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 74.89});
try {
computePassEncoder0.setBindGroup(1, bindGroup0, new Uint32Array(133), 11, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let buffer2 = device0.createBuffer({size: 7296, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let textureView2 = texture2.createView({aspect: 'all', mipLevelCount: 1});
try {
device0.queue.writeBuffer(buffer0, 8128, new BigUint64Array(1036), 272, 8);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup1 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView0}]});
let commandEncoder2 = device0.createCommandEncoder({});
let computePassEncoder2 = commandEncoder2.beginComputePass();
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], depthReadOnly: true, stencilReadOnly: false});
let renderBundle0 = renderBundleEncoder0.finish({});
let imageData0 = new ImageData(16, 4);
let commandEncoder3 = device0.createCommandEncoder({});
let texture4 = device0.createTexture({
  size: {width: 180},
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView3 = texture4.createView({baseArrayLayer: 0});
let computePassEncoder3 = commandEncoder3.beginComputePass();
try {
computePassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [{binding: 8, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}],
});
let buffer3 = device0.createBuffer({size: 28776, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder4 = device0.createCommandEncoder();
let computePassEncoder4 = commandEncoder4.beginComputePass();
try {
computePassEncoder4.setBindGroup(2, bindGroup0);
} catch {}
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [{binding: 8, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}],
});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]});
let buffer4 = device0.createBuffer({size: 3459, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder5 = device0.createCommandEncoder({});
let sampler1 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 70.60,
  lodMaxClamp: 86.28,
  maxAnisotropy: 8,
});
try {
device0.queue.writeBuffer(buffer4, 696, new DataView(new ArrayBuffer(28614)), 2107, 84);
} catch {}
let textureView4 = texture0.createView({baseArrayLayer: 2, arrayLayerCount: 9});
let computePassEncoder5 = commandEncoder5.beginComputePass({});
let commandEncoder6 = device0.createCommandEncoder({});
let texture5 = device0.createTexture({
  size: [180, 80, 43],
  mipLevelCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture6 = device0.createTexture({
  size: [90],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView5 = texture4.createView({baseMipLevel: 0});
try {
computePassEncoder5.setBindGroup(1, bindGroup0, new Uint32Array(1484), 89, 0);
} catch {}
let buffer5 = device0.createBuffer({size: 17138, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let computePassEncoder6 = commandEncoder6.beginComputePass();
try {
computePassEncoder2.setBindGroup(3, bindGroup1);
} catch {}
try {
computePassEncoder5.setBindGroup(1, bindGroup0, new Uint32Array(559), 133, 0);
} catch {}
let bindGroup2 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 328, resource: textureView0}]});
try {
buffer5.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData0,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let canvas0 = document.createElement('canvas');
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]});
try {
computePassEncoder5.setBindGroup(3, bindGroup0, new Uint32Array(230), 11, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 5, y: 4, z: 20},
  aspect: 'all',
}, new Uint8Array(345).fill(229), /* required buffer size: 345 */
{offset: 345, bytesPerRow: 80}, {width: 15, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder3.setBindGroup(0, bindGroup2, new Uint32Array(1659), 423, 0);
} catch {}
let commandEncoder7 = device0.createCommandEncoder();
let computePassEncoder7 = commandEncoder7.beginComputePass({});
try {
canvas0.getContext('bitmaprenderer');
} catch {}
let commandEncoder8 = device0.createCommandEncoder();
let texture7 = device0.createTexture({
  size: [517, 30, 11],
  mipLevelCount: 4,
  format: 'depth24plus',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler2 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 89.97});
try {
computePassEncoder2.setBindGroup(3, bindGroup2, new Uint32Array(301), 26, 0);
} catch {}
try {
commandEncoder8.insertDebugMarker('\u21ca');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 150, y: 27, z: 14},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder9 = device0.createCommandEncoder();
let texture8 = device0.createTexture({
  size: {width: 180},
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setBindGroup(0, bindGroup2, new Uint32Array(86), 1, 0);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
buffer5.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 8},
  aspect: 'all',
}, new Uint8Array(39).fill(181), /* required buffer size: 39 */
{offset: 39, bytesPerRow: 51}, {width: 10, height: 0, depthOrArrayLayers: 1});
} catch {}
let textureView6 = texture8.createView({});
try {
commandEncoder8.copyBufferToBuffer(buffer2, 492, buffer4, 2024, 128);
} catch {}
document.body.prepend(canvas0);
let bindGroup3 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView0}]});
let commandEncoder10 = device0.createCommandEncoder({});
let textureView7 = texture7.createView({dimension: '2d', mipLevelCount: 1, arrayLayerCount: 1});
let textureView8 = texture3.createView({});
let computePassEncoder8 = commandEncoder10.beginComputePass({});
try {
computePassEncoder8.setBindGroup(3, bindGroup3, new Uint32Array(4179), 794, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas0);
await gc();
let commandEncoder11 = device0.createCommandEncoder({});
let textureView9 = texture7.createView({dimension: '2d', mipLevelCount: 1});
let sampler3 = device0.createSampler({addressModeW: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 97.44});
try {
computePassEncoder6.setBindGroup(2, bindGroup3, new Uint32Array(483), 7, 0);
} catch {}
try {
commandEncoder8.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1072 */
  offset: 1072,
  buffer: buffer5,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 0, y: 16, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder8.copyTextureToBuffer({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 440 widthInBlocks: 55 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 144 */
  offset: 144,
  bytesPerRow: 33024,
  rowsPerImage: 379,
  buffer: buffer4,
}, {width: 55, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder12 = device0.createCommandEncoder();
try {
computePassEncoder8.setBindGroup(1, bindGroup3);
} catch {}
try {
computePassEncoder1.setBindGroup(2, bindGroup1, new Uint32Array(526), 46, 0);
} catch {}
let imageData1 = new ImageData(188, 68);
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 92});
let textureView10 = texture0.createView({baseArrayLayer: 1, arrayLayerCount: 3});
let computePassEncoder9 = commandEncoder12.beginComputePass({});
try {
commandEncoder11.copyBufferToTexture({
  /* bytesInLastRow: 176 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 192 */
  offset: 192,
  bytesPerRow: 2816,
  buffer: buffer1,
}, {
  texture: texture2,
  mipLevel: 0,
  origin: {x: 52, y: 0, z: 0},
  aspect: 'all',
}, {width: 44, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder9.copyTextureToBuffer({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 24 */
  offset: 24,
  buffer: buffer4,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
canvas0.width = 2411;
let commandEncoder13 = device0.createCommandEncoder({});
let querySet1 = device0.createQuerySet({type: 'timestamp', count: 836});
try {
commandEncoder8.resolveQuerySet(querySet0, 8, 1, buffer4, 0);
} catch {}
let buffer6 = device0.createBuffer({size: 14346, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let texture9 = device0.createTexture({
  size: [129, 7, 119],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder10 = commandEncoder9.beginComputePass({});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData1,
  origin: { x: 41, y: 4 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 10, y: 26, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 55, height: 20, depthOrArrayLayers: 0});
} catch {}
let commandEncoder14 = device0.createCommandEncoder({});
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder8.copyBufferToBuffer(buffer2, 236, buffer4, 1280, 608);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 1,
  origin: {x: 12, y: 12, z: 0},
  aspect: 'all',
}, new Uint8Array(157).fill(197), /* required buffer size: 157 */
{offset: 157, bytesPerRow: 159}, {width: 0, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder3.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder2.setBindGroup(3, bindGroup3, new Uint32Array(3646), 1_907, 0);
} catch {}
try {
commandEncoder8.copyBufferToTexture({
  /* bytesInLastRow: 136 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 744 */
  offset: 744,
  rowsPerImage: 290,
  buffer: buffer2,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 59, y: 0, z: 0},
  aspect: 'all',
}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer0, 1948, new Int16Array(12864), 8199, 672);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView11 = texture2.createView({dimension: '2d-array', mipLevelCount: 1});
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 1,
  origin: {x: 14, y: 0, z: 17},
  aspect: 'all',
}, new Uint8Array(189_288).fill(60), /* required buffer size: 189_288 */
{offset: 8, bytesPerRow: 130, rowsPerImage: 56}, {width: 3, height: 0, depthOrArrayLayers: 27});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup4 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 328, resource: textureView8}]});
let sampler4 = device0.createSampler({addressModeW: 'mirror-repeat', minFilter: 'linear', mipmapFilter: 'linear', lodMinClamp: 13.33});
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 168 */
  offset: 168,
  buffer: buffer1,
}, {
  texture: texture9,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 21},
  aspect: 'all',
}, {width: 10, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
computePassEncoder3.insertDebugMarker('\u58f2');
} catch {}
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'film', transfer: 'logSqrt'} });
let commandEncoder15 = device0.createCommandEncoder({});
let textureView12 = texture2.createView({dimension: '2d-array', mipLevelCount: 1});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
document.body.append(canvas0);
let textureView13 = texture6.createView({aspect: 'all'});
try {
commandEncoder15.copyBufferToBuffer(buffer1, 36, buffer0, 780, 4);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 8, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(101).fill(93), /* required buffer size: 101 */
{offset: 101, bytesPerRow: 184, rowsPerImage: 47}, {width: 28, height: 36, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
let texture10 = device0.createTexture({
  size: {width: 1035},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView14 = texture8.createView({arrayLayerCount: 1});
let computePassEncoder11 = commandEncoder13.beginComputePass({
  label: '\u3d81\u00ca\u014b\u{1fe96}\u{1fd47}\u3727\u318c\u0c69\u8d10',
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 409, endOfPassWriteIndex: 93},
});
try {
computePassEncoder5.setBindGroup(0, bindGroup3, new Uint32Array(359), 54, 0);
} catch {}
let commandEncoder16 = device0.createCommandEncoder({});
let textureView15 = texture3.createView({format: 'bgra8unorm'});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle1 = renderBundleEncoder1.finish({});
let sampler5 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'clamp-to-edge'});
try {
computePassEncoder3.setBindGroup(0, bindGroup1);
} catch {}
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt2020', transfer: 'bt2020_12bit'} });
let buffer7 = device0.createBuffer({
  size: 6203,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture11 = device0.createTexture({
  size: {width: 180, height: 80, depthOrArrayLayers: 1},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView16 = texture7.createView({aspect: 'depth-only', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 2});
try {
computePassEncoder6.setBindGroup(3, bindGroup2);
} catch {}
try {
commandEncoder11.clearBuffer(buffer0, 532, 2116);
} catch {}
try {
commandEncoder15.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3584 */
  offset: 3584,
  bytesPerRow: 19712,
  buffer: buffer0,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 16, y: 1, z: 0},
  aspect: 'all',
}, {width: 30, height: 35, depthOrArrayLayers: 0});
} catch {}
let buffer8 = device0.createBuffer({
  size: 5231,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder6.setBindGroup(2, bindGroup4);
} catch {}
try {
commandEncoder15.pushDebugGroup('\u91c2');
} catch {}
let textureView17 = texture6.createView({dimension: '1d'});
try {
commandEncoder8.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 120 */
  offset: 120,
  bytesPerRow: 5376,
  buffer: buffer5,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 9, y: 25, z: 0},
  aspect: 'all',
}, {width: 20, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(8).fill(81), /* required buffer size: 8 */
{offset: 8, rowsPerImage: 126}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let textureView18 = texture7.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder12 = commandEncoder14.beginComputePass({});
try {
computePassEncoder8.setBindGroup(1, bindGroup0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder11.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 4240 */
  offset: 4240,
  bytesPerRow: 11264,
  rowsPerImage: 439,
  buffer: buffer2,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 20, height: 32, depthOrArrayLayers: 0});
} catch {}
let textureView19 = texture9.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder13 = commandEncoder15.beginComputePass({});
let renderPassEncoder0 = commandEncoder17.beginRenderPass({
  colorAttachments: [{view: textureView19, depthSlice: 47, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet0,
});
let sampler6 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 9,
});
try {
renderPassEncoder0.beginOcclusionQuery(3);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder16.copyBufferToBuffer(buffer5, 16944, buffer4, 1064, 0);
} catch {}
try {
commandEncoder8.clearBuffer(buffer0, 3316, 14088);
} catch {}
let textureView20 = texture0.createView({
  label: '\u0eb4\u31da\u9ea1\u9493\u46d4\udfe3\u08b8\u{1f7e5}\u{1fd0f}',
  dimension: '2d',
  baseArrayLayer: 8,
});
let computePassEncoder14 = commandEncoder16.beginComputePass();
let renderPassEncoder1 = commandEncoder11.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  depthSlice: 36,
  clearValue: { r: -478.2, g: -662.5, b: 491.1, a: -999.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 21473266,
});
try {
computePassEncoder0.setBindGroup(1, bindGroup2, new Uint32Array(1236), 263, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle1]);
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 127,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup5 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView8}]});
let buffer9 = device0.createBuffer({
  size: 1541,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView21 = texture11.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let texture12 = device0.createTexture({
  size: {width: 180, height: 1, depthOrArrayLayers: 29},
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder15 = commandEncoder8.beginComputePass({});
try {
renderPassEncoder1.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder0.setViewport(128.28148493240144, 4.7174450023150065, 0.55746547722769, 1.5472050963999802, 0.32419838567581283, 0.658593400637254);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 62,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 254,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 2, hasDynamicOffset: false },
    },
    {
      binding: 578,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let buffer10 = device0.createBuffer({
  label: '\u0990\u0947\u0a13\udffb',
  size: 24145,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture13 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 17},
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView22 = texture5.createView({baseArrayLayer: 0, arrayLayerCount: 1});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], depthReadOnly: true});
try {
computePassEncoder8.setBindGroup(3, bindGroup3, []);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup4, new Uint32Array(3653), 166, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(868), 23, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
document.body.prepend(canvas0);
let bindGroup6 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 578, resource: {buffer: buffer8, offset: 0, size: 3920}},
    {binding: 62, resource: textureView7},
    {binding: 254, resource: {buffer: buffer7, offset: 256, size: 192}},
  ],
});
let buffer11 = device0.createBuffer({
  size: 13803,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture14 = device0.createTexture({
  size: {width: 180},
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler7 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMaxClamp: 94.31,
  compare: 'less',
});
try {
computePassEncoder14.setBindGroup(2, bindGroup3, new Uint32Array(159), 20, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer10, 2_576, 1_809);
} catch {}
let commandEncoder18 = device0.createCommandEncoder({});
let texture15 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 17},
  mipLevelCount: 3,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView23 = texture14.createView({});
let renderBundle2 = renderBundleEncoder2.finish({});
try {
renderPassEncoder1.setIndexBuffer(buffer9, 'uint16', 90, 4);
} catch {}
try {
commandEncoder18.resolveQuerySet(querySet0, 13, 1, buffer8, 0);
} catch {}
let buffer12 = device0.createBuffer({size: 2600, usage: GPUBufferUsage.COPY_DST});
let sampler8 = device0.createSampler({addressModeU: 'mirror-repeat', minFilter: 'linear', compare: 'always', maxAnisotropy: 1});
let texture16 = device0.createTexture({
  size: {width: 90},
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder16 = commandEncoder18.beginComputePass({});
try {
renderPassEncoder1.setBindGroup(2, bindGroup2, new Uint32Array(1870), 743, 0);
} catch {}
let texture17 = device0.createTexture({
  size: {width: 360, height: 1, depthOrArrayLayers: 412},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler9 = device0.createSampler({
  label: '\u024b\u08e4\u{1fbb0}\uafba\u21be\u006d\u08f6\u1bac',
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMaxClamp: 99.40,
});
try {
renderPassEncoder1.setBindGroup(2, bindGroup5, new Uint32Array(1743), 249, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

@group(0) @binding(254) var<storage, read> buffer13: array<T1, 1>;

@group(0) @binding(578) var<storage, read> buffer14: array<array<array<vec2f, 1>, 408>>;

struct FragmentOutput0 {
  @builtin(sample_mask) f0: u32,
  @location(0) f1: vec4u,
}

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

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

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

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

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

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

struct T2 {
  f0: T1,
}

alias vec3b = vec3<bool>;

/* used global variables: buffer14 */
fn fn0(a0: ptr<storage, VertexOutput0, read_write>, a1: T1) -> array<T0, 1> {
  var out: array<T0, 1>;
  let ptr0: ptr<private, f16> = &vp0.f0.f0[unconst_u32(32)].f0[unconst_u32(193)][unconst_u32(265)];
  var vf0: f16 = a1.f0[unconst_u32(83)].f0[unconst_u32(6)][0];
  var vf1: f32 = (*&buffer14)[unconst_u32(92)][unconst_u32(56)][unconst_u32(387)][unconst_u32(46)];
  let ptr1: ptr<private, array<f16, 1>> = &vp0.f0.f0[0].f0[unconst_u32(188)];
  let vf2: array<T0, 1> = a1.f0;
  vf0 -= vf2[unconst_u32(13)].f0[unconst_u32(135)][unconst_u32(364)];
  while bool(vp0.f0.f0[0].f0[0][0]) {
  var vf3: f32 = (*&buffer14)[arrayLength(&(*&buffer14))][407][unconst_u32(77)][unconst_u32(4)];
  let ptr2: ptr<storage, vec2f, read> = &buffer14[unconst_u32(109)][407][unconst_u32(56)];
  var vf4: vec4f = trunc(vec4f(unconst_f32(0.5814), unconst_f32(0.5536), unconst_f32(0.07831), unconst_f32(0.07599)));
  _ = buffer14;
}
  (*a0).f2 -= vec4f(transpose(mat3x2h(unconst_f16(-16281.7), unconst_f16(-167.0), unconst_f16(28430.1), unconst_f16(-19912.8), unconst_f16(37634.7), unconst_f16(19911.3)))[unconst_i32(0)].xxzy);
  let ptr3: ptr<storage, vec2f, read_write> = &(*a0).f0;
  let ptr4: ptr<storage, vec2f, read> = &buffer14[unconst_u32(379)][407][unconst_u32(398)];
  let vf5: vec2u = (vec2u(unconst_u32(183), unconst_u32(62)) << vec2u(unconst_u32(17), unconst_u32(67)));
  let ptr5: ptr<storage, vec2f, read> = &buffer14[arrayLength(&buffer14)][unconst_u32(438)][bitcast<u32>((*a0).f0[0])];
  return out;
  _ = buffer14;
}

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

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

struct VertexOutput0 {
  @location(11) f0: vec2f,
  @location(4) f1: vec2i,
  @invariant @builtin(position) f2: vec4f,
}

/* used global variables: buffer13 */
@vertex
fn vertex0(@location(12) a0: u32, @location(10) a1: vec2h, @location(1) @interpolate(flat, centroid) a2: vec4u, @location(14) @interpolate(flat, sample) a3: i32) -> @builtin(position) vec4f {
  var out: vec4f;
  vp0.f0 = T1(array<T0, 1>(T0(array<array<f16, 1>, 1>(array<f16, 1>((*&buffer13)[0].f0[0].f0[unconst_u32(628)][unconst_u32(267)])))));
  let ptr6: ptr<storage, f16, read> = &(*&buffer13)[0].f0[unconst_u32(162)].f0[0][0];
  let ptr7: ptr<storage, T0, read> = &buffer13[0].f0[0];
  return out;
  _ = buffer13;
}

/* used global variables: buffer13 */
@vertex
fn vertex1() -> VertexOutput0 {
  var out: VertexOutput0;
  let ptr8: ptr<storage, T0, read> = &(*&buffer13)[unconst_u32(3)].f0[u32((*&buffer13)[0].f0[0].f0[0][0])];
  return out;
  _ = buffer13;
}

/* used global variables: buffer14 */
@fragment
fn fragment0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  {
  let ptr9: ptr<private, f16> = &vp0.f0.f0[unconst_u32(232)].f0[unconst_u32(13)][0];
  out.f1 += vec4u(u32(buffer14[arrayLength(&buffer14)][407][0][unconst_u32(14)]));
  let ptr10: ptr<storage, array<array<vec2f, 1>, 408>, read> = &(*&buffer14)[arrayLength(&(*&buffer14)) - 1];
  out.f1 = vec4u(u32(vp0.f0.f0[unconst_u32(223)].f0[0][0]));
  _ = buffer14;
}
  let ptr11: ptr<storage, vec2f, read> = &buffer14[arrayLength(&buffer14)][407][unconst_u32(298)];
  return out;
  _ = buffer14;
}

/* used global variables: buffer14 */
@compute @workgroup_size(1, 1, 1)
fn compute0(@builtin(global_invocation_id) a0: vec3u, @builtin(local_invocation_id) a1: vec3u, @builtin(workgroup_id) a2: vec3u) {
  let ptr12: ptr<private, f16> = &vp0.f0.f0[unconst_u32(45)].f0[0][0];
  vp0 = T2(T1(array<T0, 1>(T0(array<array<f16, 1>, 1>(array<f16, 1>(vec2h((*&buffer14)[unconst_u32(36)][unconst_u32(122)][0]).x))))));
  {
}
  _ = buffer14;
}`,
});
let bindGroup7 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 328, resource: textureView0}]});
let commandEncoder19 = device0.createCommandEncoder({});
let texture18 = device0.createTexture({size: [180, 80, 1], format: 'astc-10x5-unorm-srgb', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView24 = texture6.createView({});
let computePassEncoder17 = commandEncoder19.beginComputePass({});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], stencilReadOnly: true});
let renderBundle3 = renderBundleEncoder3.finish();
try {
renderPassEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(342), 39, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer10, 'uint32', 1_580, 4_947);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 7160, new Int16Array(923), 81, 160);
} catch {}
let promise0 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}});
let bindGroup8 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView20}]});
try {
computePassEncoder4.setBindGroup(1, bindGroup8, new Uint32Array(361), 150, 0);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setViewport(119.04071851712945, 1.5459742370837843, 6.969392684679062, 2.2031063806166373, 0.44761016266913967, 0.805258928735308);
} catch {}
document.body.append(canvas0);
let buffer15 = device0.createBuffer({size: 5494, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let sampler10 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 44.43,
  compare: 'less-equal',
  maxAnisotropy: 3,
});
try {
renderPassEncoder0.setVertexBuffer(3, buffer7);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView25 = texture15.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 6});
try {
renderPassEncoder1.setBindGroup(2, bindGroup6);
} catch {}
try {
computePassEncoder9.setBindGroup(0, bindGroup8, new Uint32Array(382), 8, 0);
} catch {}
try {
buffer2.unmap();
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
let buffer16 = device0.createBuffer({
  size: 3595,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let sampler11 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
renderPassEncoder1.setViewport(18.789418973302613, 1.6565598645944744, 22.56230228472548, 4.033621627278273, 0.08648802565561342, 0.08775980884649563);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer9, 'uint16', 168, 1_199);
} catch {}
let commandEncoder20 = device0.createCommandEncoder({});
let texture19 = device0.createTexture({
  label: '\u0445\ube6d\u43a9\u3cac\ud974\u{1f9d1}\u3885\u0f2d\u0545',
  size: [180],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView26 = texture19.createView({dimension: '1d', format: 'rgba16uint'});
let renderPassEncoder2 = commandEncoder20.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  depthSlice: 78,
  clearValue: { r: 979.1, g: 272.3, b: -263.4, a: -114.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder1.executeBundles([renderBundle2, renderBundle1, renderBundle0]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(257).fill(71), /* required buffer size: 257 */
{offset: 257, rowsPerImage: 27}, {width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'linear'} });
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle2]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer10, 'uint16', 8_592, 6_788);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 13, y: 25, z: 6},
  aspect: 'all',
}, new Uint8Array(13_980).fill(92), /* required buffer size: 13_980 */
{offset: 299, bytesPerRow: 405, rowsPerImage: 3}, {width: 79, height: 1, depthOrArrayLayers: 12});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 16, y: 29, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

requires packed_4x8_integer_dot_product;

@group(0) @binding(578) var<storage, read> buffer18: array<array<array<i32, 24>, 34>>;

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

/* used global variables: buffer18 */
fn fn2() {
  fn0();
  let vf16: u32 = arrayLength(&buffer18);
  {
  let vf17: vec4i = unpack4xI8(unconst_u32(94));
}
  fn0();
  let ptr31: ptr<storage, array<i32, 24>, read> = &buffer18[unconst_u32(53)][33];
  let ptr32: ptr<storage, array<array<i32, 24>, 34>, read> = &(*&buffer18)[unconst_u32(33)];
  let ptr33: ptr<storage, array<i32, 24>, read> = &(*ptr32)[33];
  let ptr34: ptr<storage, i32, read> = &(*ptr32)[unconst_u32(700)][unconst_u32(175)];
  let ptr35: ptr<storage, array<i32, 24>, read> = &(*ptr31);
  _ = buffer18;
}

struct T1 {
  @align(32) @size(64) f0: vec4h,
  @size(64) f1: atomic<i32>,
  @align(8) @size(64) f2: atomic<u32>,
  @align(64) @size(3072) f3: array<array<T0, 1>>,
}

struct T2 {
  @size(216) f0: T0,
}

@group(0) @binding(254) var<storage, read> buffer17: f16;

/* used global variables: buffer18 */
fn fn1(a0: ptr<workgroup, T0>) -> f16 {
  var out: f16;
  loop {
  for (var it0=arrayLength(&(*&buffer18)); it0<pack4x8unorm(asinh(vec4f(unconst_f32(0.3749), unconst_f32(0.1052), unconst_f32(0.06603), unconst_f32(0.09956)))); it0++) {
  let vf11: vec2i = (vec2i(unconst_i32(71), unconst_i32(199)) / bitcast<vec2i>(min(vec2u(unconst_u32(281), unconst_u32(45)), vec2u(((vec2i(unconst_i32(45), unconst_i32(45)) / unconst_i32(-223)).rgg + unconst_i32(130)).br)))[0]);
  var vf12: bool = all(bool(exp2(bitcast<vec2h>(buffer18[unconst_u32(408)][33][23])).g));
  let ptr20: ptr<storage, i32, read> = &(*&buffer18)[unconst_u32(236)][33][23];
  let ptr21: ptr<storage, array<array<i32, 24>, 34>, read> = &(*&buffer18)[unconst_i32(14)];
  let ptr22: ptr<storage, i32, read> = &buffer18[unconst_u32(171)][unconst_u32(49)][unconst_u32(129)];
  break;
  _ = buffer18;
}
  let ptr23: ptr<storage, array<i32, 24>, read> = &buffer18[unconst_u32(363)][33];
  let ptr24: ptr<storage, array<i32, 24>, read> = &(*&buffer18)[arrayLength(&(*&buffer18))][unconst_u32(75)];
  break;
  _ = buffer18;
}
  {
  let ptr25: ptr<storage, i32, read> = &(*&buffer18)[arrayLength(&(*&buffer18))][unconst_u32(1000)][unconst_u32(265)];
  let ptr26: ptr<storage, array<i32, 24>, read> = &(*&buffer18)[arrayLength(&(*&buffer18))][33];
  switch (*&buffer18)[arrayLength(&(*&buffer18))][33][23] { 
  default {
  for (var it1=u32(buffer18[unconst_u32(104)][unconst_u32(80)][23]); it1<u32((*a0).f0); it1++) {
  let vf13: vec3h = sqrt(vec3h(unconst_f16(7662.5), unconst_f16(2408.4), unconst_f16(6098.0)));
  let ptr27: ptr<storage, array<array<i32, 24>, 34>, read> = &buffer18[arrayLength(&buffer18)];
  _ = buffer18;
}
  out += f16((unconst_f16(12409.0) != unconst_f16(275.7)));
  break;
  _ = buffer18;
}
  }
  _ = buffer18;
}
  (*a0).f0 += f16((*&buffer18)[unconst_u32(195)][unconst_u32(218)][23]);
  var vf14: bool = (unconst_bool(false) && unconst_bool(true));
  let vf15: vec2f = acosh(vec2f(unconst_f32(0.2151), unconst_f32(0.2704)));
  (*a0) = T0(f16(buffer18[unconst_u32(167)][unconst_u32(35)][23]));
  let ptr28: ptr<storage, i32, read> = &buffer18[unconst_u32(123)][33][unconst_u32(299)];
  let ptr29: ptr<storage, i32, read> = &buffer18[unconst_u32(231)][33][23];
  let ptr30: ptr<storage, i32, read> = &buffer18[unconst_u32(175)][unconst_u32(7)][unconst_u32(14)];
  return out;
  _ = buffer18;
}

var<workgroup> vw1: atomic<u32>;

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

@group(0) @binding(62) var tex1: texture_depth_2d;

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

/* used global variables: buffer18 */
fn fn3(a0: ptr<private, T0>, a1: ptr<function, f32>) -> VertexOutput1 {
  var out: VertexOutput1;
  let ptr36: ptr<storage, array<i32, 24>, read> = &buffer18[unconst_u32(75)][unconst_u32(92)];
  var vf18: vec4h = asinh(vec4h(countLeadingZeros(vec4i(unconst_i32(90), unconst_i32(413), unconst_i32(205), unconst_i32(43)))));
  out.f4 -= vec4f(bitcast<f32>((*&buffer18)[pack4x8snorm(vec4f(unconst_f32(0.00103), unconst_f32(0.1698), unconst_f32(0.02991), unconst_f32(0.00843)))][unconst_u32(1000)][23]));
  return out;
  _ = buffer18;
}

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

struct VertexOutput1 {
  @location(4) f3: vec2u,
  @builtin(position) f4: vec4f,
  @location(14) f5: vec2u,
}

/* used global variables: buffer18 */
fn fn0() {
  let ptr13: ptr<storage, array<i32, 24>, read> = &(*&buffer18)[unconst_u32(61)][33];
  while bool((*&buffer18)[arrayLength(&(*&buffer18))][unconst_u32(2)][unconst_u32(17)]) {
  let ptr14: ptr<storage, array<i32, 24>, read> = &buffer18[arrayLength(&buffer18)][33];
  let ptr15: ptr<storage, i32, read> = &buffer18[unconst_u32(164)][unconst_u32(280)][unconst_u32(57)];
  let ptr16: ptr<storage, i32, read> = &(*&buffer18)[unconst_u32(160)][unconst_u32(136)][23];
  let ptr17: ptr<storage, i32, read> = &(*&buffer18)[unconst_u32(72)][33][23];
  while bool((*&buffer18)[unconst_u32(14)][33][23]) {
  let vf6: vec3h = radians(vec3h(unconst_f16(5428.9), unconst_f16(1233.7), unconst_f16(1953.6)));
  let vf7: vec3f = log(vec3f(unconst_f32(0.09610), unconst_f32(0.1589), unconst_f32(0.1038)));
  break;
}
  _ = buffer18;
}
  let ptr18: ptr<storage, array<i32, 24>, read> = &buffer18[arrayLength(&buffer18)][33];
  let vf8: vec2f = degrees(vec2f(bitcast<f32>(buffer18[unconst_u32(498)][33][bitcast<u32>((*ptr13)[23])])));
  var vf9: vec2f = vf8;
  vf9 *= vec2f(f32(buffer18[unconst_u32(229)][unconst_u32(27)][23]));
  let ptr19: ptr<storage, i32, read> = &(*ptr18)[unconst_u32(58)];
  vf9 += vec2f(bitcast<f32>(buffer18[arrayLength(&buffer18)][33][23]));
  var vf10: vec3h = radians(vec3h(f16(buffer18[arrayLength(&buffer18)][33][unconst_u32(145)])));
  _ = buffer18;
}

var<workgroup> vw2: T0;

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

struct T0 {
  f0: f16,
}

var<workgroup> vw0: FragmentOutput1;

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

/* used global variables: buffer17, buffer18, tex1 */
@vertex
fn vertex2(@location(13) @interpolate(flat) a0: vec2f, @location(12) a1: vec4h) -> VertexOutput1 {
  var out: VertexOutput1;
  let ptr37: ptr<storage, f16, read> = &buffer17;
  out = VertexOutput1(vec2u(u32((*&buffer18)[arrayLength(&(*&buffer18))][33][23])), vec4f(f32((*&buffer18)[arrayLength(&(*&buffer18))][33][23])), vec2u(u32((*&buffer18)[arrayLength(&(*&buffer18))][33][23])));
  let vf19: u32 = pack2x16unorm(vec2f(unconst_f32(0.1074), unconst_f32(0.1803)));
  while bool(buffer18[arrayLength(&buffer18)][33][23]) {
  if bool(buffer18[arrayLength(&buffer18)][33][unconst_u32(70)]) {
  let ptr38: ptr<storage, i32, read> = &(*&buffer18)[arrayLength(&(*&buffer18))][unconst_u32(163)][unconst_u32(87)];
  let ptr39: ptr<storage, array<i32, 24>, read> = &buffer18[unconst_u32(28)][unconst_u32(268)];
  out.f3 = vec2u(u32((*&buffer18)[unconst_u32(345)][33][23]));
  out.f5 &= vec2u(bitcast<u32>(ceil(unconst_f32(0.2872))));
  _ = buffer18;
}
  out = VertexOutput1(vec2u(u32((*&buffer18)[arrayLength(&(*&buffer18))][33][23])), vec4f(bitcast<f32>((*&buffer18)[arrayLength(&(*&buffer18))][33][23])), vec2u(u32((*&buffer18)[arrayLength(&(*&buffer18))][33][23])));
  let ptr40: ptr<storage, array<array<array<i32, 24>, 34>>, read> = &(*&buffer18);
  out.f4 = vec4f(bitcast<f32>((*ptr40)[arrayLength(&(*ptr40))][33][unconst_u32(262)]));
  break;
  _ = buffer18;
}
  let ptr41: ptr<storage, f16, read> = &(*ptr37);
  out.f5 >>= vec2u(bitcast<u32>(step(unconst_f32(0.3321), unconst_f32(-0.01603))));
  var vf20: vec2u = textureDimensions(tex1);
  let vf21: vec2h = clamp(vec2h(unconst_f16(20226.7), unconst_f16(-2625.5)), vec2h(unconst_f16(2755.4), unconst_f16(23875.4)), bitcast<vec2h>((*&buffer18)[unconst_u32(33)][unconst_u32(370)][23]));
  vf20 |= vec2u(u32((*&buffer18)[unconst_u32(173)][unconst_u32(190)][23]));
  let ptr42: ptr<storage, array<i32, 24>, read> = &buffer18[arrayLength(&buffer18)][unconst_u32(460)];
  return out;
  _ = buffer17;
  _ = buffer18;
  _ = tex1;
}

/* used global variables: buffer18 */
@fragment
fn fragment1(@location(14) a0: vec2u, @location(4) @interpolate(flat, either) a1: vec2u) -> FragmentOutput1 {
  var out: FragmentOutput1;
  fn2();
  var vf22: vec4i = countLeadingZeros(vec4i(unconst_i32(67), unconst_i32(192), unconst_i32(27), unconst_i32(127)));
  out = FragmentOutput1(unpack4xU8(pack4xU8Clamp(vec4u(unconst_u32(136), unconst_u32(406), unconst_u32(101), unconst_u32(280)))), pack4xU8Clamp(vec4u(unconst_u32(136), unconst_u32(406), unconst_u32(101), unconst_u32(280))));
  out = FragmentOutput1(unpack4xU8(bitcast<u32>(vf22[unconst_u32(175)])), bitcast<u32>(vf22[unconst_u32(175)]));
  let ptr43: ptr<storage, i32, read> = &(*&buffer18)[unconst_u32(147)][unconst_u32(115)][23];
  return out;
  _ = buffer18;
}

/* used global variables: buffer18 */
@compute @workgroup_size(3, 1, 1)
fn compute1() {
  _ = fn1(&vw2);
  vw0.f1 &= pack4xU8Clamp((*&vw0).f0);
  var vf23 = fn1(&vw2);
  vf23 *= vec2h(quantizeToF16(vec2f(unconst_f32(-0.1672), unconst_f32(0.3891)))).y;
  let vf24: f32 = tanh(unconst_f32(0.1239));
  atomicMax(&vw1, unconst_u32(95));
  vw0 = FragmentOutput1(vec4u(u32(vw2.f0)), u32(vw2.f0));
  vw0 = FragmentOutput1(vec4u(quantizeToF16(vec2f(unconst_f32(0.07965), unconst_f32(0.07016))).rggg), u32(quantizeToF16(vec2f(unconst_f32(0.07965), unconst_f32(0.07016))).g));
  var vf25: bool = (unconst_u32(361) != unconst_u32(32));
  atomicAdd(&vw1, unconst_u32(188));
  let ptr44: ptr<workgroup, FragmentOutput1> = &vw0;
  _ = buffer18;
}`,
});
let commandEncoder21 = device0.createCommandEncoder();
let texture20 = device0.createTexture({
  size: {width: 180, height: 1, depthOrArrayLayers: 12},
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder16.setBindGroup(0, bindGroup8, new Uint32Array(4222), 720, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle1, renderBundle2, renderBundle1, renderBundle1, renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer0, 'uint16', 2_480, 5_005);
} catch {}
let promise2 = shaderModule0.getCompilationInfo();
try {
commandEncoder21.copyBufferToBuffer(buffer16, 8, buffer12, 172, 1464);
} catch {}
try {
commandEncoder21.copyBufferToTexture({
  /* bytesInLastRow: 152 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1808 */
  offset: 1808,
  buffer: buffer3,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder21.resolveQuerySet(querySet1, 150, 95, buffer15, 256);
} catch {}
let textureView27 = texture20.createView({baseArrayLayer: 0});
let computePassEncoder18 = commandEncoder21.beginComputePass({});
try {
computePassEncoder5.setBindGroup(3, bindGroup7, new Uint32Array(1647), 120, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle1]);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer0, 0, 2_194);
} catch {}
try {
computePassEncoder2.pushDebugGroup('\udbd0');
} catch {}
let commandEncoder22 = device0.createCommandEncoder({});
let textureView28 = texture4.createView({aspect: 'all'});
try {
buffer7.unmap();
} catch {}
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout5]});
let buffer19 = device0.createBuffer({
  size: 11635,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder23 = device0.createCommandEncoder({});
let computePassEncoder19 = commandEncoder22.beginComputePass({
  label: '\u0327\u65d5\u7b8f\ud13f\u9a13\u{1feb2}\uded9\u{1fbe4}\u1d3c\u0425\u0c83',
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 627},
});
let sampler12 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 99.72,
  maxAnisotropy: 1,
});
try {
renderPassEncoder1.setVertexBuffer(2, buffer10);
} catch {}
document.body.append(canvas0);
let shaderModule2 = device0.createShaderModule({
  code: `
requires packed_4x8_integer_dot_product;

diagnostic(info, xyz);

enable f16;

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

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

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

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

override override0: f32;

struct VertexOutput2 {
  @location(5) f6: vec4f,
  @builtin(position) f7: vec4f,
  @location(6) f8: vec4f,
  @location(15) f9: f16,
}

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

@group(0) @binding(578) var<storage, read> buffer21: array<array<array<array<f16, 34>, 1>, 16>, 3>;

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

@id(2536) override override2: u32 = 78;

override override1 = true;

struct FragmentOutput2 {
  @location(6) @interpolate(flat, center) f0: vec4u,
  @builtin(sample_mask) f1: u32,
  @location(0) @interpolate(flat) f2: vec4u,
}

struct T0 {
  f0: f16,
}

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

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

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

/* used global variables: buffer21 */
@vertex
fn vertex3(@location(9) a0: vec2u, @location(11) a1: i32, @location(2) @interpolate(flat, centroid) a2: vec4h, @location(7) a3: vec4i, @location(13) @interpolate(flat) a4: u32, @location(6) a5: f16, @location(8) @interpolate(flat) a6: i32, @location(15) a7: f32, @location(4) a8: vec2f) -> VertexOutput2 {
  var out: VertexOutput2;
  var vf26: vec2u = a0;
  out.f6 += vec4f(f32((*&buffer21)[unconst_u32(23)][15][unconst_u32(2)][33]));
  for (var it2=pack2x16snorm(vec2f(unconst_f32(0.1815), unconst_f32(0.3736))); it2<u32((*&buffer21)[unconst_u32(349)][unconst_u32(6)][0][unconst_u32(18)]); it2++) {
  var vf27: bool = override1;
  break;
  _ = override1;
}
  out.f7 = vec4f(f32(buffer21[2][15][unconst_u32(121)][33]));
  var vf28: vec2i = firstTrailingBit(vec2i(unconst_i32(-231), unconst_i32(78)));
  let ptr45: ptr<storage, f16, read> = &(*&buffer21)[2][unconst_u32(49)][unconst_u32(219)][33];
  return out;
  _ = override1;
  _ = buffer21;
}

/* used global variables: buffer21 */
@fragment
fn fragment2(@builtin(sample_mask) a0: u32, @builtin(position) a1: vec4f, @location(14) a2: vec2u) -> FragmentOutput2 {
  var out: FragmentOutput2;
  let ptr46: ptr<storage, f16, read> = &(*&buffer21)[unconst_u32(296)][15][0][33];
  let ptr47: ptr<storage, array<array<array<f16, 34>, 1>, 16>, read> = &buffer21[unconst_u32(645)];
  let ptr48: ptr<storage, f16, read> = &buffer21[unconst_u32(80)][15][0][33];
  out.f2 -= vec4u(u32((*&buffer21)[u32(buffer21[2][unconst_u32(116)][0][unconst_u32(66)])][unconst_u32(223)][0][33]));
  out.f0 ^= vec4u(u32((*&buffer21)[unconst_u32(237)][unconst_u32(124)][0][33]));
  out.f2 |= vec4u(u32((*ptr47)[15][0][33]));
  out.f0 |= unpack4xU8(u32((*&buffer21)[2][15][unconst_u32(86)][33]));
  let ptr49: ptr<storage, array<f16, 34>, read> = &(*&buffer21)[2][15][unconst_u32(25)];
  let ptr50: ptr<storage, f16, read> = &buffer21[unconst_u32(116)][unconst_u32(86)][unconst_u32(43)][33];
  let ptr51: ptr<storage, array<f16, 34>, read> = &(*&buffer21)[unconst_u32(23)][u32(override1)][0];
  return out;
  _ = override1;
  _ = buffer21;
}

/* used global variables: buffer21 */
@compute @workgroup_size(6, 1, 1)
fn compute2() {
  let ptr52: ptr<storage, array<f16, 34>, read> = &(*&buffer21)[2][15][0];
  let ptr53: ptr<storage, f16, read> = &(*&buffer21)[2][unconst_u32(82)][0][33];
  let ptr54: ptr<storage, f16, read> = &buffer21[unconst_u32(147)][unconst_u32(125)][unconst_u32(154)][unconst_u32(76)];
  let vf29: bool = (unconst_bool(false) || unconst_bool(true));
  _ = buffer21;
}`,
});
let commandEncoder24 = device0.createCommandEncoder({});
let textureView29 = texture13.createView({
  label: '\u0a0c\u{1fe36}\u0a08\u{1f69c}\u0bcd\u2052\u0791\uff77\u08f0',
  dimension: 'cube',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 3,
});
let renderPassEncoder3 = commandEncoder24.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  depthSlice: 76,
  clearValue: { r: 460.7, g: 219.4, b: 764.4, a: 379.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder12.setBindGroup(2, bindGroup2, new Uint32Array(179), 24, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup2, []);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup3, new Uint32Array(1900), 404, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer0);
} catch {}
try {
commandEncoder23.copyBufferToBuffer(buffer5, 4932, buffer4, 452, 600);
} catch {}
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let textureView30 = texture10.createView({dimension: '1d'});
try {
computePassEncoder8.setBindGroup(1, bindGroup5, new Uint32Array(3529), 634, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup6, new Uint32Array(3053), 378, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer3, 'uint32', 11_776, 1_530);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(2, buffer7);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
commandEncoder23.copyBufferToBuffer(buffer16, 1700, buffer0, 12, 84);
} catch {}
try {
  await promise1;
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

struct T3 {
  f0: array<f16, 1>,
}

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

@group(0) @binding(578) var<storage, read> buffer23: array<mat2x3f, 102>;

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

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

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

struct T1 {
  f0: array<f16>,
}

struct VertexOutput3 {
  @location(8) @interpolate(flat, first) f10: vec2h,
  @location(9) f11: vec2h,
  @builtin(position) f12: vec4f,
  @location(2) @interpolate(flat, either) f13: vec2h,
}

struct T4 {
  @align(64) @size(64) f0: vec2h,
  @align(8) @size(3200) f1: array<array<atomic<i32>, 11>>,
}

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

override override3 = false;

struct S0 {
  @builtin(vertex_index) f0: u32,
  @location(13) f1: i32,
  @location(3) f2: vec2i,
  @location(5) @interpolate(perspective, sample) f3: vec4f,
  @location(11) f4: vec2u,
}

/* used global variables: buffer23 */
fn fn0(a0: ptr<uniform, S0>) {
  let ptr55: ptr<storage, mat2x3f, read> = &(*&buffer23)[unconst_u32(400)];
  _ = buffer23;
}

var<workgroup> vw3: S0;

struct T0 {
  f0: array<f16>,
}

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

/* used global variables: buffer23 */
@vertex
fn vertex4(a0: S0, @location(14) a1: vec2h) -> VertexOutput3 {
  var out: VertexOutput3;
  out.f11 += vec2h(a0.f3.xx);
  out.f10 += vec2h(a0.f3.bg);
  out.f11 *= vec2h(buffer23[unconst_u32(151)][unconst_i32(1)].bg);
  {
  out.f10 -= bitcast<vec2h>(a0.f0);
  var vf30: f32 = tan((*&buffer23)[unconst_u32(163)][unconst_i32(0)].z);
  _ = buffer23;
}
  return out;
  _ = buffer23;
}

/* used global variables: buffer23 */
@compute @workgroup_size(3, 1, 1)
fn compute3(@builtin(local_invocation_id) a0: vec3u) {
  vw3 = S0(u32((*&buffer23)[unconst_u32(54)][unconst_u32(437)][unconst_u32(257)]), i32((*&buffer23)[unconst_u32(54)][unconst_u32(437)][unconst_u32(257)]), vec2i(bitcast<i32>((*&buffer23)[unconst_u32(54)][unconst_u32(437)][unconst_u32(257)])), vec4f((*&buffer23)[unconst_u32(54)][unconst_u32(437)][unconst_u32(257)]), vec2u(u32((*&buffer23)[unconst_u32(54)][unconst_u32(437)][unconst_u32(257)])));
  vw3.f1 -= (*&vw3).f1;
  let ptr56: ptr<workgroup, i32> = &vw3.f1;
  vw3 = S0(bitcast<vec3u>(log2(vec3f(unconst_f32(0.4881), unconst_f32(-0.1979), unconst_f32(0.1226))))[2], i32(log2(vec3f(unconst_f32(0.4881), unconst_f32(-0.1979), unconst_f32(0.1226))).z), vec2i(log2(vec3f(unconst_f32(0.4881), unconst_f32(-0.1979), unconst_f32(0.1226))).xz), log2(vec3f(unconst_f32(0.4881), unconst_f32(-0.1979), unconst_f32(0.1226))).ggrr, bitcast<vec2u>(log2(vec3f(unconst_f32(0.4881), unconst_f32(-0.1979), unconst_f32(0.1226))).br));
  {
  vw3 = S0(u32((*&vw3).f1), (*&vw3).f1, vec2i((*&vw3).f1), vec4f(bitcast<f32>((*&vw3).f1)), vec2u(bitcast<u32>((*&vw3).f1)));
  vw3 = (*&vw3);
  {
  var vf31: bool = (unconst_u32(79) > unconst_u32(123));
  let vf32: vec2f = fract(vec2f(unconst_f32(-0.5949), unconst_f32(0.1992)));
}
}
  vw3.f2 = vec2i(vw3.f4);
  for (var it3=pack4x8snorm(vw3.f3); it3<pack4xI8Clamp(vec4i(unconst_i32(-8), unconst_i32(140), unconst_i32(306), unconst_i32(-19))); it3++) {
  vw3.f1 = bitcast<vec4i>(countOneBits(vec4u(unconst_u32(500), unconst_u32(44), unconst_u32(7), unconst_u32(488)))).g;
}
  _ = buffer23;
}`,
});
let texture21 = device0.createTexture({
  size: [258, 15, 11],
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder20 = commandEncoder23.beginComputePass({});
try {
computePassEncoder16.setBindGroup(1, bindGroup1, new Uint32Array(1416), 80, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup3, new Uint32Array(4672), 315, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer0, 'uint16', 1_894, 1_212);
} catch {}
document.body.append(canvas0);
let buffer24 = device0.createBuffer({
  size: 4054,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder25 = device0.createCommandEncoder({});
let renderPassEncoder4 = commandEncoder25.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  depthSlice: 1,
  clearValue: { r: 296.4, g: -23.11, b: 259.3, a: 358.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 758},
});
try {
renderPassEncoder2.setBindGroup(1, bindGroup3);
} catch {}
let commandEncoder26 = device0.createCommandEncoder();
try {
renderPassEncoder2.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder4.setBlendConstant({ r: 425.6, g: -193.6, b: -482.9, a: 958.1, });
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer9);
} catch {}
try {
computePassEncoder11.setBindGroup(1, bindGroup6, new Uint32Array(2113), 910, 0);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(5);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle2, renderBundle3, renderBundle0]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer19, 'uint32', 2_076, 1_085);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 24, y: 1, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView31 = texture14.createView({baseMipLevel: 0});
let computePassEncoder21 = commandEncoder26.beginComputePass({});
try {
computePassEncoder1.setBindGroup(1, bindGroup6);
} catch {}
try {
computePassEncoder5.setBindGroup(3, bindGroup7, new Uint32Array(746), 6, 0);
} catch {}
let textureView32 = texture18.createView({dimension: '2d-array', baseArrayLayer: 0});
try {
computePassEncoder1.setBindGroup(2, bindGroup2, new Uint32Array(69), 1, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle3, renderBundle2, renderBundle0, renderBundle3]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let buffer25 = device0.createBuffer({
  size: 7643,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let texture22 = device0.createTexture({size: {width: 45}, dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer10, 'uint16', 2_096, 6_008);
} catch {}
document.body.append(canvas0);
let commandEncoder27 = device0.createCommandEncoder({});
let texture23 = device0.createTexture({
  size: [45, 1, 4],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView33 = texture19.createView({});
try {
computePassEncoder10.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup0, new Uint32Array(5), 3, 0);
} catch {}
try {
commandEncoder27.copyTextureToTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 78, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 24},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup9 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 62, resource: textureView9},
    {binding: 254, resource: {buffer: buffer16, offset: 256, size: 48}},
    {binding: 578, resource: {buffer: buffer16, offset: 0, size: 3296}},
  ],
});
let texture24 = device0.createTexture({
  size: {width: 517, height: 30, depthOrArrayLayers: 11},
  mipLevelCount: 4,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder22 = commandEncoder27.beginComputePass();
try {
renderPassEncoder1.setBindGroup(2, bindGroup3, new Uint32Array(440), 15, 0);
} catch {}
let promise3 = shaderModule2.getCompilationInfo();
try {
computePassEncoder5.insertDebugMarker('\u{1f64b}');
} catch {}
let textureView34 = texture2.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder17.setBindGroup(0, bindGroup6);
} catch {}
try {
computePassEncoder2.setBindGroup(2, bindGroup1, new Uint32Array(1516), 245, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder3.setScissorRect(50, 1, 5, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer11, 'uint32', 448, 9_373);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer11, 0, 4_501);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(105).fill(144), /* required buffer size: 105 */
{offset: 105, bytesPerRow: 132}, {width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer26 = device0.createBuffer({
  label: '\u0666\u0d7d\u{1fdae}\u0c3f\ueae1\u7980\u2506\uaba6\u9503\u4308\u69d0',
  size: 16268,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder28 = device0.createCommandEncoder({});
let textureView35 = texture15.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 6});
let textureView36 = texture12.createView({dimension: '2d', format: 'rgba16uint', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder18.setBindGroup(1, bindGroup1);
} catch {}
try {
commandEncoder28.copyTextureToBuffer({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 10, y: 4, z: 3},
  aspect: 'all',
}, {
  /* bytesInLastRow: 168 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1272 */
  offset: 1272,
  bytesPerRow: 36864,
  buffer: buffer4,
}, {width: 21, height: 95, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder2.popDebugGroup();
} catch {}
let buffer27 = device0.createBuffer({
  size: 6615,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder29 = device0.createCommandEncoder({});
let texture25 = device0.createTexture({
  size: [258, 15, 11],
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup2, new Uint32Array(5361), 94, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer11, 912, 515);
} catch {}
try {
buffer5.unmap();
} catch {}
let buffer28 = device0.createBuffer({size: 6408, usage: GPUBufferUsage.MAP_READ});
let textureView37 = texture13.createView({dimension: 'cube', format: 'rgba16uint', mipLevelCount: 1});
let computePassEncoder23 = commandEncoder28.beginComputePass({});
try {
renderPassEncoder4.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer8, 'uint16', 1_538, 539);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, undefined, 307_955_275, 393_416_362);
} catch {}
try {
commandEncoder29.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1344 */
  offset: 1344,
  bytesPerRow: 61696,
  buffer: buffer25,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 86, y: 30, z: 4},
  aspect: 'all',
}, {width: 40, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData1,
  origin: { x: 51, y: 41 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 8, y: 3, z: 14},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 30, height: 4, depthOrArrayLayers: 0});
} catch {}
let buffer29 = device0.createBuffer({
  size: 7220,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder24 = commandEncoder29.beginComputePass({timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 398}});
try {
renderPassEncoder2.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, undefined, 2_233_370_197);
} catch {}
let texture26 = device0.createTexture({
  size: [180, 80, 12],
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView38 = texture22.createView({baseArrayLayer: 0});
let sampler13 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 86.41,
  compare: 'equal',
});
try {
renderPassEncoder0.setIndexBuffer(buffer11, 'uint16', 3_910, 257);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer7, 988);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let buffer30 = device0.createBuffer({size: 7610, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder10.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 164, 88);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 0, y: 10, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
let commandEncoder30 = device0.createCommandEncoder({});
let textureView39 = texture11.createView({baseArrayLayer: 0});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']});
try {
renderPassEncoder0.setBindGroup(3, bindGroup7);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer0, 'uint32', 2_012, 5_233);
} catch {}
try {
commandEncoder30.copyBufferToTexture({
  /* bytesInLastRow: 1200 widthInBlocks: 150 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 600 */
  offset: 600,
  bytesPerRow: 44032,
  buffer: buffer25,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 150, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas0);
let commandEncoder31 = device0.createCommandEncoder({});
try {
renderPassEncoder4.setVertexBuffer(7, buffer10, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup0, new Uint32Array(930), 36, 0);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer11, 'uint32', 4_240, 51);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(3, buffer7);
} catch {}
try {
commandEncoder30.clearBuffer(buffer4, 132, 480);
} catch {}
try {
computePassEncoder13.pushDebugGroup('\ud8f2');
} catch {}
let imageBitmap0 = await createImageBitmap(videoFrame0);
let textureView40 = texture7.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
let texture27 = device0.createTexture({
  size: [90, 40, 105],
  mipLevelCount: 3,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder10.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle1]);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer11, 'uint32', 1_272, 8_406);
} catch {}
try {
commandEncoder30.copyTextureToTexture({
  texture: texture21,
  mipLevel: 1,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 47, y: 0, z: 0},
  aspect: 'all',
},
{width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
let pipeline0 = await promise0;
let buffer31 = device0.createBuffer({size: 9057, usage: GPUBufferUsage.VERTEX});
let commandEncoder32 = device0.createCommandEncoder({});
let renderPassEncoder5 = commandEncoder30.beginRenderPass({
  colorAttachments: [{
  view: textureView36,
  clearValue: { r: 115.2, g: 403.5, b: -453.0, a: -52.90, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 4294967295},
});
let renderBundle4 = renderBundleEncoder4.finish({});
try {
computePassEncoder10.setBindGroup(0, bindGroup8, new Uint32Array(2920), 284, 0);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer7, 1_276);
} catch {}
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let buffer32 = device0.createBuffer({
  size: 17529,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let renderPassEncoder6 = commandEncoder32.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  depthSlice: 64,
  clearValue: { r: -506.9, g: -956.4, b: -680.2, a: -526.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 155369861,
});
try {
computePassEncoder17.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle1, renderBundle2, renderBundle0]);
} catch {}
let imageData2 = new ImageData(60, 76);
let buffer33 = device0.createBuffer({
  size: 3264,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView41 = texture9.createView({mipLevelCount: 1});
let textureView42 = texture2.createView({mipLevelCount: 1});
let computePassEncoder25 = commandEncoder31.beginComputePass({});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], stencilReadOnly: true});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'display-p3'});
try {
computePassEncoder15.setBindGroup(2, bindGroup6, new Uint32Array(1911), 311, 0);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer32, 'uint32', 460, 1_896);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer33, 16);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup3);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup0, new Uint32Array(2539), 342, 0);
} catch {}
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3]});
let buffer34 = device0.createBuffer({size: 11101, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder33 = device0.createCommandEncoder({});
let sampler14 = device0.createSampler({addressModeW: 'mirror-repeat', magFilter: 'linear', mipmapFilter: 'linear', maxAnisotropy: 1});
try {
computePassEncoder8.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup1, new Uint32Array(2283), 426, 0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup1, new Uint32Array(1353), 36, 0);
} catch {}
try {
commandEncoder33.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2776 */
  offset: 2776,
  bytesPerRow: 3328,
  buffer: buffer26,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 4, y: 7, z: 0},
  aspect: 'all',
}, {width: 7, height: 39, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 49, y: 1, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout0 = pipeline0.getBindGroupLayout(0);
let bindGroup10 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 328, resource: textureView20}]});
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let computePassEncoder26 = commandEncoder33.beginComputePass({timestampWrites: {querySet: querySet1}});
try {
computePassEncoder7.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(1, bindGroup7, new Uint32Array(254), 84, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer25, 'uint16', 336, 1_646);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer27, 1_952, 187);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup3);
} catch {}
let commandEncoder34 = device0.createCommandEncoder({});
let texture28 = device0.createTexture({
  size: {width: 517, height: 30, depthOrArrayLayers: 62},
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder27 = commandEncoder34.beginComputePass({});
try {
computePassEncoder14.setBindGroup(0, bindGroup9);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup4);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup0, new Uint32Array(946), 212, 0);
} catch {}
try {
  await promise3;
} catch {}
document.body.append(canvas0);
let texture29 = device0.createTexture({
  size: {width: 45},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup4, new Uint32Array(459), 15, 0);
} catch {}
try {
computePassEncoder26.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup6, new Uint32Array(1675), 674, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer1, 'uint32', 168, 9);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
  await promise4;
} catch {}
let commandEncoder35 = device0.createCommandEncoder({});
let textureView43 = texture20.createView({});
let computePassEncoder28 = commandEncoder35.beginComputePass({});
let sampler15 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.36,
  maxAnisotropy: 12,
});
try {
device0.queue.submit([]);
} catch {}
let autogeneratedBindGroupLayout1 = pipeline0.getBindGroupLayout(0);
let texture30 = device0.createTexture({
  size: [90, 1, 1],
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundle5 = renderBundleEncoder5.finish({});
try {
computePassEncoder3.setBindGroup(3, bindGroup2, new Uint32Array(1502), 4, 0);
} catch {}
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle0]);
} catch {}
let buffer35 = device0.createBuffer({
  size: 15036,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture31 = device0.createTexture({
  size: [45, 20, 25],
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView44 = texture19.createView({dimension: '1d', baseArrayLayer: 0});
try {
computePassEncoder25.setBindGroup(3, bindGroup10, new Uint32Array(1311), 313, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup10, new Uint32Array(145), 16, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 2, y: 12, z: 9},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt709', transfer: 'gamma22curve'} });
let textureView45 = texture0.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 4});
try {
computePassEncoder25.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder13.popDebugGroup();
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
let autogeneratedBindGroupLayout2 = pipeline0.getBindGroupLayout(0);
try {
computePassEncoder6.setBindGroup(1, bindGroup8, new Uint32Array(69), 15, 0);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline0);
} catch {}
let commandEncoder36 = device0.createCommandEncoder({});
let texture32 = device0.createTexture({
  size: [129, 7, 11],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder29 = commandEncoder36.beginComputePass({timestampWrites: {querySet: querySet1}});
try {
renderPassEncoder6.setBlendConstant({ r: 346.4, g: 83.99, b: -519.2, a: 615.2, });
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
let bindGroup11 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 8, resource: externalTexture0}]});
let texture33 = device0.createTexture({
  size: [129, 7, 11],
  mipLevelCount: 4,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']});
try {
computePassEncoder28.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer29, 'uint16', 874, 305);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: canvas0,
  origin: { x: 63, y: 4 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 13, y: 13, z: 4},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 9, height: 10, depthOrArrayLayers: 0});
} catch {}
try {
  await promise5;
} catch {}
let buffer36 = device0.createBuffer({size: 5337, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView46 = texture32.createView({dimension: '2d', baseArrayLayer: 0});
let sampler16 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.78,
});
try {
computePassEncoder19.setBindGroup(3, bindGroup3);
} catch {}
try {
computePassEncoder17.setBindGroup(2, bindGroup3, new Uint32Array(1705), 167, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup0, new Uint32Array(2948), 121, 0);
} catch {}
try {
renderBundleEncoder6.insertDebugMarker('\ub765');
} catch {}
let pipeline1 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule0, constants: {}}});
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3]});
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 264});
let texture34 = device0.createTexture({
  size: [90, 1, 1],
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder3.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer32, 'uint16', 6_748, 908);
} catch {}
try {
renderBundleEncoder6.setBindGroup(2, bindGroup5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(87).fill(76), /* required buffer size: 87 */
{offset: 87}, {width: 74, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView47 = texture20.createView({});
let texture35 = device0.createTexture({
  size: {width: 1035, height: 60, depthOrArrayLayers: 11},
  mipLevelCount: 3,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle6 = renderBundleEncoder6.finish({});
try {
renderPassEncoder1.end();
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer29, 'uint16', 562, 1_383);
} catch {}
try {
commandEncoder11.copyBufferToBuffer(buffer11, 1544, buffer10, 1472, 2296);
} catch {}
try {
commandEncoder11.copyBufferToTexture({
  /* bytesInLastRow: 364 widthInBlocks: 91 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1848 */
  offset: 1848,
  bytesPerRow: 37376,
  buffer: buffer27,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 5, y: 26, z: 0},
  aspect: 'all',
}, {width: 91, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData1,
  origin: { x: 7, y: 6 },
  flipY: true,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 1, y: 29, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 25, height: 19, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 328,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let buffer37 = device0.createBuffer({size: 3627, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder37 = device0.createCommandEncoder({});
let commandBuffer0 = commandEncoder11.finish({label: '\u0311\u213e\u{1f8d8}\u06a7\u0deb\u0f6c\u068e\u444f\u035e\ud4c4\uae9b'});
let texture36 = device0.createTexture({
  size: [90, 40, 1],
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder30 = commandEncoder37.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 52}});
try {
computePassEncoder18.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer1, 'uint32', 268, 70);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 6376, new DataView(new ArrayBuffer(19287)), 8086, 1904);
} catch {}
let textureView48 = texture13.createView({dimension: 'cube', mipLevelCount: 1});
let texture37 = device0.createTexture({
  size: [45],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder22.setPipeline(pipeline0);
} catch {}
await gc();
let buffer38 = device0.createBuffer({size: 1824, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder17.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setScissorRect(16, 0, 14, 0);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup11);
} catch {}
try {
  await promise2;
} catch {}
let commandEncoder38 = device0.createCommandEncoder({});
let renderBundle7 = renderBundleEncoder7.finish({});
let externalTexture1 = device0.importExternalTexture({source: videoFrame3});
let buffer39 = device0.createBuffer({
  size: 141,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture38 = device0.createTexture({
  size: [22, 10, 33],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder10.setBindGroup(1, bindGroup9, new Uint32Array(2319), 238, 0);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer25, 'uint16', 538, 290);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, buffer19, 492);
} catch {}
try {
buffer32.unmap();
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3360 */
  offset: 3360,
  bytesPerRow: 8448,
  buffer: buffer25,
}, {
  texture: texture15,
  mipLevel: 1,
  origin: {x: 44, y: 12, z: 2},
  aspect: 'all',
}, {width: 20, height: 61, depthOrArrayLayers: 0});
} catch {}
let bindGroup12 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 8, resource: externalTexture1}]});
let texture39 = device0.createTexture({size: [517, 30, 11], format: 'rgba16uint', usage: GPUTextureUsage.STORAGE_BINDING});
let textureView49 = texture23.createView({dimension: '2d', aspect: 'all'});
let computePassEncoder31 = commandEncoder38.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 235, endOfPassWriteIndex: 379}});
let externalTexture2 = device0.importExternalTexture({source: videoFrame2});
let bindGroup13 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView45}]});
let buffer40 = device0.createBuffer({
  size: 15876,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder39 = device0.createCommandEncoder({});
let textureView50 = texture35.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let renderPassEncoder7 = commandEncoder39.beginRenderPass({
  colorAttachments: [{
  view: textureView49,
  clearValue: { r: 472.9, g: -886.6, b: -444.0, a: -426.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 356},
});
try {
renderPassEncoder7.executeBundles([renderBundle6]);
} catch {}
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'log'} });
let texture40 = device0.createTexture({
  size: {width: 517, height: 30, depthOrArrayLayers: 11},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler17 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 84.67,
});
let externalTexture3 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder15.setBindGroup(3, bindGroup11, new Uint32Array(1942), 440, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer39, 8, 100);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 180, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 578, resource: {buffer: buffer24, offset: 512, size: 3304}}],
});
let buffer41 = device0.createBuffer({
  size: 1314,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView51 = texture33.createView({dimension: '2d', mipLevelCount: 2, baseArrayLayer: 5});
try {
computePassEncoder0.setBindGroup(1, bindGroup8);
} catch {}
try {
computePassEncoder17.setBindGroup(1, bindGroup14, new Uint32Array(209), 103, 0);
} catch {}
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer1, 'uint32', 76, 98);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer11, 0, 8_790);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas0);
let canvas1 = document.createElement('canvas');
let buffer42 = device0.createBuffer({size: 1402, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let texture41 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 31},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let buffer43 = device0.createBuffer({
  size: 68,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
let commandEncoder40 = device0.createCommandEncoder({});
let textureView52 = texture23.createView({baseArrayLayer: 0, arrayLayerCount: 1});
let computePassEncoder32 = commandEncoder40.beginComputePass({timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 4294967295}});
try {
computePassEncoder26.setBindGroup(2, bindGroup11, new Uint32Array(1336), 227, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer10, 'uint16', 2_196, 12_386);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let texture42 = device0.createTexture({
  size: {width: 258},
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder21.setBindGroup(3, bindGroup14, new Uint32Array(1437), 419, 0);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let pipeline2 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 148,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 88, shaderLocation: 15},
          {format: 'sint8x4', offset: 12, shaderLocation: 7},
          {format: 'float32x4', offset: 24, shaderLocation: 4},
          {format: 'unorm16x4', offset: 40, shaderLocation: 2},
          {format: 'snorm16x2', offset: 8, shaderLocation: 6},
          {format: 'uint8x4', offset: 4, shaderLocation: 13},
          {format: 'uint8x4', offset: 0, shaderLocation: 9},
          {format: 'sint8x2', offset: 8, shaderLocation: 8},
          {format: 'sint16x4', offset: 36, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'back'},
});
let imageBitmap1 = await createImageBitmap(canvas0);
let autogeneratedBindGroupLayout3 = pipeline2.getBindGroupLayout(0);
let sampler18 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.85,
});
try {
computePassEncoder32.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -952.1, g: -607.0, b: -623.5, a: -802.1, });
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer19, 'uint16', 1_184, 3_480);
} catch {}
let pipeline3 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex4',
    constants: {},
    buffers: [
      {
        arrayStride: 248,
        attributes: [
          {format: 'unorm8x4', offset: 12, shaderLocation: 14},
          {format: 'sint8x4', offset: 0, shaderLocation: 3},
          {format: 'float32x3', offset: 24, shaderLocation: 5},
          {format: 'uint32x4', offset: 60, shaderLocation: 11},
          {format: 'sint32', offset: 52, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
let commandEncoder41 = device0.createCommandEncoder({});
let texture43 = device0.createTexture({
  size: [45],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView53 = texture11.createView({});
try {
computePassEncoder32.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup0);
} catch {}
try {
commandEncoder41.copyTextureToBuffer({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4064 */
  offset: 4064,
  buffer: buffer29,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout4]});
let texture44 = device0.createTexture({
  size: {width: 45, height: 1, depthOrArrayLayers: 12},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture45 = device0.createTexture({
  size: [180, 1, 296],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView54 = texture21.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder28.setBindGroup(3, bindGroup9, new Uint32Array(6730), 827, 0);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline3);
} catch {}
let bindGroup15 = device0.createBindGroup({
  label: '\u368e\ub0ff\ue68a\u5a98\u2cd1\u0731\u04cc',
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 578, resource: {buffer: buffer0, offset: 256, size: 4628}}],
});
let commandEncoder42 = device0.createCommandEncoder({});
let computePassEncoder33 = commandEncoder42.beginComputePass();
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup10, new Uint32Array(98), 0, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer8);
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1544 */
  offset: 1544,
  bytesPerRow: 54016,
  rowsPerImage: 63,
  buffer: buffer5,
}, {
  texture: texture26,
  mipLevel: 0,
  origin: {x: 4, y: 21, z: 1},
  aspect: 'all',
}, {width: 20, height: 15, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder41.copyTextureToTexture({
  texture: texture30,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder41.resolveQuerySet(querySet2, 17, 19, buffer8, 0);
} catch {}
let buffer44 = device0.createBuffer({size: 3328, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let textureView55 = texture13.createView({dimension: '2d', mipLevelCount: 1});
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2672 */
  offset: 2672,
  buffer: buffer11,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 6, y: 10, z: 4},
  aspect: 'all',
}, new Uint8Array(62_225).fill(11), /* required buffer size: 62_225 */
{offset: 173, bytesPerRow: 72, rowsPerImage: 170}, {width: 15, height: 12, depthOrArrayLayers: 6});
} catch {}
let pipeline4 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule3}});
try {
computePassEncoder16.setBindGroup(0, bindGroup13);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup0, new Uint32Array(452), 173, 0);
} catch {}
try {
commandEncoder41.copyTextureToBuffer({
  texture: texture13,
  mipLevel: 1,
  origin: {x: 8, y: 3, z: 7},
  aspect: 'all',
}, {
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 19536 */
  offset: 1056,
  bytesPerRow: 1024,
  buffer: buffer0,
}, {width: 6, height: 19, depthOrArrayLayers: 1});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let img0 = await imageWithData(8, 101, '#10101010', '#20202020');
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 62,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 254,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 2, hasDynamicOffset: false },
    },
    {
      binding: 578,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let buffer45 = device0.createBuffer({
  size: 20952,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder43 = device0.createCommandEncoder({});
let textureView56 = texture38.createView({baseArrayLayer: 1, arrayLayerCount: 9});
let sampler19 = device0.createSampler({
  label: '\u3933\u005f',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 76.22,
  maxAnisotropy: 5,
});
try {
computePassEncoder8.setBindGroup(0, bindGroup6);
} catch {}
try {
computePassEncoder11.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup4, new Uint32Array(68), 19, 0);
} catch {}
let buffer46 = device0.createBuffer({
  size: 1544,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let textureView57 = texture13.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 12});
let renderPassEncoder8 = commandEncoder41.beginRenderPass({
  colorAttachments: [{
  view: textureView52,
  clearValue: { r: -241.4, g: 466.7, b: -521.6, a: -59.35, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 112215601,
});
let externalTexture4 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder33.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer10, 'uint32', 3_072, 2_353);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(6, buffer46, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let buffer47 = device0.createBuffer({
  size: 6989,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let computePassEncoder34 = commandEncoder43.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 741, endOfPassWriteIndex: 605}});
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer29, 'uint16', 282, 474);
} catch {}
try {
renderPassEncoder2.insertDebugMarker('\u{1fe38}');
} catch {}
try {
  await promise6;
} catch {}
let texture46 = device0.createTexture({
  size: [180, 80, 1],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView58 = texture31.createView({mipLevelCount: 1, arrayLayerCount: 2});
let sampler20 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
});
try {
computePassEncoder27.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 308, new BigUint64Array(18420), 1847, 36);
} catch {}
let commandEncoder44 = device0.createCommandEncoder({});
try {
computePassEncoder31.setBindGroup(2, bindGroup7, new Uint32Array(3605), 285, 0);
} catch {}
try {
computePassEncoder34.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder12.pushDebugGroup('\u25a4');
} catch {}
let commandEncoder45 = device0.createCommandEncoder({});
let texture47 = device0.createTexture({
  size: {width: 22, height: 10, depthOrArrayLayers: 55},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView59 = texture16.createView({dimension: '1d'});
let computePassEncoder35 = commandEncoder45.beginComputePass({});
let sampler21 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 82.40, compare: 'equal'});
try {
computePassEncoder24.setBindGroup(3, bindGroup12);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer45, 'uint16', 4_294, 5_139);
} catch {}
try {
computePassEncoder31.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup2);
} catch {}
try {
commandEncoder44.copyTextureToTexture({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 14, y: 11, z: 0},
  aspect: 'all',
},
{
  texture: texture43,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpteRp431', transfer: 'hlg'} });
let computePassEncoder36 = commandEncoder44.beginComputePass({});
try {
computePassEncoder2.setBindGroup(2, bindGroup10, new Uint32Array(1868), 868, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle3]);
} catch {}
try {
  await promise7;
} catch {}
let canvas2 = document.createElement('canvas');
let bindGroup16 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 578, resource: {buffer: buffer5, offset: 0, size: 3808}}],
});
let texture48 = device0.createTexture({size: [90], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder13.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder31.insertDebugMarker('\uce95');
} catch {}
try {
device0.queue.writeBuffer(buffer25, 1680, new Float32Array(2648), 565, 76);
} catch {}
let commandEncoder46 = device0.createCommandEncoder();
let textureView60 = texture8.createView({});
let computePassEncoder37 = commandEncoder46.beginComputePass();
let sampler22 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 86.21,
});
try {
computePassEncoder28.setBindGroup(3, bindGroup11);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle7, renderBundle6]);
} catch {}
try {
renderPassEncoder8.insertDebugMarker('\u2227');
} catch {}
let commandEncoder47 = device0.createCommandEncoder({});
let texture49 = device0.createTexture({
  size: [45],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView61 = texture13.createView({
  label: '\u0169\u203a\u1486\u{1f838}',
  dimension: 'cube-array',
  mipLevelCount: 1,
  baseArrayLayer: 0,
  arrayLayerCount: 6,
});
let computePassEncoder38 = commandEncoder47.beginComputePass({timestampWrites: {querySet: querySet1}});
try {
computePassEncoder36.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup12, []);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer8, 'uint16', 692, 525);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline2);
} catch {}
let promise8 = shaderModule3.getCompilationInfo();
try {
computePassEncoder12.popDebugGroup();
} catch {}
let commandEncoder48 = device0.createCommandEncoder({});
let computePassEncoder39 = commandEncoder48.beginComputePass({});
let externalTexture5 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder15.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 216, new Int16Array(65536), 13823, 4);
} catch {}
let texture50 = device0.createTexture({
  size: {width: 90},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder33.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup1, []);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer46, 0, 97);
} catch {}
try {
buffer26.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder28.setBindGroup(1, bindGroup3);
} catch {}
try {
computePassEncoder30.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup3, new Uint32Array(928), 41, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
await gc();
let bindGroup17 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 62, resource: textureView9},
    {binding: 254, resource: {buffer: buffer25, offset: 2048, size: 1224}},
    {binding: 578, resource: {buffer: buffer35, offset: 0}},
  ],
});
let textureView62 = texture7.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 2});
let textureView63 = texture32.createView({baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder30.setBindGroup(2, bindGroup7, new Uint32Array(5228), 616, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer29, 508); };
} catch {}
try {
computePassEncoder38.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder5.insertDebugMarker('\ud39e');
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpte240m', transfer: 'bt709'} });
let bindGroup18 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView45}]});
let commandEncoder49 = device0.createCommandEncoder();
try {
computePassEncoder37.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline2);
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 54, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture38,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
let buffer48 = device0.createBuffer({
  size: 7369,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup8);
} catch {}
try {
computePassEncoder8.end();
} catch {}
try {
computePassEncoder35.setPipeline(pipeline1);
} catch {}
try {
  await buffer37.mapAsync(GPUMapMode.WRITE, 760, 588);
} catch {}
let computePassEncoder40 = commandEncoder24.beginComputePass();
let renderPassEncoder9 = commandEncoder49.beginRenderPass({
  colorAttachments: [{
  view: textureView52,
  clearValue: { r: 108.5, g: -183.8, b: -663.9, a: 178.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1},
});
try {
computePassEncoder34.setBindGroup(0, bindGroup8, new Uint32Array(683), 76, 0);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup11);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle6, renderBundle5, renderBundle0, renderBundle5]);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline2);
} catch {}
try {
buffer5.unmap();
} catch {}
let bindGroup19 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 578, resource: {buffer: buffer5, offset: 2304, size: 5320}}],
});
let buffer49 = device0.createBuffer({
  size: 10212,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let renderPassEncoder10 = commandEncoder10.beginRenderPass({
  colorAttachments: [{
  view: textureView55,
  clearValue: { r: -289.6, g: 724.5, b: 261.6, a: 574.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder12.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder8.setBindGroup(3, bindGroup13, []);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup16, new Uint32Array(496), 55, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer10, 'uint16', 552, 3_384);
} catch {}
let imageData3 = new ImageData(8, 16);
let bindGroup20 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 578, resource: {buffer: buffer25, offset: 0, size: 3760}}],
});
let commandEncoder50 = device0.createCommandEncoder();
let computePassEncoder41 = commandEncoder50.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 261, endOfPassWriteIndex: 386}});
try {
computePassEncoder33.setBindGroup(1, bindGroup14, new Uint32Array(2494), 181, 0);
} catch {}
try {
computePassEncoder39.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(6, buffer34, 0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(1, bindGroup6);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(2, buffer44, 0, 427);
} catch {}
try {
computePassEncoder22.insertDebugMarker('\u0176');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 31}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 10, y: 75, z: 6},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup21 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 328, resource: textureView0}]});
let textureView64 = texture21.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1});
let renderBundle8 = renderBundleEncoder8.finish({});
try {
renderPassEncoder4.setIndexBuffer(buffer10, 'uint32', 2_548, 965);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 20, y: 62, z: 6},
  aspect: 'all',
}, new Uint8Array(342).fill(151), /* required buffer size: 342 */
{offset: 342}, {width: 50, height: 1, depthOrArrayLayers: 0});
} catch {}
await gc();
let imageData4 = new ImageData(20, 44);
let bindGroup22 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 578, resource: {buffer: buffer33, offset: 0, size: 3264}}],
});
let buffer50 = device0.createBuffer({size: 11295, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView65 = texture7.createView({aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 3});
let sampler23 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 70.29, compare: 'always'});
try {
computePassEncoder15.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup0, new Uint32Array(327), 10, 0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline2);
} catch {}
let bindGroup23 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 328, resource: textureView39}]});
let commandEncoder51 = device0.createCommandEncoder();
let computePassEncoder42 = commandEncoder51.beginComputePass({});
let sampler24 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat'});
try {
renderPassEncoder4.setStencilReference(1077);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer43, 'uint32', 8, 2);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline3);
} catch {}
let commandEncoder52 = device0.createCommandEncoder();
let textureView66 = texture1.createView({label: '\uad7d\u1410', aspect: 'all', baseMipLevel: 0, baseArrayLayer: 14, arrayLayerCount: 70});
let sampler25 = device0.createSampler({addressModeW: 'repeat', minFilter: 'linear', lodMaxClamp: 77.78, maxAnisotropy: 1});
try {
computePassEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline3);
} catch {}
try {
commandEncoder52.resolveQuerySet(querySet0, 33, 0, buffer16, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(415).fill(28), /* required buffer size: 415 */
{offset: 415}, {width: 2, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 31}
*/
{
  source: imageData0,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 44, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 2, depthOrArrayLayers: 0});
} catch {}
let img1 = await imageWithData(36, 25, '#10101010', '#20202020');
let texture51 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 17},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder43 = commandEncoder52.beginComputePass({timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 510}});
try {
computePassEncoder24.setBindGroup(3, bindGroup2);
} catch {}
try {
computePassEncoder43.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup10, new Uint32Array(3022), 221, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer10, 'uint16', 9_226, 5_427);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(3, buffer45, 0, 67);
} catch {}
try {
computePassEncoder5.insertDebugMarker('\udfd4');
} catch {}
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpte170m', transfer: 'unspecified'} });
let commandEncoder53 = device0.createCommandEncoder({});
let textureView67 = texture51.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 1});
let texture52 = device0.createTexture({
  size: {width: 258, height: 15, depthOrArrayLayers: 155},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder39.setBindGroup(0, bindGroup15, new Uint32Array(2851), 657, 0);
} catch {}
try {
computePassEncoder41.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer29, 'uint16', 660, 2_373);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(2).fill(216), /* required buffer size: 2 */
{offset: 2, rowsPerImage: 68}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView68 = texture40.createView({dimension: '2d', format: 'rgba16float', baseArrayLayer: 1});
let computePassEncoder44 = commandEncoder53.beginComputePass({
  label: '\uff92\ud9a9\u0fc2\ud949\u{1fe93}\u4d6f',
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 63},
});
let sampler26 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 16,
});
try {
computePassEncoder14.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder2.executeBundles([]);
} catch {}
let imageData5 = new ImageData(8, 104);
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout3, veryExplicitBindGroupLayout2]});
try {
computePassEncoder17.setBindGroup(1, bindGroup10, []);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup7, new Uint32Array(84), 44, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer32, 'uint16', 168, 142);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline2);
} catch {}
let imageData6 = new ImageData(12, 52);
let buffer51 = device0.createBuffer({
  label: '\uc0bc\ua815',
  size: 16760,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder54 = device0.createCommandEncoder({});
let sampler27 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 93.39});
try {
computePassEncoder25.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder42.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer45, 0);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
commandEncoder54.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2000 */
  offset: 2000,
  bytesPerRow: 4096,
  buffer: buffer27,
}, {
  texture: texture26,
  mipLevel: 0,
  origin: {x: 63, y: 22, z: 0},
  aspect: 'all',
}, {width: 6, height: 2, depthOrArrayLayers: 0});
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
try {
  await promise8;
} catch {}
let bindGroup24 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 578, resource: {buffer: buffer35, offset: 3584}}],
});
let computePassEncoder45 = commandEncoder54.beginComputePass({});
let externalTexture6 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder12.setBindGroup(1, bindGroup5, new Uint32Array(133), 1, 0);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup5, new Uint32Array(108), 7, 0);
} catch {}
try {
renderPassEncoder8.setStencilReference(161);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer39, 0, 19);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let recycledExplicitBindGroupLayout0 = pipeline3.getBindGroupLayout(0);
let sampler28 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 89.97, maxAnisotropy: 1});
try {
computePassEncoder20.setBindGroup(0, bindGroup5, []);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer51, 'uint16', 1_302, 479);
} catch {}
let bindGroup25 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 578, resource: {buffer: buffer26, offset: 2816}}],
});
let commandEncoder55 = device0.createCommandEncoder({});
let texture53 = device0.createTexture({
  size: [360, 1, 4],
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView69 = texture39.createView({baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder46 = commandEncoder55.beginComputePass();
let sampler29 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMaxClamp: 90.09});
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer39, 16); };
} catch {}
try {
computePassEncoder24.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder45.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeBuffer(buffer51, 2328, new DataView(new ArrayBuffer(17311)), 236, 244);
} catch {}
let gpuCanvasContext0 = canvas2.getContext('webgpu');
let buffer52 = device0.createBuffer({
  size: 423,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView70 = texture9.createView({mipLevelCount: 1});
try {
computePassEncoder41.setBindGroup(2, bindGroup5, new Uint32Array(2239), 721, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer35, 'uint32', 5_992, 215);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer51, 1516, new Float32Array(15941), 4033, 324);
} catch {}
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 7,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32uint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 37, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 282, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let bindGroup26 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 37, resource: {buffer: buffer41, offset: 0, size: 380}},
    {binding: 7, resource: textureView6},
    {binding: 282, resource: externalTexture3},
  ],
});
let commandEncoder56 = device0.createCommandEncoder({});
let computePassEncoder47 = commandEncoder56.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 155, endOfPassWriteIndex: 396}});
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup21);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(3, buffer34);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
await gc();
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'write-only', viewDimension: '3d' },
    },
  ],
});
let commandEncoder57 = device0.createCommandEncoder();
try {
computePassEncoder6.setBindGroup(0, bindGroup7, new Uint32Array(411), 30, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup26);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let promise10 = device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule0, constants: {}}});
let imageBitmap2 = await createImageBitmap(imageBitmap0);
let bindGroup27 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 578, resource: {buffer: buffer47, offset: 256, size: 3584}}],
});
let buffer53 = device0.createBuffer({
  size: 4577,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder58 = device0.createCommandEncoder({});
let computePassEncoder48 = commandEncoder57.beginComputePass({});
let sampler30 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.41,
});
try {
computePassEncoder7.setBindGroup(0, bindGroup17, new Uint32Array(3066), 699, 0);
} catch {}
try {
computePassEncoder14.end();
} catch {}
try {
computePassEncoder47.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline2);
} catch {}
let texture54 = device0.createTexture({
  size: {width: 180, height: 1, depthOrArrayLayers: 72},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder49 = commandEncoder16.beginComputePass({});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], depthReadOnly: true});
try {
computePassEncoder11.setBindGroup(1, bindGroup4, new Uint32Array(3554), 537, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup27, new Uint32Array(59), 30, 0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup1, new Uint32Array(430), 56, 0);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeBuffer(buffer24, 208, new Int16Array(3226), 862, 280);
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(261, 32);
let buffer54 = device0.createBuffer({
  size: 2655,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder59 = device0.createCommandEncoder({});
let textureView71 = texture13.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 8});
let sampler31 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 60.77,
  maxAnisotropy: 19,
});
let externalTexture7 = device0.importExternalTexture({source: videoFrame7});
try {
computePassEncoder13.setBindGroup(2, bindGroup22, new Uint32Array(1484), 34, 0);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle5, renderBundle1, renderBundle5]);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline2);
} catch {}
try {
commandEncoder59.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 272 */
  offset: 272,
  rowsPerImage: 531,
  buffer: buffer1,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 1});
} catch {}
let commandEncoder60 = device0.createCommandEncoder({});
let textureView72 = texture44.createView({format: 'rgba16uint', baseArrayLayer: 7, arrayLayerCount: 1});
try {
computePassEncoder27.setBindGroup(3, bindGroup9);
} catch {}
try {
computePassEncoder28.setBindGroup(3, bindGroup8, new Uint32Array(141), 2, 0);
} catch {}
try {
computePassEncoder49.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer0, 'uint16', 32, 13_360);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup17);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(101).fill(32), /* required buffer size: 101 */
{offset: 101}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView73 = texture24.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 4});
let texture55 = gpuCanvasContext0.getCurrentTexture();
let textureView74 = texture47.createView({mipLevelCount: 1, baseArrayLayer: 13, arrayLayerCount: 5});
let computePassEncoder50 = commandEncoder59.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 494}});
try {
computePassEncoder12.setBindGroup(3, bindGroup7);
} catch {}
try {
computePassEncoder26.setBindGroup(3, bindGroup23, new Uint32Array(644), 127, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer52, 4); };
} catch {}
try {
computePassEncoder40.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup17);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup23, new Uint32Array(3524), 57, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer9, 0, 190);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(4, undefined, 319_185_602, 431_251_670);
} catch {}
try {
device0.queue.writeBuffer(buffer24, 20, new Int16Array(28993), 4803, 364);
} catch {}
document.body.append(img1);
let commandEncoder61 = device0.createCommandEncoder();
let texture56 = device0.createTexture({
  size: {width: 45, height: 20, depthOrArrayLayers: 22},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView75 = texture34.createView({dimension: '2d', arrayLayerCount: 1});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], stencilReadOnly: true});
let sampler32 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 67.71,
  lodMaxClamp: 82.18,
  maxAnisotropy: 15,
});
try {
computePassEncoder27.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder22.setBindGroup(2, bindGroup1, new Uint32Array(327), 196, 0);
} catch {}
try {
computePassEncoder7.end();
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle7]);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 31}
*/
{
  source: canvas0,
  origin: { x: 324, y: 25 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 7, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 16, height: 31, depthOrArrayLayers: 0});
} catch {}
let pipeline5 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  multisample: {mask: 0x44a80172},
  fragment: {
  module: shaderModule1,
  constants: {},
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32', offset: 92, shaderLocation: 13},
          {format: 'snorm8x2', offset: 60, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let buffer55 = device0.createBuffer({
  size: 12654,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder62 = device0.createCommandEncoder({});
let commandBuffer1 = commandEncoder7.finish();
let textureView76 = texture15.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderBundle9 = renderBundleEncoder10.finish({});
let sampler33 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
});
try {
computePassEncoder38.setBindGroup(0, bindGroup9, new Uint32Array(923), 151, 0);
} catch {}
try {
renderPassEncoder6.setViewport(4.482802662299672, 1.6850106946102648, 12.070401516047225, 0.6255164615445679, 0.2716518573809854, 0.41868772271301874);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer39, 36, 3);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer43, 'uint32', 4, 2);
} catch {}
try {
commandEncoder62.copyBufferToBuffer(buffer25, 1212, buffer4, 1828, 68);
} catch {}
document.body.prepend(img0);
let offscreenCanvas1 = new OffscreenCanvas(3, 162);
let commandEncoder63 = device0.createCommandEncoder({});
let renderPassEncoder11 = commandEncoder60.beginRenderPass({
  colorAttachments: [{
  view: textureView41,
  depthSlice: 73,
  clearValue: { r: 326.1, g: -365.2, b: -206.7, a: -8.159, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 383, endOfPassWriteIndex: 142},
});
try {
renderPassEncoder4.setVertexBuffer(6, buffer7, 0);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(7, buffer11, 0);
} catch {}
try {
commandEncoder61.copyTextureToTexture({
  texture: texture35,
  mipLevel: 2,
  origin: {x: 12, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 32, y: 14, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext1 = offscreenCanvas0.getContext('webgpu');
let texture57 = device0.createTexture({
  size: [180, 1, 567],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder43.setBindGroup(3, bindGroup1);
} catch {}
try {
computePassEncoder38.setBindGroup(1, bindGroup14, new Uint32Array(881), 90, 0);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup21, new Uint32Array(783), 1, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer10);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer10, 'uint16', 1_016, 1_022);
} catch {}
try {
commandEncoder63.copyBufferToBuffer(buffer43, 0, buffer41, 852, 8);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise9;
} catch {}
let recycledExplicitBindGroupLayout1 = pipeline3.getBindGroupLayout(0);
let commandEncoder64 = device0.createCommandEncoder({});
let textureView77 = texture51.createView({dimension: 'cube', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1});
let computePassEncoder51 = commandEncoder64.beginComputePass({});
try {
computePassEncoder43.setBindGroup(1, bindGroup23, new Uint32Array(129), 31, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup26);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup5, new Uint32Array(572), 33, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer34, 124, 822);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup15, new Uint32Array(2886), 564, 0);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(6, buffer11, 0, 2_574);
} catch {}
let arrayBuffer0 = buffer37.getMappedRange(760, 84);
let videoFrame8 = new VideoFrame(canvas1, {timestamp: 0});
let textureView78 = texture40.createView({dimension: '2d', baseArrayLayer: 1});
let externalTexture8 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder35.setBindGroup(2, bindGroup0);
} catch {}
try {
computePassEncoder18.setBindGroup(0, bindGroup27, new Uint32Array(1491), 699, 0);
} catch {}
try {
computePassEncoder51.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup18, []);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup16, new Uint32Array(569), 71, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup10);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer3, 'uint16', 3_818, 239);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(3, buffer51);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let recycledExplicitBindGroupLayout2 = pipeline3.getBindGroupLayout(0);
let commandEncoder65 = device0.createCommandEncoder({});
let textureView79 = texture8.createView({});
let renderBundle10 = renderBundleEncoder9.finish({});
try {
computePassEncoder12.setBindGroup(3, bindGroup3);
} catch {}
try {
computePassEncoder18.setBindGroup(2, bindGroup16, new Uint32Array(1232), 263, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline2);
} catch {}
try {
commandEncoder63.copyTextureToBuffer({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 24 */
  offset: 24,
  buffer: buffer11,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder65.copyTextureToTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture27,
  mipLevel: 2,
  origin: {x: 3, y: 10, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder66 = device0.createCommandEncoder();
let texture58 = gpuCanvasContext0.getCurrentTexture();
let sampler34 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMaxClamp: 75.52,
});
try {
computePassEncoder4.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer51, 'uint32', 536, 307);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline5);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
try {
computePassEncoder49.setBindGroup(0, bindGroup3);
} catch {}
try {
computePassEncoder50.setPipeline(pipeline1);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 14 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 164 */
  offset: 164,
  bytesPerRow: 25856,
  buffer: buffer24,
}, {
  texture: texture51,
  mipLevel: 1,
  origin: {x: 9, y: 4, z: 3},
  aspect: 'all',
}, {width: 7, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder58.insertDebugMarker('\u{1fff4}');
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'bt2020_12bit'} });
let bindGroup28 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 8, resource: externalTexture0}]});
try {
renderPassEncoder9.setBindGroup(0, bindGroup17, new Uint32Array(957), 25, 0);
} catch {}
try {
commandEncoder61.copyTextureToTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 146, y: 3, z: 1},
  aspect: 'all',
},
{
  texture: texture49,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 176,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let bindGroup29 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 8, resource: externalTexture4}]});
let computePassEncoder52 = commandEncoder62.beginComputePass();
let sampler35 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', lodMinClamp: 80.41, lodMaxClamp: 80.45});
try {
renderPassEncoder10.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, undefined, 281_613_349, 1_055_198_143);
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer49);
} catch {}
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 1,
  origin: {x: 18, y: 0, z: 3},
  aspect: 'all',
}, {
  /* bytesInLastRow: 288 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1536 */
  offset: 1536,
  buffer: buffer12,
}, {width: 36, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder61.insertDebugMarker('\u0b95');
} catch {}
try {
externalTexture6.label = '\ud506\u997e\u0b57\u0e49\u{1f83c}\u6d57\uf9af\u{1ffac}\u{1fd6f}\uaaff\u238b';
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let renderPassEncoder12 = commandEncoder63.beginRenderPass({
  colorAttachments: [{
  view: textureView72,
  clearValue: { r: 336.8, g: -714.2, b: 793.0, a: -605.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 39950297,
});
try {
computePassEncoder29.setBindGroup(2, bindGroup13);
} catch {}
try {
computePassEncoder51.setBindGroup(3, bindGroup21, new Uint32Array(1977), 109, 0);
} catch {}
try {
computePassEncoder46.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline5);
} catch {}
try {
commandEncoder58.copyTextureToBuffer({
  texture: texture43,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 120 */
  offset: 120,
  buffer: buffer30,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder58.resolveQuerySet(querySet0, 12, 23, buffer48, 2304);
} catch {}
try {
device0.queue.writeBuffer(buffer4, 64, new Int16Array(2089), 56, 220);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 69, y: 12, z: 2},
  aspect: 'all',
}, new Uint8Array(437).fill(88), /* required buffer size: 437 */
{offset: 437, bytesPerRow: 63}, {width: 7, height: 7, depthOrArrayLayers: 0});
} catch {}
let bindGroup30 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: [{binding: 176, resource: textureView51}]});
let commandEncoder68 = device0.createCommandEncoder();
let textureView80 = texture0.createView({aspect: 'all', baseArrayLayer: 4, arrayLayerCount: 5});
try {
renderPassEncoder5.setBindGroup(1, bindGroup15, new Uint32Array(25), 0, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer11, 'uint16', 12_906, 4);
} catch {}
let buffer56 = device0.createBuffer({
  size: 13866,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder69 = device0.createCommandEncoder({});
let renderPassEncoder13 = commandEncoder61.beginRenderPass({
  colorAttachments: [{
  view: textureView52,
  clearValue: { r: 12.45, g: 947.9, b: 594.1, a: -152.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder6.setBindGroup(3, bindGroup18, new Uint32Array(715), 50, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup20, new Uint32Array(1140), 165, 0);
} catch {}
try {
buffer40.unmap();
} catch {}
let pipeline6 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
let pipeline7 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 468,
        attributes: [
          {format: 'uint32x3', offset: 60, shaderLocation: 12},
          {format: 'float32x4', offset: 60, shaderLocation: 10},
          {format: 'sint8x4', offset: 84, shaderLocation: 14},
          {format: 'uint32x3', offset: 144, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list'},
});
try {
textureView57.label = '\ueca5\u{1fc18}\u6958\u360c\u9a0c\u{1f73d}\u{1fce2}\u9d30\u1671\ua991\u06eb';
} catch {}
let commandEncoder70 = device0.createCommandEncoder({});
let textureView81 = texture47.createView({dimension: '2d', format: 'rgba16float', mipLevelCount: 1, baseArrayLayer: 8});
try {
renderPassEncoder10.setViewport(219.7587381152212, 221.2458888162224, 30.52946723660021, 20.801184103972915, 0.18926556872827338, 0.3590990864088295);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer48, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: canvas0,
  origin: { x: 154, y: 10 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 7, y: 6, z: 5},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 13, height: 4, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img1);
let bindGroup31 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 578, resource: {buffer: buffer5, offset: 1024, size: 6088}}],
});
try {
renderPassEncoder11.setIndexBuffer(buffer19, 'uint16', 880, 331);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline7);
} catch {}
try {
device0.queue.writeBuffer(buffer53, 116, new Float32Array(7777), 667, 356);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder71 = device0.createCommandEncoder({});
let textureView82 = texture34.createView({dimension: '2d-array'});
let computePassEncoder53 = commandEncoder69.beginComputePass({});
try {
computePassEncoder11.setBindGroup(1, bindGroup13);
} catch {}
try {
computePassEncoder53.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer32, 'uint16', 2_160, 75);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline3);
} catch {}
let commandEncoder72 = device0.createCommandEncoder({});
let textureView83 = texture16.createView({});
try {
renderPassEncoder2.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline7);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 328,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let buffer57 = device0.createBuffer({size: 6478, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandBuffer2 = commandEncoder70.finish();
let textureView84 = texture1.createView({baseArrayLayer: 55, arrayLayerCount: 18});
try {
computePassEncoder13.setBindGroup(0, bindGroup5, new Uint32Array(449), 51, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
commandEncoder72.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 824 */
  offset: 824,
  buffer: buffer35,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
}, {width: 10, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 10, y: 1, z: 24},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer58 = device0.createBuffer({
  size: 16560,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder73 = device0.createCommandEncoder({});
let texture59 = device0.createTexture({
  size: {width: 129},
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder54 = commandEncoder66.beginComputePass({});
try {
renderPassEncoder10.setBindGroup(1, bindGroup17);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup18, new Uint32Array(5213), 112, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(4, undefined, 9_278_134, 1_713_856_923);
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4272 */
  offset: 4272,
  bytesPerRow: 17152,
  buffer: buffer56,
}, {
  texture: texture30,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder73.copyTextureToTexture({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 51, y: 12, z: 1},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{width: 25, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer59 = device0.createBuffer({
  size: 10331,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder74 = device0.createCommandEncoder({});
let renderPassEncoder14 = commandEncoder58.beginRenderPass({
  colorAttachments: [{
  view: textureView70,
  depthSlice: 9,
  clearValue: { r: 782.1, g: -992.6, b: 625.7, a: 314.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1},
});
let sampler36 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder44.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup22);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle4, renderBundle5]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, buffer49);
} catch {}
try {
commandEncoder67.copyTextureToTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture42,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
await gc();
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'write-only', viewDimension: '3d' },
    },
  ],
});
let bindGroup32 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 62, resource: textureView9},
    {binding: 578, resource: {buffer: buffer0, offset: 16384, size: 3604}},
    {binding: 254, resource: {buffer: buffer49, offset: 1536}},
  ],
});
let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout2, veryExplicitBindGroupLayout8]});
let commandEncoder75 = device0.createCommandEncoder({});
let textureView85 = texture40.createView({baseArrayLayer: 1, arrayLayerCount: 3});
let texture60 = device0.createTexture({
  size: {width: 180, height: 80, depthOrArrayLayers: 15},
  mipLevelCount: 2,
  format: 'astc-6x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder37.setBindGroup(1, bindGroup10);
} catch {}
try {
renderPassEncoder2.setScissorRect(5, 0, 4, 0);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
let bindGroup33 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 328, resource: textureView15}]});
let texture61 = device0.createTexture({
  size: {width: 256},
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder55 = commandEncoder71.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 833}});
try {
computePassEncoder30.setBindGroup(0, bindGroup28, new Uint32Array(2285), 308, 0);
} catch {}
try {
computePassEncoder54.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup14, new Uint32Array(1202), 51, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer25, 'uint16', 814, 943);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(3, buffer43, 0);
} catch {}
try {
  await promise11;
} catch {}
await gc();
let textureView86 = texture51.createView({dimension: 'cube', mipLevelCount: 1});
let textureView87 = texture10.createView({});
try {
computePassEncoder37.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder9.setViewport(39.710745992696296, 0.8895197618637867, 0.07733054050806067, 0.09207981643149393, 0.4886252956277245, 0.8465162056493859);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(4, buffer7);
} catch {}
let gpuCanvasContext2 = canvas1.getContext('webgpu');
let texture62 = device0.createTexture({
  size: {width: 45, height: 1, depthOrArrayLayers: 504},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder56 = commandEncoder67.beginComputePass({});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], stencilReadOnly: false});
try {
computePassEncoder12.setBindGroup(2, bindGroup20, new Uint32Array(1679), 647, 0);
} catch {}
try {
computePassEncoder38.end();
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer46, 'uint32', 148, 73);
} catch {}
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 385});
let texture63 = device0.createTexture({size: {width: 258}, dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let computePassEncoder57 = commandEncoder72.beginComputePass();
let renderBundle11 = renderBundleEncoder11.finish({});
try {
renderPassEncoder2.setBindGroup(3, bindGroup4, new Uint32Array(1310), 69, 0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer10, 'uint16', 88, 11_679);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer43, 24, 7);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 664 widthInBlocks: 83 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 16 */
  offset: 16,
  buffer: buffer26,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 83, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer49, 624, new Float32Array(19917), 111, 304);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.label = '\u3957\u{1fbe3}\u74c5';
} catch {}
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 61,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '1d' },
    },
    {binding: 89, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let texture64 = device0.createTexture({
  size: [256, 256, 17],
  mipLevelCount: 4,
  sampleCount: 1,
  dimension: '2d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle3, renderBundle9, renderBundle0]);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(5, buffer34, 0, 604);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let pipeline8 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule0, targets: [{format: 'rgba16uint', writeMask: 0}]},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex4',
    buffers: [
      {
        arrayStride: 380,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x4', offset: 12, shaderLocation: 11},
          {format: 'unorm16x4', offset: 16, shaderLocation: 14},
          {format: 'sint16x4', offset: 16, shaderLocation: 13},
          {format: 'float32x4', offset: 56, shaderLocation: 5},
        ],
      },
      {arrayStride: 56, stepMode: 'instance', attributes: [{format: 'sint32', offset: 0, shaderLocation: 3}]},
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let bindGroup34 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 8, resource: externalTexture0}]});
let texture65 = device0.createTexture({
  size: [45, 20, 22],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView88 = texture24.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder58 = commandEncoder47.beginComputePass({});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true});
let renderBundle12 = renderBundleEncoder12.finish();
try {
computePassEncoder56.setBindGroup(3, bindGroup29, new Uint32Array(624), 30, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer3, 'uint16', 9_664, 3_798);
} catch {}
let gpuCanvasContext3 = offscreenCanvas1.getContext('webgpu');
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 20,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 483,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let texture66 = device0.createTexture({
  size: {width: 90, height: 40, depthOrArrayLayers: 17},
  format: 'rg32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView89 = texture19.createView({});
let computePassEncoder59 = commandEncoder68.beginComputePass();
try {
renderPassEncoder6.setBindGroup(0, bindGroup10, new Uint32Array(73), 0, 0);
} catch {}
try {
renderPassEncoder6.setViewport(60.54394840061331, 6.73042439314426, 16.21257657579405, 0.2594682970189832, 0.9988622505829411, 0.999969193056788);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer0, 'uint16', 3_484, 481);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 22, height: 10, depthOrArrayLayers: 55}
*/
{
  source: imageData0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 5},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
let imageData7 = new ImageData(24, 36);
let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout1, veryExplicitBindGroupLayout6]});
let commandEncoder76 = device0.createCommandEncoder();
let texture67 = device0.createTexture({
  size: {width: 360, height: 1, depthOrArrayLayers: 7},
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder53.setBindGroup(3, bindGroup12);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(15);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle1, renderBundle4]);
} catch {}
let querySet4 = device0.createQuerySet({type: 'timestamp', count: 590});
let textureView90 = texture67.createView({baseArrayLayer: 3, arrayLayerCount: 2});
let texture68 = device0.createTexture({
  size: {width: 45, height: 1, depthOrArrayLayers: 1},
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler37 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', minFilter: 'nearest', lodMaxClamp: 89.27});
try {
computePassEncoder31.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup26);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
commandEncoder74.copyBufferToBuffer(buffer50, 1348, buffer25, 240, 212);
} catch {}
let imageData8 = new ImageData(20, 60);
let buffer60 = device0.createBuffer({label: '\u382d\u07ec', size: 7665, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder77 = device0.createCommandEncoder({});
let externalTexture9 = device0.importExternalTexture({source: videoFrame7});
try {
computePassEncoder22.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(3);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer54, 'uint16', 688, 260);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline8);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder75.copyBufferToTexture({
  /* bytesInLastRow: 168 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1352 */
  offset: 1352,
  bytesPerRow: 22016,
  buffer: buffer2,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, {width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder78 = device0.createCommandEncoder();
let querySet5 = device0.createQuerySet({type: 'timestamp', count: 90});
let textureView91 = texture67.createView({arrayLayerCount: 2});
let sampler38 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', minFilter: 'linear', lodMinClamp: 20.91});
try {
computePassEncoder52.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder11.beginOcclusionQuery(3);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder10.setScissorRect(1, 49, 84, 81);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer8, 'uint32', 320, 2_531);
} catch {}
try {
commandEncoder75.copyBufferToBuffer(buffer16, 1148, buffer11, 696, 356);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 848 */
  offset: 848,
  bytesPerRow: 7424,
  buffer: buffer47,
}, {
  texture: texture2,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 24, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder77.clearBuffer(buffer56, 16, 312);
} catch {}
let autogeneratedBindGroupLayout4 = pipeline2.getBindGroupLayout(0);
let bindGroup35 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 89, resource: {buffer: buffer11, offset: 256, size: 5584}},
    {binding: 61, resource: textureView87},
  ],
});
try {
computePassEncoder29.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup5, new Uint32Array(666), 56, 0);
} catch {}
try {
renderPassEncoder11.endOcclusionQuery();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 31}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 0, y: 8, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer61 = device0.createBuffer({size: 24744, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let texture69 = device0.createTexture({
  size: [1035, 60, 105],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder60 = commandEncoder75.beginComputePass({timestampWrites: {querySet: querySet4, endOfPassWriteIndex: 378}});
let sampler39 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 95.93});
try {
computePassEncoder51.setBindGroup(3, bindGroup34, new Uint32Array(1012), 108, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1, 2); };
} catch {}
try {
computePassEncoder55.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder12.insertDebugMarker('\uef6c');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
globalThis.someLabel = commandEncoder9.label;
} catch {}
let bindGroup36 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: [{binding: 176, resource: textureView75}]});
let buffer62 = device0.createBuffer({
  label: '\u9e3a\u{1fd6b}\uba10\ua080\u{1f9c5}',
  size: 1919,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let renderPassEncoder15 = commandEncoder74.beginRenderPass({
  colorAttachments: [{
  view: textureView70,
  depthSlice: 36,
  clearValue: { r: -903.0, g: -208.1, b: -376.3, a: 416.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet2,
});
try {
computePassEncoder37.setBindGroup(0, bindGroup27, new Uint32Array(1099), 57, 0);
} catch {}
try {
buffer29.unmap();
} catch {}
try {
commandEncoder77.copyTextureToBuffer({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 368 */
  offset: 368,
  buffer: buffer60,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup37 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 328, resource: textureView0}]});
let textureView92 = texture34.createView({dimension: '2d-array', format: 'r8sint', baseArrayLayer: 0});
try {
renderPassEncoder0.setBindGroup(3, bindGroup16, new Uint32Array(3880), 779, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer51, 'uint32', 1_296, 4_804);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline3);
} catch {}
let bindGroup38 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 328, resource: textureView15}]});
let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout5]});
let commandEncoder79 = device0.createCommandEncoder({});
let texture70 = device0.createTexture({
  size: {width: 1035, height: 60, depthOrArrayLayers: 11},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder36.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(14);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint32', 72, 425);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let bindGroup39 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 254, resource: {buffer: buffer27, offset: 1280, size: 1000}},
    {binding: 62, resource: textureView7},
    {binding: 578, resource: {buffer: buffer5, offset: 1024, size: 3844}},
  ],
});
let commandEncoder80 = device0.createCommandEncoder({});
let computePassEncoder61 = commandEncoder73.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 467, endOfPassWriteIndex: 387}});
try {
computePassEncoder60.setBindGroup(1, bindGroup37);
} catch {}
try {
computePassEncoder60.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup37, new Uint32Array(3334), 186, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline8);
} catch {}
try {
commandEncoder80.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 39, y: 2, z: 1},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
},
{width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout0]});
let textureView93 = texture31.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder62 = commandEncoder77.beginComputePass({});
try {
computePassEncoder10.setBindGroup(0, bindGroup10, new Uint32Array(139), 40, 0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline5);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
buffer3.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData8,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 15, y: 4, z: 26},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 32, depthOrArrayLayers: 0});
} catch {}
let pipeline9 = device0.createComputePipeline({layout: pipelineLayout14, compute: {module: shaderModule1, constants: {}}});
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

enable f16;

diagnostic(info, xyz);

/* zero global variables used */
fn fn0(a0: FragmentOutput3) -> VertexOutput4 {
  var out: VertexOutput4;
  out = VertexOutput4(vec2u(a0.f0), unpack4x8unorm(a0.f0), vec4f(bitcast<f32>(a0.f0)));
  let vf33: f32 = a0.f1[unconst_u32(96)];
  var vf34: bool = all(vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true), unconst_bool(false)));
  let vf35: u32 = a0.f0;
  let vf36: vec2f = atan2(vec2f(unconst_f32(0.1913), unconst_f32(0.07219)), vec2f(unconst_f32(0.08853), unconst_f32(0.2058)));
  let vf37: vec4f = a0.f1;
  var vf38: vec2u = (vec2u(unconst_u32(181), unconst_u32(327)) ^ vec2u(unconst_u32(127), unconst_u32(302)));
  var vf39: vec2u = insertBits(vec2u(unconst_u32(128), unconst_u32(102)), vec2u(unconst_u32(96), unconst_u32(146)), unconst_u32(68), unconst_u32(41));
  let ptr57: ptr<function, vec2u> = &vf39;
  return out;
}

/* zero global variables used */
fn fn1() -> array<array<array<array<vec2i, 1>, 1>, 1>, 1> {
  var out: array<array<array<array<vec2i, 1>, 1>, 1>, 1>;
  var vf40 = fn0(FragmentOutput3(pack2x16snorm(vec2f(unconst_f32(0.00726), unconst_f32(0.1928))), unpack4x8snorm(pack2x16snorm(vec2f(unconst_f32(0.00726), unconst_f32(0.1928))))));
  return out;
}

var<workgroup> vw17: VertexOutput4;

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

struct FragmentOutput3 {
  @builtin(sample_mask) f0: u32,
  @location(0) f1: vec4f,
}

var<workgroup> vw9: T1;

var<workgroup> vw12: FragmentOutput3;

struct T0 {
  @size(8) f0: array<atomic<i32>, 1>,
  @size(72) f1: vec4h,
}

var<workgroup> vw10: vec2u;

var<workgroup> vw4: mat2x4f;

var<workgroup> vw15: atomic<i32>;

var<workgroup> vw19: T0;

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

var<workgroup> vw7: mat4x2h;

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

struct VertexOutput4 {
  @location(11) f14: vec2u,
  @builtin(position) f15: vec4f,
  @location(15) @interpolate(perspective, center) f16: vec4f,
}

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

var<workgroup> vw11: VertexOutput4;

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

alias vec3b = vec3<bool>;

/* used global variables: tex4 */
fn fn2() -> FragmentOutput3 {
  var out: FragmentOutput3;
  let vf41: vec2u = textureDimensions(tex4, unconst_i32(31));
  let vf42: vec2h = acos(vec2h(unconst_f16(1955.2), unconst_f16(-10198.8)));
  out.f1 += (vec4f(unconst_f32(0.08235), unconst_f32(0.2925), unconst_f32(0.05619), unconst_f32(0.08426)) % f32(asin(unconst_f16(2481.0))));
  {
  var vf43 = fn1();
  out = FragmentOutput3(vec2u(vf43[0][unconst_u32(426)][unconst_u32(243)][unconst_u32(126)])[0], bitcast<vec4f>(vf43[0][unconst_u32(426)][unconst_u32(243)][unconst_u32(126)].yxxy));
  _ = fn1();
  out.f0 *= (vec3u(unconst_u32(4), unconst_u32(118), unconst_u32(65)) << vec3u(unconst_u32(53), unconst_u32(72), unconst_u32(169)))[1];
}
  if bool(textureDimensions(tex4)[1]) {
  var vf44 = fn1();
  fn1();
  let ptr58: ptr<function, vec2i> = &vf44[0][unconst_u32(290)][unconst_u32(13)][0];
  out.f1 += vec4f(vf44[0][0][vec2u(vf44[unconst_u32(73)][0][0][0]).r][0].grgg);
}
  var vf45 = fn0(FragmentOutput3((unconst_u32(169) ^ unconst_u32(15)), vec4f(f32((unconst_u32(169) ^ unconst_u32(15))))));
  var vf46 = fn1();
  var vf47 = fn1();
  return out;
  _ = tex4;
}

var<workgroup> vw18: FragmentOutput3;

/* used global variables: tex4 */
@must_use 
fn fn4() -> mat4x2h {
  var out: mat4x2h;
  let vf49: vec2u = textureDimensions(tex4, unconst_i32(59));
  fn0(FragmentOutput3(vec4u(sqrt(vec4h(textureLoad(tex4, vec2i(unconst_i32(35), unconst_i32(116)), unconst_i32(1000)))))[1], vec4f(sqrt(vec4h(textureLoad(tex4, vec2i(unconst_i32(35), unconst_i32(116)), unconst_i32(1000)))))));
  return out;
  _ = tex4;
}

var<workgroup> vw5: T1;

/* zero global variables used */
fn fn3() -> mat2x4h {
  var out: mat2x4h;
  let vf48: vec4u = unpack4xU8(dot4U8Packed(unconst_u32(342), unconst_u32(220)));
  return out;
}

var<workgroup> vw8: T1;

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

var<workgroup> vw16: FragmentOutput3;

var<workgroup> vw6: T1;

var<workgroup> vw14: atomic<u32>;

var<workgroup> vw13: f16;

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

/* zero global variables used */
@vertex
fn vertex5(@location(3) a0: vec4f) -> VertexOutput4 {
  var out: VertexOutput4;
  out.f16 = vec4f((vec2u(unconst_u32(87), unconst_u32(50)) < vec2u(unconst_u32(174), unconst_u32(81))).grrg);
  var vf50 = fn0(FragmentOutput3(bitcast<u32>(degrees(vec2h(unconst_f16(31464.3), unconst_f16(6953.2)))), vec4f(degrees(vec2h(unconst_f16(31464.3), unconst_f16(6953.2))).rgrg)));
  fn0(FragmentOutput3(u32(any((vec2u(unconst_u32(13), unconst_u32(174)) < vec2u(unconst_u32(313), unconst_u32(5))))), vec4f((vec2u(unconst_u32(13), unconst_u32(174)) < vec2u(unconst_u32(313), unconst_u32(5))).yyyy)));
  return out;
}

/* used global variables: tex4 */
@fragment
fn fragment3() -> FragmentOutput3 {
  var out: FragmentOutput3;
  _ = fn4();
  out.f0 ^= textureDimensions(tex4).y;
  let vf51: vec2f = unpack2x16float(unconst_u32(504));
  loop {
  _ = fn0(FragmentOutput3(bitcast<u32>(dot4I8Packed(unconst_u32(204), unconst_u32(85))), vec4f(bitcast<f32>(dot4I8Packed(unconst_u32(204), unconst_u32(85))))));
  break;
}
  while bool(cross(vec3f(unconst_f32(0.1741), unconst_f32(0.2778), unconst_f32(0.09554)), vec3f(unconst_f32(0.1206), unconst_f32(0.2615), unconst_f32(0.08417)))[2]) {
  var vf52: vec3<bool> = (vec3h(unconst_f16(4432.2), unconst_f16(7437.7), unconst_f16(15926.2)) == vec3h(unconst_f16(3965.9), unconst_f16(11505.9), unconst_f16(648.4)));
}
  out = FragmentOutput3(u32(sign(unconst_i32(72))), vec4f(f32(sign(unconst_i32(72)))));
  fn0(FragmentOutput3(pack2x16snorm(vec2f(unconst_f32(0.05110), unconst_f32(0.06849))), unpack4x8unorm(pack2x16snorm(vec2f(unconst_f32(0.05110), unconst_f32(0.06849))))));
  _ = fn4();
  out.f1 = vec4f((vec2u(u32(length(vec4h(unconst_f16(1391.7), unconst_f16(1463.7), unconst_f16(16164.5), unconst_f16(14574.9))))) < vec2u(unconst_u32(282), unconst_u32(322))).xyyx);
  return out;
  _ = tex4;
}

/* zero global variables used */
@compute @workgroup_size(1, 1, 1)
fn compute4() {
  let ptr59: ptr<workgroup, atomic<i32>> = &vw19.f0[0];
  while bool(atomicLoad(&(*&vw5).f0[unconst_u32(35)][unconst_u32(1)])) {
  var vf53 = fn3();
  let ptr60: ptr<workgroup, vec4f> = &vw17.f16;
  let ptr61: ptr<workgroup, vec4f> = &(*&vw16).f1;
  let vf54: FragmentOutput3 = workgroupUniformLoad(&vw12);
  fn3();
}
  vw11 = VertexOutput4(vec2u(u32(atomicLoad(&(*&vw5).f0[0][0]))), vec4f(bitcast<f32>(atomicLoad(&(*&vw5).f0[0][0]))), vec4f(f32(atomicLoad(&(*&vw5).f0[0][0]))));
  let vf55: i32 = atomicLoad(&vw19.f0[unconst_u32(93)]);
  atomicCompareExchangeWeak(&vw6.f0[unconst_u32(525)][0], unconst_i32(144), unconst_i32(40));
  var vf56: i32 = atomicLoad(&vw19.f0[0]);
}`,
});
let bindGroup40 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 127, resource: {buffer: buffer0, offset: 4096, size: 1996}},
    {binding: 8, resource: textureView14},
  ],
});
let commandEncoder81 = device0.createCommandEncoder();
let textureView94 = texture61.createView({baseMipLevel: 0});
try {
renderPassEncoder11.beginOcclusionQuery(7);
} catch {}
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({entries: [{binding: 3, visibility: GPUShaderStage.VERTEX, externalTexture: {}}]});
let textureView95 = texture47.createView({dimension: '2d', format: 'rgba16float', mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 1});
let computePassEncoder63 = commandEncoder81.beginComputePass({timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 637}});
try {
computePassEncoder35.setBindGroup(3, bindGroup21);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer0, 0, 869);
} catch {}
let promise12 = device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 104, shaderLocation: 3},
          {format: 'unorm8x4', offset: 52, shaderLocation: 5},
          {format: 'sint32x4', offset: 56, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 440,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 86, shaderLocation: 11},
          {format: 'unorm8x4', offset: 100, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
let commandEncoder82 = device0.createCommandEncoder();
let computePassEncoder64 = commandEncoder79.beginComputePass({timestampWrites: {querySet: querySet5, endOfPassWriteIndex: 38}});
try {
renderPassEncoder2.executeBundles([renderBundle10, renderBundle10]);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer45, 'uint16', 2_020, 1_343);
} catch {}
try {
commandEncoder65.copyBufferToBuffer(buffer25, 1272, buffer59, 3820, 92);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1024 */
  offset: 1024,
  bytesPerRow: 2304,
  buffer: buffer2,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 26, y: 33, z: 1},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView96 = texture59.createView({label: '\u0921\u023b\u31e5\u1cc4\u0d3d\u{1f730}\u0e94'});
let externalTexture10 = device0.importExternalTexture({source: videoFrame7});
try {
renderPassEncoder13.setBindGroup(0, bindGroup36, new Uint32Array(1118), 308, 0);
} catch {}
try {
renderPassEncoder11.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer25, 'uint16', 842, 226);
} catch {}
let bindGroup41 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 578, resource: {buffer: buffer8, offset: 0, size: 3400}},
    {binding: 254, resource: {buffer: buffer33, offset: 0, size: 268}},
    {binding: 62, resource: textureView7},
  ],
});
let buffer63 = device0.createBuffer({
  size: 6598,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder83 = device0.createCommandEncoder({});
let sampler40 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 80.96,
  maxAnisotropy: 14,
});
try {
computePassEncoder47.setBindGroup(0, bindGroup41);
} catch {}
try {
computePassEncoder59.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup26, new Uint32Array(543), 150, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer8, 0, 2_297);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 22, height: 10, depthOrArrayLayers: 55}
*/
{
  source: imageData4,
  origin: { x: 7, y: 7 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup42 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView53}]});
let textureView97 = texture3.createView({});
let computePassEncoder65 = commandEncoder65.beginComputePass({});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder65.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup9, new Uint32Array(4395), 446, 0);
} catch {}
try {
renderPassEncoder9.draw(5, 23, 0, 880_174_241);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer52, 196);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(7, buffer0, 0, 6_383);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer29, 'uint16', 556, 1_331);
} catch {}
document.body.append(img0);
let recycledExplicitBindGroupLayout3 = pipeline5.getBindGroupLayout(0);
let texture71 = device0.createTexture({
  size: {width: 180},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle13 = renderBundleEncoder13.finish({});
try {
computePassEncoder2.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder64.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder9.draw(0, 26, 0, 135_633_785);
} catch {}
try {
renderPassEncoder9.drawIndexed(4, 146, 5, 450_862_529, 204_120_250);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer54, 644);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer54, 16);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(5, buffer7, 0, 238);
} catch {}
try {
commandEncoder76.copyTextureToBuffer({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 3},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1112 */
  offset: 1112,
  buffer: buffer49,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
let canvas3 = document.createElement('canvas');
let textureView98 = texture51.createView({dimension: 'cube', baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder66 = commandEncoder83.beginComputePass();
try {
computePassEncoder52.setBindGroup(3, bindGroup3, new Uint32Array(1771), 557, 0);
} catch {}
try {
renderPassEncoder9.draw(2, 263, 0, 341_174_858);
} catch {}
try {
computePassEncoder27.insertDebugMarker('\u0f98');
} catch {}
let bindGroup43 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 89, resource: {buffer: buffer27, offset: 1280, size: 2884}},
    {binding: 61, resource: textureView13},
  ],
});
let texture72 = device0.createTexture({
  size: {width: 90, height: 40, depthOrArrayLayers: 45},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView99 = texture48.createView({});
let computePassEncoder67 = commandEncoder82.beginComputePass({});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
let sampler41 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat'});
try {
computePassEncoder63.setBindGroup(2, bindGroup41, new Uint32Array(1755), 175, 0);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup17);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer56, 'uint32', 3_184, 1_587);
} catch {}
try {
commandEncoder78.copyTextureToBuffer({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 7},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1072 widthInBlocks: 134 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 744 */
  offset: 744,
  buffer: buffer33,
}, {width: 134, height: 0, depthOrArrayLayers: 1});
} catch {}
let buffer64 = device0.createBuffer({size: 4342, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder84 = device0.createCommandEncoder({});
let texture73 = device0.createTexture({
  size: {width: 90, height: 40, depthOrArrayLayers: 4},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView100 = texture0.createView({dimension: '2d', format: 'astc-5x4-unorm', baseArrayLayer: 9});
let sampler42 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat'});
try {
computePassEncoder61.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup7, new Uint32Array(1434), 405, 0);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer19, 'uint32', 1_624, 659);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let textureView101 = texture73.createView({arrayLayerCount: 1});
let textureView102 = texture7.createView({aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 1});
let computePassEncoder68 = commandEncoder84.beginComputePass();
let renderPassEncoder16 = commandEncoder78.beginRenderPass({
  colorAttachments: [{
  view: textureView52,
  clearValue: { r: 406.4, g: -317.1, b: -293.1, a: 233.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder65.setBindGroup(1, bindGroup30);
} catch {}
try {
computePassEncoder66.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup11, new Uint32Array(647), 33, 0);
} catch {}
try {
renderPassEncoder9.draw(0, 60, 0, 235_869_617);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer58, 'uint32', 4_248, 214);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer53);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup7, new Uint32Array(378), 38, 0);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(6, buffer32, 0);
} catch {}
try {
commandEncoder76.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 584 */
  offset: 584,
  bytesPerRow: 60160,
  buffer: buffer47,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder44.pushDebugGroup('\u02c0');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: offscreenCanvas1,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 126, y: 11, z: 4},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 21, depthOrArrayLayers: 0});
} catch {}
let canvas4 = document.createElement('canvas');
let texture74 = device0.createTexture({
  size: {width: 258},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView103 = texture64.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 5});
let renderPassEncoder17 = commandEncoder76.beginRenderPass({
  colorAttachments: [{
  view: textureView50,
  clearValue: { r: -554.3, g: -11.13, b: -455.2, a: -997.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet2,
  maxDrawCount: 345948540,
});
try {
computePassEncoder68.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup28, new Uint32Array(1039), 67, 0);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(2, buffer0, 26_968);
} catch {}
try {
commandEncoder80.copyBufferToBuffer(buffer29, 2988, buffer36, 460, 272);
} catch {}
try {
commandEncoder80.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 952 */
  offset: 952,
  buffer: buffer25,
}, {
  texture: texture54,
  mipLevel: 1,
  origin: {x: 36, y: 0, z: 10},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup44 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 8, resource: externalTexture5}]});
let commandEncoder85 = device0.createCommandEncoder({});
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 183});
let textureView104 = texture72.createView({format: 'rgba8uint'});
let renderPassEncoder18 = commandEncoder80.beginRenderPass({
  colorAttachments: [{
  view: textureView71,
  clearValue: { r: 984.2, g: -133.9, b: -358.9, a: 160.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder37.setBindGroup(3, bindGroup5, new Uint32Array(1050), 337, 0);
} catch {}
try {
computePassEncoder58.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder9.draw(0, 59, 0, 582_264_719);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer32, 1_548);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer56, 'uint32', 3_784, 593);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer19, 1_908);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup23, new Uint32Array(2348), 102, 0);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(3, buffer46, 0, 25);
} catch {}
try {
commandEncoder85.copyBufferToBuffer(buffer48, 1272, buffer30, 456, 272);
} catch {}
let commandEncoder86 = device0.createCommandEncoder({});
let textureView105 = texture74.createView({});
let computePassEncoder69 = commandEncoder86.beginComputePass({});
let externalTexture11 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'display-p3'});
try {
renderPassEncoder18.setBindGroup(0, bindGroup6, new Uint32Array(2965), 737, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(56, 191, 7, 715_936_075, 810_149_272);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup28, new Uint32Array(1700), 243, 0);
} catch {}
let pipelineLayout15 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout2]});
let textureView106 = texture71.createView({});
let textureView107 = texture57.createView({mipLevelCount: 1});
let computePassEncoder70 = commandEncoder85.beginComputePass();
try {
computePassEncoder62.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup44);
} catch {}
try {
renderPassEncoder18.setStencilReference(137);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer8, 'uint32', 172, 701);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup42, new Uint32Array(1504), 576, 0);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer41, 'uint16', 94, 21);
} catch {}
let textureView108 = texture3.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder43.setBindGroup(2, bindGroup8, []);
} catch {}
try {
computePassEncoder29.end();
} catch {}
try {
computePassEncoder57.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder13.setBlendConstant({ r: 225.3, g: -625.2, b: 237.3, a: -106.6, });
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer16, 344);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(4, buffer39);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 17},
  aspect: 'all',
}, new Uint8Array(100_855).fill(153), /* required buffer size: 100_855 */
{offset: 195, bytesPerRow: 114, rowsPerImage: 63}, {width: 14, height: 1, depthOrArrayLayers: 15});
} catch {}
let imageData9 = new ImageData(16, 16);
try {
canvas4.getContext('webgl');
} catch {}
let texture75 = device0.createTexture({
  size: {width: 180, height: 1, depthOrArrayLayers: 16},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder71 = commandEncoder36.beginComputePass({});
let renderBundle14 = renderBundleEncoder14.finish({});
let sampler43 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  lodMaxClamp: 95.23,
});
try {
computePassEncoder67.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder9.drawIndexed(8, 22, 84, -1_976_737_960, 417_776_386);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer26, 7_028);
} catch {}
let canvas5 = document.createElement('canvas');
let bindGroup45 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 282, resource: externalTexture7},
    {binding: 37, resource: {buffer: buffer24, offset: 256, size: 388}},
    {binding: 7, resource: textureView14},
  ],
});
let textureView109 = texture6.createView({});
let sampler44 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder37.setBindGroup(1, bindGroup41, new Uint32Array(435), 184, 0);
} catch {}
try {
computePassEncoder69.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup36, new Uint32Array(4215), 443, 0);
} catch {}
try {
renderPassEncoder8.setScissorRect(10, 0, 1, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer51);
} catch {}
document.body.prepend(img0);
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpteSt4281', transfer: 'bt2020_12bit'} });
let bindGroup46 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 578, resource: {buffer: buffer25, offset: 512, size: 3692}}],
});
let commandEncoder87 = device0.createCommandEncoder({});
let computePassEncoder72 = commandEncoder87.beginComputePass({timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 129}});
try {
renderPassEncoder13.setBindGroup(0, bindGroup17, []);
} catch {}
try {
renderPassEncoder9.draw(0, 1, 0, 60_991_517);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer16, 100);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(173).fill(7), /* required buffer size: 173 */
{offset: 173, rowsPerImage: 1}, {width: 92, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline10 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule0}});
document.body.append(canvas1);
let imageData10 = new ImageData(8, 60);
let commandEncoder88 = device0.createCommandEncoder({});
let textureView110 = texture73.createView({baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder73 = commandEncoder88.beginComputePass();
let sampler45 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.43,
  maxAnisotropy: 17,
});
try {
computePassEncoder5.setBindGroup(0, bindGroup41, new Uint32Array(1166), 666, 0);
} catch {}
try {
computePassEncoder70.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup19, new Uint32Array(318), 91, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(59, 88, 31, 372_378_762, 1_111_060_869);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer39, 28);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer29, 632);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline7);
} catch {}
try {
buffer54.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let gpuCanvasContext4 = canvas3.getContext('webgpu');
let pipelineLayout16 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]});
let commandEncoder89 = device0.createCommandEncoder({});
let texture76 = device0.createTexture({
  size: {width: 22, height: 10, depthOrArrayLayers: 4},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder74 = commandEncoder89.beginComputePass({});
try {
computePassEncoder59.setBindGroup(1, bindGroup27);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup0, new Uint32Array(203), 151, 0);
} catch {}
try {
renderPassEncoder15.end();
} catch {}
try {
renderPassEncoder10.setScissorRect(26, 256, 9, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(81, 3, 0, 256_768_296, 859_433_731);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer61, 'uint16', 3_420, 1_327);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(4, buffer32, 436, 1_733);
} catch {}
try {
commandEncoder74.copyBufferToBuffer(buffer50, 944, buffer44, 1092, 596);
} catch {}
let renderPassEncoder19 = commandEncoder74.beginRenderPass({
  colorAttachments: [{
  view: textureView55,
  clearValue: { r: 907.6, g: 70.46, b: -759.3, a: -377.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet6,
  maxDrawCount: 43688920,
});
let sampler46 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', minFilter: 'nearest', lodMaxClamp: 97.15});
try {
computePassEncoder63.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer32, 792);
} catch {}
let bindGroup47 = device0.createBindGroup({layout: veryExplicitBindGroupLayout12, entries: [{binding: 6, resource: textureView27}]});
let texture77 = device0.createTexture({
  label: '\u3195\u4b1c\u42ab\u03f0\u{1f7c6}\u45f9\ue095\u0185\ud5a5\u0680',
  size: [180, 80, 91],
  dimension: '3d',
  format: 'r8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture78 = device0.createTexture({
  size: {width: 360, height: 1, depthOrArrayLayers: 1},
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView111 = texture65.createView({baseArrayLayer: 0});
let sampler47 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMaxClamp: 95.75,
  compare: 'never',
});
try {
renderPassEncoder7.setScissorRect(16, 0, 3, 0);
} catch {}
try {
renderPassEncoder9.draw(0, 41, 0, 195_555_687);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer34, 708);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer35, 'uint32', 2_616, 848);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(1, buffer39, 0, 42);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let pipeline11 = await promise12;
let recycledExplicitBindGroupLayout4 = pipeline1.getBindGroupLayout(0);
let bindGroup48 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 578, resource: {buffer: buffer26, offset: 1024}}],
});
let buffer65 = device0.createBuffer({size: 273, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let textureView112 = texture72.createView({mipLevelCount: 1});
let textureView113 = texture40.createView({aspect: 'all', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder54.setBindGroup(3, bindGroup21, new Uint32Array(3032), 169, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(85, 7, 48, 211_134_964, 461_921_618);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer39, 24);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer27, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder44.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer49, 272, new Float32Array(10069), 6178, 1232);
} catch {}
try {
externalTexture2.label = '\u7162\u{1f97c}\ue0fd\u1085\u5e88';
} catch {}
let bindGroup49 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 578, resource: {buffer: buffer63, offset: 1024, size: 3404}}],
});
let commandEncoder90 = device0.createCommandEncoder({});
let renderPassEncoder20 = commandEncoder90.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 341,
  clearValue: { r: -266.7, g: 210.7, b: 323.4, a: -384.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet6,
});
let sampler48 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 65.93,
  maxAnisotropy: 8,
});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer62, 272); };
} catch {}
try {
renderPassEncoder9.draw(2, 71, 8, 1_814_235_494);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline2);
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470m', transfer: 'smpteSt4281'} });
let texture79 = device0.createTexture({
  size: {width: 360, height: 1, depthOrArrayLayers: 818},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView114 = texture23.createView({dimension: '2d', format: 'rgba16uint', baseArrayLayer: 1});
try {
computePassEncoder55.setBindGroup(3, bindGroup10);
} catch {}
try {
computePassEncoder71.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder9.draw(0, 460, 0, 120_091_961);
} catch {}
try {
renderPassEncoder9.drawIndexed(13, 556, 12, 561_264_646, 1_589_500_423);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer6, 260);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer16, 1_044);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer9, 'uint32', 288, 225);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder25.insertDebugMarker('\u03b7');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 83},
  aspect: 'all',
}, new Uint8Array(2_866_010).fill(221), /* required buffer size: 2_866_010 */
{offset: 26, bytesPerRow: 276, rowsPerImage: 176}, {width: 25, height: 0, depthOrArrayLayers: 60});
} catch {}
let buffer66 = device0.createBuffer({size: 12229, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture80 = device0.createTexture({
  label: '\udac8\u6115\u512b\u0ce2\u2d01\u09ff\u5dd7\u59b2\u{1fa8a}\u09f2\u6ec0',
  size: [258],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], stencilReadOnly: true});
try {
computePassEncoder36.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder5.end();
} catch {}
try {
computePassEncoder72.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup16);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup31, new Uint32Array(1063), 631, 0);
} catch {}
try {
renderPassEncoder11.beginOcclusionQuery(48);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(7, buffer10, 0);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer3, 'uint32', 11_376, 2_399);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder5.copyTextureToTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 80},
  aspect: 'all',
},
{
  texture: texture27,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 44, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas4);
let commandEncoder91 = device0.createCommandEncoder({});
let computePassEncoder75 = commandEncoder91.beginComputePass();
try {
computePassEncoder46.setBindGroup(0, bindGroup10, new Uint32Array(1386), 662, 0);
} catch {}
try {
computePassEncoder75.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup41, new Uint32Array(125), 2, 0);
} catch {}
try {
renderPassEncoder11.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder9.drawIndexed(18, 102, 122, -1_508_695_862, 136_147_307);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer42, 'uint16', 104, 650);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(0, undefined, 259_999_440);
} catch {}
try {
buffer29.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer51, 3848, new BigUint64Array(1245));
} catch {}
let buffer67 = device0.createBuffer({
  size: 18064,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let textureView115 = texture71.createView({});
let textureView116 = texture69.createView({mipLevelCount: 2});
try {
computePassEncoder74.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder18.setBindGroup(2, bindGroup19);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup37, new Uint32Array(40), 3, 0);
} catch {}
try {
renderPassEncoder9.draw(0, 16, 0, 455_766_476);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer19, 'uint16', 28, 964);
} catch {}
try {
commandEncoder5.copyBufferToBuffer(buffer35, 11580, buffer58, 1960, 1780);
} catch {}
try {
commandEncoder5.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 504 */
  offset: 504,
  buffer: buffer25,
}, {
  texture: texture30,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData11 = new ImageData(64, 48);
let autogeneratedBindGroupLayout5 = pipeline8.getBindGroupLayout(0);
let computePassEncoder76 = commandEncoder5.beginComputePass({});
let sampler49 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 90.79});
try {
computePassEncoder39.setBindGroup(0, bindGroup10, new Uint32Array(1701), 311, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroupsIndirect(buffer40, 964); };
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle6, renderBundle1]);
} catch {}
try {
renderPassEncoder16.setBlendConstant({ r: -552.5, g: -159.1, b: -481.6, a: -545.8, });
} catch {}
try {
renderPassEncoder16.setViewport(9.779028947576597, 0.3867687559122277, 22.811887668827193, 0.2378276509913158, 0.6416339444556813, 0.8233451268175345);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup2);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline5);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let imageData12 = new ImageData(4, 160);
try {
globalThis.someLabel = externalTexture3.label;
} catch {}
let bindGroup50 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout4,
  entries: [
    {binding: 578, resource: {buffer: buffer0, offset: 1536, size: 7804}},
    {binding: 62, resource: textureView7},
    {binding: 254, resource: {buffer: buffer24, offset: 256, size: 1784}},
  ],
});
let commandEncoder92 = device0.createCommandEncoder({});
let computePassEncoder77 = commandEncoder92.beginComputePass();
try {
computePassEncoder50.setBindGroup(2, bindGroup14);
} catch {}
try {
computePassEncoder73.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup29, new Uint32Array(1450), 383, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder9.draw(1, 190, 11, 2_512_225_053);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(4, buffer32, 11_920);
} catch {}
let sampler50 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 80.54,
  compare: 'always',
  maxAnisotropy: 1,
});
try {
computePassEncoder9.setBindGroup(2, bindGroup22);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroupsIndirect(buffer40, 1_240); };
} catch {}
try {
renderPassEncoder7.setScissorRect(1, 0, 41, 0);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(7, buffer62, 164);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup21);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(0, buffer63, 4_240, 719);
} catch {}
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {binding: 47, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 169,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 192,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 267, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 359,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let textureView117 = texture61.createView({});
let sampler51 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.04,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup14, new Uint32Array(1203), 535, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroupsIndirect(buffer26, 7_856); };
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup49);
} catch {}
try {
renderPassEncoder9.drawIndexed(53, 289, 13, -1_558_128_493, 741_259_237);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer32, 216);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer27, 1_448);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer0, 'uint32', 2_920, 48);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline2);
} catch {}
let promise14 = device0.createComputePipelineAsync({layout: pipelineLayout13, compute: {module: shaderModule0}});
let pipeline12 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  multisample: {mask: 0x2d4a8bb8},
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 24,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 0, shaderLocation: 13},
          {format: 'snorm16x4', offset: 0, shaderLocation: 12},
        ],
      },
    ],
  },
});
let texture81 = device0.createTexture({
  size: [90, 1, 1],
  sampleCount: 4,
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle15 = renderBundleEncoder15.finish({});
let sampler52 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 72.55,
  compare: 'equal',
});
try {
computePassEncoder30.setBindGroup(2, bindGroup20);
} catch {}
try {
renderPassEncoder9.draw(2, 90, 3, 242_313_760);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer34, 1_864);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer62, 'uint16', 56, 435);
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'unspecified', transfer: 'gamma28curve'} });
let commandEncoder93 = device0.createCommandEncoder({});
let textureView118 = texture74.createView({});
let texture82 = device0.createTexture({
  size: {width: 45, height: 1, depthOrArrayLayers: 4},
  sampleCount: 1,
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder78 = commandEncoder93.beginComputePass({});
try {
computePassEncoder42.setBindGroup(3, bindGroup10, new Uint32Array(837), 37, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup2, new Uint32Array(2163), 126, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer52, 76);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(5, buffer54, 896);
} catch {}
let arrayBuffer1 = buffer37.getMappedRange(848, 52);
let buffer68 = device0.createBuffer({
  size: 15597,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
});
try {
computePassEncoder47.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup46, new Uint32Array(1727), 237, 0);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder9.drawIndexed(31, 9, 66, 171_669_834, 1_080_811_326);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline5);
} catch {}
try {
device0.queue.writeBuffer(buffer68, 5336, new Int16Array(2764), 509, 16);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 11, height: 5, depthOrArrayLayers: 55}
*/
{
  source: imageData10,
  origin: { x: 5, y: 0 },
  flipY: true,
}, {
  texture: texture47,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 17},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await promise13;
} catch {}
try {
canvas5.getContext('webgpu');
} catch {}
try {
computePassEncoder78.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer8, 324);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(6, buffer53, 2_680, 280);
} catch {}
let commandEncoder94 = device0.createCommandEncoder({});
let textureView119 = texture51.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 5});
let computePassEncoder79 = commandEncoder94.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 41}});
try {
renderPassEncoder9.end();
} catch {}
try {
renderPassEncoder17.setStencilReference(3772);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer53, 828, 18);
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture44,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 4},
  aspect: 'all',
},
{
  texture: texture79,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 121},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture54,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 6},
  aspect: 'all',
}, new Uint8Array(28).fill(63), /* required buffer size: 28 */
{offset: 28, rowsPerImage: 37}, {width: 27, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let imageData13 = new ImageData(44, 48);
let commandEncoder95 = device0.createCommandEncoder({});
let computePassEncoder80 = commandEncoder95.beginComputePass({});
try {
computePassEncoder80.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeBuffer(buffer43, 12, new BigUint64Array(8338), 1402, 0);
} catch {}
let bindGroup51 = device0.createBindGroup({layout: veryExplicitBindGroupLayout9, entries: [{binding: 6, resource: textureView43}]});
let texture83 = device0.createTexture({
  size: [360, 1, 75],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder34.setBindGroup(1, bindGroup20, new Uint32Array(2007), 123, 0);
} catch {}
try {
computePassEncoder79.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup37);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle0, renderBundle5, renderBundle1]);
} catch {}
try {
buffer45.unmap();
} catch {}
try {
commandEncoder49.copyTextureToBuffer({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 512 widthInBlocks: 64 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1024 */
  offset: 1024,
  buffer: buffer62,
}, {width: 64, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer44, 148, new Int16Array(9784), 4753, 108);
} catch {}
let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 328,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let bindGroup52 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [
    {binding: 254, resource: {buffer: buffer26, offset: 3328}},
    {binding: 62, resource: textureView9},
    {binding: 578, resource: {buffer: buffer24, offset: 0, size: 3520}},
  ],
});
let commandEncoder96 = device0.createCommandEncoder({});
let textureView120 = texture76.createView({format: 'rgba16uint', arrayLayerCount: 1});
try {
computePassEncoder76.setPipeline(pipeline10);
} catch {}
let arrayBuffer2 = buffer37.getMappedRange(976, 168);
try {
commandEncoder49.copyBufferToTexture({
  /* bytesInLastRow: 1296 widthInBlocks: 162 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 872 */
  offset: 872,
  bytesPerRow: 6912,
  rowsPerImage: 703,
  buffer: buffer50,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
}, {width: 162, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup53 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout4,
  entries: [
    {binding: 62, resource: textureView9},
    {binding: 254, resource: {buffer: buffer8, offset: 1536, size: 644}},
    {binding: 578, resource: {buffer: buffer16, offset: 0, size: 3300}},
  ],
});
let computePassEncoder81 = commandEncoder49.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 414, endOfPassWriteIndex: 147}});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder11.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer11, 0);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
commandEncoder96.copyBufferToTexture({
  /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1312 */
  offset: 1312,
  bytesPerRow: 22528,
  buffer: buffer3,
}, {
  texture: texture2,
  mipLevel: 0,
  origin: {x: 16, y: 32, z: 0},
  aspect: 'all',
}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let renderPassEncoder21 = commandEncoder96.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 97,
  clearValue: { r: -496.0, g: -852.5, b: -299.9, a: 4.245, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup17, new Uint32Array(457), 4, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle11, renderBundle13, renderBundle13, renderBundle11, renderBundle13]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer45, 'uint16', 134, 8_133);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup34, new Uint32Array(2295), 571, 0);
} catch {}
try {
renderBundleEncoder16.insertDebugMarker('\u{1f7e3}');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture51,
  mipLevel: 1,
  origin: {x: 1, y: 29, z: 1},
  aspect: 'all',
}, new Uint8Array(38_331).fill(12), /* required buffer size: 38_331 */
{offset: 295, bytesPerRow: 332, rowsPerImage: 65}, {width: 94, height: 50, depthOrArrayLayers: 2});
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpteRp431', transfer: 'log'} });
try {
bindGroup0.label = '\u{1f6f1}\u22c3\u00a0\u{1fcaa}\ue334\u3b04\ua8c3\u095b\u3cbf\u0ef9';
} catch {}
let commandEncoder97 = device0.createCommandEncoder({});
let textureView121 = texture38.createView({dimension: '2d', baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder82 = commandEncoder97.beginComputePass();
let externalTexture12 = device0.importExternalTexture({source: videoFrame12, colorSpace: 'srgb'});
try {
computePassEncoder82.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer29, 'uint16', 564, 1_028);
} catch {}
let bindGroup54 = device0.createBindGroup({layout: veryExplicitBindGroupLayout12, entries: [{binding: 6, resource: textureView27}]});
let pipelineLayout17 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout2]});
let buffer69 = device0.createBuffer({size: 1620, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView122 = texture13.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 6});
let texture84 = device0.createTexture({
  size: [45, 20, 146],
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer62, 336); };
} catch {}
try {
computePassEncoder77.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup31);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer29, 'uint32', 848, 3_068);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(6, buffer43, 4, 4);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup16);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(5, buffer27, 0);
} catch {}
let pipeline13 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
let buffer70 = device0.createBuffer({
  size: 45214,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder98 = device0.createCommandEncoder({});
try {
computePassEncoder75.setBindGroup(3, bindGroup31, new Uint32Array(1733), 728, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder11.end();
} catch {}
try {
computePassEncoder81.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder5.beginOcclusionQuery(3);
} catch {}
try {
renderPassEncoder5.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup12);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup50, new Uint32Array(35), 2, 0);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(1, buffer39, 0, 17);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(81).fill(123), /* required buffer size: 81 */
{offset: 81}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 62, resource: textureView18},
    {binding: 254, resource: {buffer: buffer54, offset: 1024, size: 284}},
    {binding: 578, resource: {buffer: buffer66, offset: 3072, size: 4004}},
  ],
});
let renderPassEncoder22 = commandEncoder98.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 334,
  clearValue: { r: 338.8, g: -267.6, b: 872.2, a: 583.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet5},
  maxDrawCount: 96000909,
});
let sampler53 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 98.51});
try {
computePassEncoder24.setBindGroup(3, bindGroup49);
} catch {}
try {
computePassEncoder47.end();
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup10);
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup3);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer54);
} catch {}
try {
commandEncoder56.copyBufferToTexture({
  /* bytesInLastRow: 104 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 224 */
  offset: 224,
  buffer: buffer54,
}, {
  texture: texture19,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder56.copyTextureToTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 26},
  aspect: 'all',
},
{
  texture: texture43,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageBitmap3 = await createImageBitmap(imageData13);
let bindGroup56 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout14,
  entries: [{binding: 20, resource: textureView91}, {binding: 483, resource: textureView45}],
});
let buffer71 = device0.createBuffer({
  label: '\u0d8b\u{1fa82}',
  size: 26869,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder99 = device0.createCommandEncoder();
let commandBuffer3 = commandEncoder13.finish();
let textureView123 = texture49.createView({});
let sampler54 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 54.12});
try {
computePassEncoder43.setBindGroup(1, bindGroup18, new Uint32Array(5314), 1_014, 0);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer70, 'uint16', 9_750, 6_239);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer67, 'uint16', 844, 100);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup57 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 8, resource: externalTexture5}]});
let buffer72 = device0.createBuffer({
  size: 4314,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let computePassEncoder83 = commandEncoder56.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 260, endOfPassWriteIndex: 146}});
let renderPassEncoder23 = commandEncoder99.beginRenderPass({colorAttachments: [{view: textureView107, depthSlice: 117, loadOp: 'load', storeOp: 'store'}]});
let sampler55 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 60.52,
  maxAnisotropy: 13,
});
let externalTexture13 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'});
try {
renderPassEncoder19.setBindGroup(1, bindGroup55);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer7, 196, 473);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup31, new Uint32Array(3125), 362, 0);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer54, 'uint16', 6, 608);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(4, buffer49, 0, 1_201);
} catch {}
let promise15 = shaderModule3.getCompilationInfo();
try {
renderBundleEncoder16.insertDebugMarker('\u06fc');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 48, y: 15, z: 1},
  aspect: 'all',
}, new Uint8Array(83).fill(120), /* required buffer size: 83 */
{offset: 83, bytesPerRow: 30, rowsPerImage: 107}, {width: 6, height: 5, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
let bindGroup58 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: [{binding: 176, resource: textureView51}]});
let sampler56 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 85.34});
try {
computePassEncoder83.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup17, []);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup7, new Uint32Array(2938), 72, 0);
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup10);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer8, 'uint16', 158, 34);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(6, buffer31, 0, 311);
} catch {}
let commandEncoder100 = device0.createCommandEncoder({});
let computePassEncoder84 = commandEncoder100.beginComputePass({});
try {
computePassEncoder48.setBindGroup(2, bindGroup35, new Uint32Array(5028), 61, 0);
} catch {}
try {
computePassEncoder84.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer65, 'uint32', 36, 98);
} catch {}
document.body.prepend(img0);
let textureView124 = texture27.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let sampler57 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest', lodMaxClamp: 92.07});
try {
renderPassEncoder17.setBindGroup(2, bindGroup56, new Uint32Array(1757), 102, 0);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(1, buffer58, 6_732, 1_667);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer45, 'uint32', 6_504, 945);
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
let bindGroup59 = device0.createBindGroup({
  label: '\u{1f64a}\u03e0\uabcf\u5aeb\u67b7\u8f36\uc95a',
  layout: veryExplicitBindGroupLayout12,
  entries: [{binding: 6, resource: textureView43}],
});
let commandEncoder101 = device0.createCommandEncoder();
let computePassEncoder85 = commandEncoder101.beginComputePass({label: '\uff89\u0388\u{1f88b}'});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true});
try {
renderPassEncoder16.setBindGroup(0, bindGroup53);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup50, new Uint32Array(5), 0, 0);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(3, buffer46, 0);
} catch {}
try {
renderPassEncoder21.insertDebugMarker('\u8d52');
} catch {}
let commandEncoder102 = device0.createCommandEncoder({});
let renderBundle16 = renderBundleEncoder16.finish();
try {
renderBundleEncoder17.setVertexBuffer(5, buffer9, 776);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture64,
  mipLevel: 0,
  origin: {x: 18, y: 18, z: 2},
  aspect: 'all',
}, new Uint8Array(27_093).fill(57), /* required buffer size: 27_093 */
{offset: 445, bytesPerRow: 329, rowsPerImage: 17}, {width: 82, height: 13, depthOrArrayLayers: 5});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup60 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView8}]});
let commandEncoder103 = device0.createCommandEncoder();
let textureView125 = texture75.createView({dimension: '2d', format: 'rgba16float', baseArrayLayer: 1});
let renderPassEncoder24 = commandEncoder103.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 31,
  clearValue: { r: -789.3, g: -823.5, b: -86.78, a: -125.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 30},
  maxDrawCount: 326277004,
});
try {
renderBundleEncoder17.setIndexBuffer(buffer61, 'uint16', 4_668, 1_640);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(2, buffer44, 0, 100);
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
let bindGroup61 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout14,
  entries: [{binding: 483, resource: textureView53}, {binding: 20, resource: textureView90}],
});
let buffer73 = device0.createBuffer({size: 1458, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder104 = device0.createCommandEncoder({});
let querySet7 = device0.createQuerySet({type: 'occlusion', count: 276});
let textureView126 = texture36.createView({dimension: '2d-array'});
try {
computePassEncoder85.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle11, renderBundle11, renderBundle13, renderBundle11, renderBundle13, renderBundle13, renderBundle13, renderBundle13, renderBundle11]);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer8, 'uint32', 432, 117);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(2, buffer19);
} catch {}
try {
device0.queue.writeBuffer(buffer59, 2380, new Float32Array(10081), 1362, 168);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageBitmap2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 30, y: 39, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise17 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule1, targets: [{format: 'rgba16uint'}]},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 540,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 8, shaderLocation: 13},
          {format: 'unorm16x4', offset: 0, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'back'},
});
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder105 = device0.createCommandEncoder({});
try {
renderPassEncoder8.setViewport(31.563051150223217, 0.39734681755390844, 8.612264553893592, 0.46501640801701305, 0.4353479241868907, 0.842862508459725);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline5);
} catch {}
try {
  await promise16;
} catch {}
let bindGroup62 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 328, resource: textureView8}]});
let commandEncoder106 = device0.createCommandEncoder({});
try {
computePassEncoder35.setBindGroup(3, bindGroup46);
} catch {}
try {
computePassEncoder39.setBindGroup(1, bindGroup29, new Uint32Array(221), 8, 0);
} catch {}
try {
computePassEncoder53.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup61);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup15, new Uint32Array(1536), 1_177, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer54, 'uint32', 732, 206);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup16);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer74 = device0.createBuffer({
  size: 2552,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder86 = commandEncoder102.beginComputePass({});
let sampler58 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', mipmapFilter: 'nearest', lodMaxClamp: 99.26});
try {
computePassEncoder31.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder86.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder18.setViewport(40.262401558956185, 183.3232525289417, 204.13367230244708, 49.89174438943546, 0.8596863144656678, 0.990696630081272);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(3, buffer48, 308);
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, colorSpace: 'srgb'});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline14 = await promise17;
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let texture85 = device0.createTexture({
  size: {width: 258},
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder87 = commandEncoder104.beginComputePass();
let sampler59 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.18,
});
try {
renderPassEncoder2.setBindGroup(2, bindGroup34, new Uint32Array(3043), 616, 0);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(1, undefined, 0, 280_703_549);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup51, new Uint32Array(2241), 21, 0);
} catch {}
let imageData14 = new ImageData(64, 24);
try {
adapter0.label = '\uc2eb\ucf83\u{1f8d8}\u5b36';
} catch {}
let bindGroup63 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 127, resource: {buffer: buffer26, offset: 256}}, {binding: 8, resource: textureView6}],
});
let texture86 = device0.createTexture({
  size: {width: 180},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder88 = commandEncoder106.beginComputePass({});
let sampler60 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 97.62});
try {
renderBundleEncoder17.setBindGroup(2, bindGroup58);
} catch {}
let computePassEncoder89 = commandEncoder105.beginComputePass({});
let renderBundle17 = renderBundleEncoder17.finish({});
let sampler61 = device0.createSampler({addressModeU: 'repeat'});
try {
computePassEncoder80.setBindGroup(1, bindGroup62, []);
} catch {}
try {
computePassEncoder88.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(7, buffer46, 0);
} catch {}
try {
computePassEncoder83.pushDebugGroup('\u0124');
} catch {}
let recycledExplicitBindGroupLayout5 = pipeline11.getBindGroupLayout(0);
let commandEncoder107 = device0.createCommandEncoder({});
try {
computePassEncoder34.setBindGroup(1, bindGroup46, new Uint32Array(875), 105, 0);
} catch {}
try {
renderPassEncoder14.drawIndexedIndirect(buffer47, 1_212);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer62, 272);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline11);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData6,
  origin: { x: 3, y: 3 },
  flipY: true,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 16, y: 22, z: 8},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 4, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let bindGroup64 = device0.createBindGroup({layout: veryExplicitBindGroupLayout17, entries: [{binding: 328, resource: textureView68}]});
let renderPassEncoder25 = commandEncoder107.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 525,
  clearValue: { r: -248.6, g: -131.1, b: 489.2, a: 357.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 766, endOfPassWriteIndex: 568},
});
let sampler62 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 53.99,
  maxAnisotropy: 13,
});
try {
renderPassEncoder11.beginOcclusionQuery(61);
} catch {}
try {
renderPassEncoder11.endOcclusionQuery();
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle11, renderBundle13, renderBundle13]);
} catch {}
try {
renderPassEncoder2.setScissorRect(33, 0, 13, 0);
} catch {}
try {
renderPassEncoder14.draw(853_275_355, 6, 71_341_468, 2_361_542_096);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder83.popDebugGroup();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let offscreenCanvas2 = new OffscreenCanvas(157, 37);
let textureView127 = texture50.createView({format: 'rgba16uint'});
try {
renderPassEncoder14.drawIndexedIndirect(buffer39, 20);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer70, 'uint32', 3_748, 5_908);
} catch {}
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteSt4281', transfer: 'log'} });
let buffer75 = device0.createBuffer({size: 11660, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder108 = device0.createCommandEncoder({});
try {
computePassEncoder21.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup60, new Uint32Array(2559), 892, 0);
} catch {}
try {
renderPassEncoder14.end();
} catch {}
try {
renderPassEncoder10.setScissorRect(28, 54, 1, 64);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline12);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let buffer76 = device0.createBuffer({
  size: 9834,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let renderPassEncoder26 = commandEncoder58.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 195,
  clearValue: { r: 333.1, g: 81.81, b: 637.8, a: -742.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let sampler63 = device0.createSampler({addressModeW: 'repeat', minFilter: 'linear', mipmapFilter: 'nearest'});
try {
buffer48.unmap();
} catch {}
try {
renderPassEncoder25.insertDebugMarker('\u2ff4');
} catch {}
let bindGroup65 = device0.createBindGroup({layout: veryExplicitBindGroupLayout15, entries: [{binding: 3, resource: externalTexture8}]});
let computePassEncoder90 = commandEncoder108.beginComputePass({});
try {
computePassEncoder80.setBindGroup(3, bindGroup21, new Uint32Array(947), 288, 0);
} catch {}
try {
computePassEncoder90.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup11, new Uint32Array(7416), 1_134, 0);
} catch {}
try {
renderPassEncoder25.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder5.setViewport(56.93599816720424, 0.1506541852853549, 15.69715724823619, 0.33153328904309015, 0.3010819095450987, 0.3380238731504279);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer51, 'uint16', 7_760, 561);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(80).fill(120), /* required buffer size: 80 */
{offset: 80, bytesPerRow: 190}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout6 = pipeline9.getBindGroupLayout(0);
let sampler64 = device0.createSampler({addressModeV: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 99.72});
try {
computePassEncoder0.setBindGroup(2, bindGroup61, new Uint32Array(2860), 188, 0);
} catch {}
try {
computePassEncoder34.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup13, new Uint32Array(305), 81, 0);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer43, 'uint16', 2, 8);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline11);
} catch {}
let recycledExplicitBindGroupLayout7 = pipeline4.getBindGroupLayout(0);
let buffer77 = device0.createBuffer({
  size: 2869,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder109 = device0.createCommandEncoder({});
let texture87 = device0.createTexture({
  label: '\uf6fa\u8811\u0cb2',
  size: {width: 90, height: 40, depthOrArrayLayers: 43},
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder91 = commandEncoder109.beginComputePass({});
try {
computePassEncoder91.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer63, 'uint32', 608, 515);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder83.setBindGroup(0, bindGroup41, new Uint32Array(1377), 295, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup21, new Uint32Array(1082), 103, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer1, 'uint32', 52, 40);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline12);
} catch {}
try {
device0.queue.writeBuffer(buffer56, 1072, new DataView(new ArrayBuffer(2582)), 329, 124);
} catch {}
let texture88 = device0.createTexture({
  size: [360, 1, 77],
  mipLevelCount: 5,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder83); computePassEncoder83.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder89.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder25.setBindGroup(3, bindGroup51);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup8, new Uint32Array(1094), 131, 0);
} catch {}
try {
computePassEncoder4.insertDebugMarker('\u882a');
} catch {}
try {
device0.queue.writeBuffer(buffer75, 1288, new Int16Array(2476));
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let promise18 = device0.createComputePipelineAsync({layout: pipelineLayout13, compute: {module: shaderModule2}});
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let commandEncoder110 = device0.createCommandEncoder({});
let texture89 = device0.createTexture({
  size: [90, 1, 78],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder27 = commandEncoder110.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 349,
  clearValue: { r: 98.89, g: 730.4, b: 572.8, a: -254.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], sampleCount: 1, depthReadOnly: true});
try {
computePassEncoder53.setBindGroup(2, bindGroup45);
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup22);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer51, 'uint32', 2_376, 9_010);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(5, buffer54, 4, 1_827);
} catch {}
try {
renderBundleEncoder18.setBindGroup(0, bindGroup19, new Uint32Array(1139), 0, 0);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer68, 'uint32', 1_348, 3_300);
} catch {}
let commandEncoder111 = device0.createCommandEncoder({});
let computePassEncoder92 = commandEncoder111.beginComputePass({});
try {
computePassEncoder70.setBindGroup(2, bindGroup12, new Uint32Array(2005), 1_092, 0);
} catch {}
try {
computePassEncoder92.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle6, renderBundle4]);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer19, 'uint32', 288, 1_784);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder18.setBindGroup(0, bindGroup58);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(6, buffer43);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 168, new DataView(new ArrayBuffer(7112)), 1482, 812);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext5 = offscreenCanvas2.getContext('webgpu');
document.body.append(img0);
let commandEncoder112 = device0.createCommandEncoder({});
try {
renderBundleEncoder18.setVertexBuffer(5, buffer72, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer53, 948, new Int16Array(4140), 331, 324);
} catch {}
let texture90 = device0.createTexture({
  size: {width: 45, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture91 = gpuCanvasContext1.getCurrentTexture();
let textureView128 = texture28.createView({dimension: '3d', baseMipLevel: 1, mipLevelCount: 1});
let computePassEncoder93 = commandEncoder112.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 370, endOfPassWriteIndex: 223}});
try {
renderBundleEncoder18.setIndexBuffer(buffer70, 'uint16', 12_068, 8_681);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
  await promise15;
} catch {}
let bindGroup66 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout1,
  entries: [
    {binding: 578, resource: {buffer: buffer8, offset: 0, size: 3292}},
    {binding: 62, resource: textureView9},
    {binding: 254, resource: {buffer: buffer32, offset: 2560, size: 180}},
  ],
});
let buffer78 = device0.createBuffer({size: 8352, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder4.setVertexBuffer(0, undefined);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let imageData15 = new ImageData(12, 128);
try {
computePassEncoder19.setBindGroup(3, bindGroup19, new Uint32Array(1085), 13, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup34, new Uint32Array(716), 54, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer46);
} catch {}
try {
renderBundleEncoder18.setBindGroup(2, bindGroup17, new Uint32Array(337), 33, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer76, 2004, new Int16Array(27599), 3730, 1536);
} catch {}
let buffer79 = device0.createBuffer({
  size: 2275,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView129 = texture60.createView({dimension: '2d', mipLevelCount: 1});
let sampler65 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
renderBundleEncoder18.setBindGroup(0, bindGroup35, new Uint32Array(1422), 158, 0);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer35, 'uint32', 124, 2_178);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer45, 3316, new Float32Array(8610), 772, 248);
} catch {}
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'hlg'} });
let commandEncoder113 = device0.createCommandEncoder({});
let textureView130 = texture15.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let computePassEncoder94 = commandEncoder113.beginComputePass({});
let sampler66 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 76.01});
try {
computePassEncoder94.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer74, 'uint16', 96, 137);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(6, buffer54, 0, 715);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData8,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 81, y: 11, z: 9},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 9, depthOrArrayLayers: 0});
} catch {}
let bindGroup67 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 328, resource: textureView100}]});
let commandEncoder114 = device0.createCommandEncoder({});
let renderPassEncoder28 = commandEncoder114.beginRenderPass({
  colorAttachments: [{
  view: textureView120,
  clearValue: { r: 614.9, g: 963.2, b: -798.8, a: 188.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet4},
});
let externalTexture14 = device0.importExternalTexture({source: videoFrame5, colorSpace: 'srgb'});
try {
computePassEncoder63.setBindGroup(3, bindGroup11, new Uint32Array(3308), 898, 0);
} catch {}
try {
computePassEncoder93.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder27.end();
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer51, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(326).fill(186), /* required buffer size: 326 */
{offset: 326, rowsPerImage: 225}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let buffer80 = device0.createBuffer({size: 5572, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let computePassEncoder95 = commandEncoder110.beginComputePass({});
try {
computePassEncoder35.setBindGroup(0, bindGroup28, new Uint32Array(3130), 46, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(3, buffer66, 2_072, 2_214);
} catch {}
let texture92 = device0.createTexture({
  size: [1035, 60, 11],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler67 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 13,
});
try {
renderPassEncoder2.setBindGroup(0, bindGroup55);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup2, new Uint32Array(1285), 106, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle10, renderBundle2, renderBundle15, renderBundle1, renderBundle10]);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(6, buffer63);
} catch {}
let promise19 = device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x6d8c9b06},
  fragment: {
  module: shaderModule4,
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex4',
    constants: {},
    buffers: [
      {
        arrayStride: 312,
        attributes: [
          {format: 'sint8x2', offset: 10, shaderLocation: 3},
          {format: 'snorm8x4', offset: 20, shaderLocation: 5},
          {format: 'unorm16x2', offset: 4, shaderLocation: 14},
          {format: 'uint32x2', offset: 24, shaderLocation: 11},
        ],
      },
      {arrayStride: 144, attributes: [{format: 'sint8x2', offset: 20, shaderLocation: 13}]},
    ],
  },
  primitive: {cullMode: 'front'},
});
let commandEncoder115 = device0.createCommandEncoder();
let texture93 = device0.createTexture({
  size: [360, 1, 35],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture94 = device0.createTexture({
  size: [360, 1, 154],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder96 = commandEncoder115.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 304}});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true});
try {
computePassEncoder22.setBindGroup(2, bindGroup19, new Uint32Array(556), 11, 0);
} catch {}
try {
computePassEncoder96.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup17);
} catch {}
try {
renderPassEncoder28.setStencilReference(97);
} catch {}
try {
renderBundleEncoder18.setBindGroup(0, bindGroup67);
} catch {}
try {
buffer77.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(img1);
let commandEncoder116 = device0.createCommandEncoder({});
let texture95 = device0.createTexture({
  size: [45, 20, 22],
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder97 = commandEncoder116.beginComputePass({});
let sampler68 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 35.93,
});
try {
computePassEncoder58.setBindGroup(0, bindGroup59);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer74, 'uint16', 204, 543);
} catch {}
let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({
  entries: [{binding: 8, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}],
});
let buffer81 = device0.createBuffer({
  size: 4177,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView131 = texture95.createView({aspect: 'all', mipLevelCount: 1});
let texture96 = device0.createTexture({
  size: {width: 258, height: 15, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture15 = device0.importExternalTexture({source: videoFrame15, colorSpace: 'srgb'});
try {
renderBundleEncoder19.setVertexBuffer(4, buffer7, 0);
} catch {}
try {
renderBundleEncoder18.insertDebugMarker('\u{1ff24}');
} catch {}
let commandEncoder117 = device0.createCommandEncoder();
let texture97 = device0.createTexture({
  size: [90, 1, 85],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder98 = commandEncoder117.beginComputePass({timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 451}});
let renderBundle18 = renderBundleEncoder18.finish({});
try {
renderPassEncoder26.setBindGroup(1, bindGroup14, new Uint32Array(1944), 86, 0);
} catch {}
try {
renderPassEncoder28.setViewport(19.81482505097011, 8.890805613949821, 2.0186468978344334, 0.9739433606681159, 0.4718213608286993, 0.6147596227719461);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer40, 0);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(2, undefined, 0, 1_254_801_394);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(6).fill(148), /* required buffer size: 6 */
{offset: 6}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 31}
*/
{
  source: imageData12,
  origin: { x: 1, y: 20 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 59, y: 74, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 14, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let querySet8 = device0.createQuerySet({type: 'timestamp', count: 431});
let textureView132 = texture93.createView({dimension: '2d', baseArrayLayer: 8});
try {
renderPassEncoder16.setBindGroup(1, bindGroup62, new Uint32Array(624), 170, 0);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer47, 8, 560);
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte240m', transfer: 'bt709'} });
let bindGroup68 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 254, resource: {buffer: buffer52, offset: 0, size: 8}},
    {binding: 62, resource: textureView18},
    {binding: 578, resource: {buffer: buffer75, offset: 4352, size: 3344}},
  ],
});
let commandEncoder118 = device0.createCommandEncoder({});
let texture98 = device0.createTexture({
  size: [90, 40, 63],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture99 = device0.createTexture({
  size: [22],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder16.setIndexBuffer(buffer41, 'uint16', 64, 138);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(6, buffer34, 3_140, 2_530);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer41);
} catch {}
try {
renderPassEncoder18.pushDebugGroup('\u72be');
} catch {}
try {
renderBundleEncoder19.insertDebugMarker('\u2e5a');
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 22, height: 10, depthOrArrayLayers: 55}
*/
{
  source: imageData15,
  origin: { x: 0, y: 21 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 5},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
let pipeline15 = device0.createComputePipeline({layout: pipelineLayout15, compute: {module: shaderModule4}});
let commandEncoder119 = device0.createCommandEncoder({});
let textureView133 = texture98.createView({label: '\u{1f9d2}\u59dd\ud2d3\u07fb\u{1f8e3}\u{1fcdf}\uee4c', baseArrayLayer: 5, arrayLayerCount: 14});
let computePassEncoder99 = commandEncoder118.beginComputePass({timestampWrites: {querySet: querySet1}});
let renderPassEncoder29 = commandEncoder119.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 462,
  clearValue: { r: -508.2, g: 51.72, b: 193.1, a: -895.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet8, endOfPassWriteIndex: 289},
  maxDrawCount: 127172895,
});
let renderBundle19 = renderBundleEncoder19.finish({});
let sampler69 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 83.86,
  compare: 'never',
  maxAnisotropy: 13,
});
try {
{ clearResourceUsages(device0, computePassEncoder83); computePassEncoder83.dispatchWorkgroupsIndirect(buffer77, 176); };
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer75, 2180, new BigUint64Array(6052), 1537, 12);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 258, height: 15, depthOrArrayLayers: 1}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 30, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup69 = device0.createBindGroup({layout: veryExplicitBindGroupLayout18, entries: [{binding: 8, resource: externalTexture8}]});
let commandEncoder120 = device0.createCommandEncoder({});
let textureView134 = texture95.createView({arrayLayerCount: 1});
let computePassEncoder100 = commandEncoder120.beginComputePass({});
try {
computePassEncoder80.setBindGroup(2, bindGroup34);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(0, buffer47);
} catch {}
try {
computePassEncoder23.insertDebugMarker('\uad27');
} catch {}
document.body.append(canvas3);
let buffer82 = device0.createBuffer({size: 8801, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let texture100 = device0.createTexture({
  size: [517, 30, 33],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder61.setBindGroup(2, bindGroup36);
} catch {}
try {
computePassEncoder95.setBindGroup(0, bindGroup57, new Uint32Array(2902), 141, 0);
} catch {}
try {
computePassEncoder99.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer53);
} catch {}
try {
buffer32.unmap();
} catch {}
let pipeline16 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}});
try {
computePassEncoder82.setBindGroup(0, bindGroup39);
} catch {}
try {
renderPassEncoder7.setStencilReference(402);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer46, 'uint32', 4, 168);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer33, 628, 267);
} catch {}
let promise20 = device0.createComputePipelineAsync({layout: pipelineLayout14, compute: {module: shaderModule4, constants: {}}});
let commandEncoder121 = device0.createCommandEncoder({});
try {
computePassEncoder64.setBindGroup(1, bindGroup19);
} catch {}
try {
computePassEncoder22.setBindGroup(0, bindGroup56, new Uint32Array(1223), 13, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroupsIndirect(buffer34, 952); };
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup36, new Uint32Array(942), 96, 0);
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires packed_4x8_integer_dot_product;

enable f16;

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

override override6 = 0.4949;

struct T3 {
  @align(32) @size(32) f0: T1,
  @size(128) f1: atomic<i32>,
  @size(1216) f2: array<array<array<T1, 1>, 2>>,
}

var<private> vp2: f16 = f16(864.9);

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

override override7: f32;

struct T2 {
  @align(64) @size(3264) f0: mat4x2h,
}

/* zero global variables used */
fn fn2() -> FragmentOutput4 {
  var out: FragmentOutput4;
  var vf68: vec3h = radians(vec3h(unconst_f16(4003.4), unconst_f16(371.8), unconst_f16(2048.5)));
  let vf69: vec2<bool> = (vec2f(unconst_f32(0.1736), unconst_f32(0.04485)) != vec2f(unconst_f32(-0.1279), unconst_f32(0.09416)));
  let vf70: vec2h = exp(vec2h(unconst_f16(6544.5), unconst_f16(7548.4)));
  let vf71: vec2<bool> = (vec2h(unconst_f16(11803.0), unconst_f16(29789.1)) >= vec2h(unconst_f16(7078.1), unconst_f16(5670.4)));
  var vf72: bool = vf71[unconst_u32(522)];
  vp2 -= asinh(vec3h(unconst_f16(469.6), unconst_f16(8460.8), unconst_f16(3521.9))).g;
  return out;
}

/* used global variables: buffer84 */
fn fn0(a0: ptr<storage, array<mat2x2f>, read>) -> VertexOutput5 {
  var out: VertexOutput5;
  let ptr62: ptr<storage, T2, read> = &buffer84;
  out.f18 = bitcast<f32>((*ptr62).f0[unconst_i32(0)]);
  var vf57: vec2h = (*&buffer84).f0[unconst_u32(378)];
  let ptr63: ptr<storage, mat4x2h, read> = &(*ptr62).f0;
  out.f17 = vec4f(f32(override5));
  var vf58: vec2h = (*ptr62).f0[unconst_u32(23)];
  return out;
  _ = override5;
  _ = buffer84;
}

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

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

struct T4 {
  f0: f16,
}

struct T5 {
  @align(64) @size(64) f0: T4,
  @align(64) @size(3200) f1: T3,
}

@group(0) @binding(62) var tex5: texture_depth_2d;

@group(0) @binding(578) var<storage, read> buffer84: T2;

@id(15052) override override5: u32 = 407;

@id(55222) override override4: i32;

struct T0 {
  f0: mat2x3h,
  @size(4) f1: array<f16, 1>,
  @size(144) f2: mat3x4h,
}

/* used global variables: buffer84 */
@must_use 
fn fn1(a0: array<VertexOutput5, 1>) -> T4 {
  var out: T4;
  let vf59: vec2f = inverseSqrt(vec2f(unconst_f32(0.1238), unconst_f32(0.4448)));
  vp2 *= vec4h(a0[unconst_u32(290)].f17).b;
  let vf60: vec4i = (vec4i(unconst_i32(20), unconst_i32(148), unconst_i32(38), unconst_i32(131)) ^ vec4i(unconst_i32(464), unconst_i32(149), unconst_i32(231), unconst_i32(220)));
  var vf61: vec4h = radians(vec4h(f16(pack4x8unorm(vec4f(unconst_f32(0.5400), unconst_f32(0.2812), unconst_f32(0.1464), unconst_f32(1.000))))));
  let vf62: vec2f = quantizeToF16(vec2f((unconst_i32(517) - vec2i(unconst_i32(16), unconst_i32(2)))));
  for (var it4=u32(all((vec3i(unconst_i32(37), unconst_i32(-321), unconst_i32(157)) > vec3i(unconst_i32(-288), unconst_i32(76), unconst_i32(185))))); it4<u32(vf61[unconst_u32(119)]); it4++) {
  let vf63: vec2h = sign(vec2h(unconst_f16(2966.3), unconst_f16(268.3)));
  switch i32(pack2x16float(vec2f(unconst_f32(0.1532), unconst_f32(0.06690)))) { 
  default {
  let vf64: VertexOutput5 = a0[unconst_u32(64)];
  out = T4(f16(floor(vec2f(unconst_f32(0.06608), unconst_f32(0.4171)))[1]));
  let vf65: vec2h = (*&buffer84).f0[unconst_u32(77)];
  break;
  _ = buffer84;
}
  }
  out.f0 = f16(a0[bitcast<u32>(a0[unconst_u32(115)].f18)].f17[1]);
  let vf66: f32 = a0[unconst_u32(61)].f17[unconst_u32(262)];
  vp2 = buffer84.f0[bitcast<u32>(override6)][1];
  let vf67: array<VertexOutput5, 1> = a0;
  _ = override6;
  _ = buffer84;
}
  return out;
  _ = override6;
  _ = buffer84;
}

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

struct VertexOutput5 {
  @invariant @builtin(position) f17: vec4f,
  @location(11) @interpolate(perspective, first) f18: f32,
}

struct T1 {
  @align(8) @size(8) f0: array<array<array<array<array<f16, 2>, 1>, 1>, 1>, 1>,
}

struct FragmentOutput4 {
  @location(2) @interpolate(flat) f0: vec2u,
  @location(0) f1: vec4f,
  @location(5) @interpolate(flat) f2: u32,
  @builtin(sample_mask) f3: u32,
}

var<private> vp1: vec2h = vec2h(46183.2, 22737.1);

/* used global variables: buffer84, tex5 */
@vertex
fn vertex6(@builtin(vertex_index) a0: u32, @location(7) @interpolate(flat) a1: u32, @location(0) @interpolate(flat) a2: vec2i) -> VertexOutput5 {
  var out: VertexOutput5;
  _ = fn1(array<VertexOutput5, 1>(VertexOutput5(inverseSqrt(vec4f(f32(a0))), inverseSqrt(vec4f(f32(a0)))[2])));
  let vf73: f32 = textureLoad(tex5, vec2i((unconst_f16(14060.2) * vec2h(unconst_f16(16408.0), unconst_f16(5319.0)))), unconst_i32(7));
  out.f18 = select(vec2f(unconst_f32(0.06572), unconst_f32(0.04940)), vec2f(unconst_f32(-0.02053), unconst_f32(0.1155)), vec2<bool>(bool(a2[vec2u((vec2i(i32(vp1[unconst_u32(219)])) < vec2i(unconst_i32(4), unconst_i32(5))))[0]]))).x;
  var vf74 = fn1(array<VertexOutput5, 1>(VertexOutput5(vec4f(vp1.xxxy), bitcast<f32>(vp1))));
  vp2 += (*&buffer84).f0[unconst_i32(3)].g;
  return out;
  _ = override6;
  _ = tex5;
  _ = buffer84;
}

/* used global variables: buffer84 */
@fragment
fn fragment4() -> FragmentOutput4 {
  var out: FragmentOutput4;
  var vf75 = fn2();
  _ = fn2();
  var vf76: f16 = buffer84.f0[unconst_u32(55)][unconst_u32(74)];
  var vf77 = fn2();
  fn2();
  {
  var vf78 = fn2();
}
  vp1 *= vec2h(vf77.f0);
  vf75.f0 = vec2u(bitcast<u32>( ~bitcast<i32>(buffer84.f0[unconst_u32(27)])));
  var vf79 = fn2();
  _ = fn2();
  let ptr64: ptr<storage, mat4x2h, read> = &(*&buffer84).f0;
  loop {
  vp2 -= vec3h(trunc(vec3f(unconst_f32(0.08769), unconst_f32(0.3237), unconst_f32(0.4184))))[0];
  out.f3 &= bitcast<u32>(abs(vec2h(unconst_f16(12797.7), unconst_f16(3632.1))));
  _ = fn2();
  var vf80 = fn2();
  out = FragmentOutput4(bitcast<vec2u>(vf80.f1.bb), vf80.f1, u32(vf80.f1[1]), bitcast<u32>(vf80.f1.r));
  break;
}
  var vf81 = fn2();
  return out;
  _ = buffer84;
}`,
});
let recycledExplicitBindGroupLayout8 = pipeline4.getBindGroupLayout(0);
let textureView135 = texture73.createView({label: '\u611f\u03d8\u3865\uf217\ufaf8', dimension: '2d'});
try {
computePassEncoder18.setBindGroup(0, bindGroup68, new Uint32Array(2156), 435, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder83); computePassEncoder83.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder83); computePassEncoder83.dispatchWorkgroupsIndirect(buffer77, 104); };
} catch {}
try {
renderPassEncoder28.setBindGroup(3, bindGroup47);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer54, 'uint16', 20, 1_575);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 1616, new Float32Array(2081), 1, 52);
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 22, height: 10, depthOrArrayLayers: 55}
*/
{
  source: offscreenCanvas0,
  origin: { x: 0, y: 2 },
  flipY: true,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer85 = device0.createBuffer({size: 817, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandBuffer4 = commandEncoder121.finish();
let texture101 = device0.createTexture({
  size: [258],
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler70 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder83.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer25, 'uint16', 1_140, 515);
} catch {}
let recycledExplicitBindGroupLayout9 = pipeline7.getBindGroupLayout(0);
let bindGroup70 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 127, resource: {buffer: buffer7, offset: 0, size: 792}},
    {binding: 8, resource: textureView14},
  ],
});
let textureView136 = texture17.createView({});
try {
computePassEncoder87.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup42);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup55, new Uint32Array(3963), 5, 0);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let commandEncoder122 = device0.createCommandEncoder({});
let textureView137 = texture47.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 10});
let computePassEncoder101 = commandEncoder122.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder97.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer3, 'uint16', 2_266, 2_786);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline11);
} catch {}
let adapter1 = await navigator.gpu.requestAdapter({});
try {
adapter1.label = '\u2d20\uaaa8\u47c7';
} catch {}
let texture102 = device0.createTexture({
  size: [256, 256, 17],
  sampleCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView138 = texture8.createView({baseArrayLayer: 0});
try {
computePassEncoder95.setBindGroup(1, bindGroup21);
} catch {}
try {
computePassEncoder98.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline7);
} catch {}
try {
  await promise21;
} catch {}
let textureView139 = texture27.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder101.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup31, new Uint32Array(1227), 611, 0);
} catch {}
try {
buffer80.unmap();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup71 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 578, resource: {buffer: buffer49, offset: 256}}],
});
let commandEncoder123 = device0.createCommandEncoder({});
let textureView140 = texture31.createView({mipLevelCount: 1, arrayLayerCount: 4});
let computePassEncoder102 = commandEncoder123.beginComputePass({});
let sampler71 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 77.51,
  maxAnisotropy: 15,
});
try {
computePassEncoder27.setBindGroup(0, bindGroup47, new Uint32Array(2795), 101, 0);
} catch {}
try {
computePassEncoder83.end();
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup33, new Uint32Array(1208), 60, 0);
} catch {}
let arrayBuffer3 = buffer37.getMappedRange(1160, 148);
try {
commandEncoder56.copyBufferToTexture({
  /* bytesInLastRow: 96 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1304 */
  offset: 1304,
  buffer: buffer9,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 38, y: 0, z: 0},
  aspect: 'all',
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder56.copyTextureToTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 52, y: 71, z: 0},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise22 = adapter1.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'timestamp-query',
  ],
});
try {
externalTexture8.label = '\u{1ff2f}\u{1fc81}\u{1fbb9}\u{1f9a8}\u4780\u4db7\u7be3\u06e1';
} catch {}
let texture103 = device0.createTexture({
  size: {width: 90, height: 40, depthOrArrayLayers: 45},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder86.setBindGroup(0, bindGroup37);
} catch {}
try {
computePassEncoder56.setBindGroup(2, bindGroup45, new Uint32Array(1938), 428, 0);
} catch {}
try {
computePassEncoder82.end();
} catch {}
try {
commandEncoder56.copyBufferToTexture({
  /* bytesInLastRow: 128 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4264 */
  offset: 4264,
  bytesPerRow: 7424,
  rowsPerImage: 34,
  buffer: buffer72,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 28, y: 58, z: 0},
  aspect: 'all',
}, {width: 16, height: 25, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder97.resolveQuerySet(querySet8, 373, 10, buffer70, 13568);
} catch {}
let bindGroup72 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: [{binding: 176, resource: textureView75}]});
let buffer86 = device0.createBuffer({size: 57157, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let renderPassEncoder30 = commandEncoder56.beginRenderPass({
  colorAttachments: [{
  view: textureView41,
  depthSlice: 61,
  clearValue: { r: -719.5, g: 636.7, b: 622.0, a: 591.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet6,
});
let sampler72 = device0.createSampler({
  addressModeV: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 56.65,
  lodMaxClamp: 98.84,
  maxAnisotropy: 1,
});
try {
computePassEncoder44.setBindGroup(3, bindGroup8);
} catch {}
try {
computePassEncoder68.setBindGroup(0, bindGroup19, new Uint32Array(1199), 179, 0);
} catch {}
try {
computePassEncoder95.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder28.setBindGroup(3, bindGroup60, new Uint32Array(38), 1, 0);
} catch {}
document.body.append(canvas5);
let texture104 = device0.createTexture({
  size: [258],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder103 = commandEncoder97.beginComputePass({});
let sampler73 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', compare: 'less-equal', maxAnisotropy: 1});
try {
computePassEncoder103.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer71, 'uint16', 3_212, 3_746);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(7, buffer72);
} catch {}
let texture105 = device0.createTexture({
  size: {width: 360},
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView141 = texture43.createView({baseMipLevel: 0});
try {
device0.queue.submit([commandBuffer4]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(181).fill(121), /* required buffer size: 181 */
{offset: 181}, {width: 96, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 31}
*/
{
  source: canvas4,
  origin: { x: 7, y: 9 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 60, y: 19, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 29, height: 17, depthOrArrayLayers: 0});
} catch {}
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpteSt4281', transfer: 'bt1361ExtendedColourGamut'} });
let texture106 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder37.setBindGroup(1, bindGroup10);
} catch {}
try {
computePassEncoder100.setPipeline(pipeline4);
} catch {}
let pipeline17 = device0.createRenderPipeline({
  layout: pipelineLayout14,
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 0, shaderLocation: 12},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'sint16x2', offset: 0, shaderLocation: 14},
          {format: 'uint32x2', offset: 4, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: false},
});
let querySet9 = device0.createQuerySet({type: 'timestamp', count: 548});
try {
computePassEncoder102.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder34.setBindGroup(3, bindGroup33);
} catch {}
try {
computePassEncoder46.setBindGroup(1, bindGroup58, new Uint32Array(2553), 115, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline7);
} catch {}
let arrayBuffer4 = buffer37.getMappedRange(904, 16);
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let imageData16 = new ImageData(20, 4);
let bindGroup73 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 328, resource: textureView8}]});
let buffer87 = device0.createBuffer({
  size: 6568,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let sampler74 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 95.74});
try {
renderPassEncoder16.executeBundles([renderBundle5, renderBundle15]);
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 62, resource: textureView9},
    {binding: 578, resource: {buffer: buffer25, offset: 0, size: 3652}},
    {binding: 254, resource: {buffer: buffer87, offset: 256}},
  ],
});
let commandEncoder124 = device0.createCommandEncoder({});
let computePassEncoder104 = commandEncoder124.beginComputePass({timestampWrites: {querySet: querySet9, endOfPassWriteIndex: 457}});
try {
computePassEncoder51.setBindGroup(2, bindGroup7, new Uint32Array(3), 0, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer7, 1_796);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
let pipelineLayout18 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout10]});
let commandEncoder125 = device0.createCommandEncoder({});
let textureView142 = texture93.createView({dimension: '2d', baseArrayLayer: 4});
let textureView143 = texture82.createView({dimension: '2d'});
let computePassEncoder105 = commandEncoder125.beginComputePass({
  timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 338, endOfPassWriteIndex: 4294967295},
});
try {
computePassEncoder23.setBindGroup(0, bindGroup15, new Uint32Array(2749), 945, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder17.drawIndexed(46, 8, 2, 57_917_828, 36);
} catch {}
try {
renderPassEncoder17.drawIndexedIndirect(buffer62, 164);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let bindGroup75 = device0.createBindGroup({layout: veryExplicitBindGroupLayout12, entries: [{binding: 6, resource: textureView27}]});
let commandEncoder126 = device0.createCommandEncoder({});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: false});
let sampler75 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 25.00,
});
try {
computePassEncoder53.setBindGroup(2, bindGroup75, new Uint32Array(68), 12, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder17.draw(6, 22, 1_924_833_028, 3);
} catch {}
try {
renderPassEncoder17.drawIndirect(buffer72, 420);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer63, 'uint16', 90, 501);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(2, undefined);
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup10, new Uint32Array(1383), 66, 0);
} catch {}
let buffer88 = device0.createBuffer({size: 17523, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let querySet10 = device0.createQuerySet({type: 'timestamp', count: 221});
let texture107 = gpuCanvasContext2.getCurrentTexture();
let textureView144 = texture104.createView({aspect: 'all'});
let renderBundle20 = renderBundleEncoder20.finish();
try {
computePassEncoder42.setBindGroup(1, bindGroup62, new Uint32Array(1014), 421, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup56, new Uint32Array(1006), 18, 0);
} catch {}
try {
renderPassEncoder17.end();
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer42, 'uint32', 224, 71);
} catch {}
let bindGroup76 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 578, resource: {buffer: buffer26, offset: 0}}],
});
try {
renderPassEncoder2.setBindGroup(3, bindGroup27);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let pipeline18 = device0.createRenderPipeline({
  layout: pipelineLayout13,
  fragment: {module: shaderModule0, entryPoint: 'fragment0', constants: {}, targets: [{format: 'rgba16uint'}]},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [{arrayStride: 168, attributes: [{format: 'float32x4', offset: 12, shaderLocation: 3}]}],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', cullMode: 'front'},
});
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let recycledExplicitBindGroupLayout10 = pipeline18.getBindGroupLayout(0);
let texture108 = device0.createTexture({
  size: [90, 1, 1],
  mipLevelCount: 3,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder106 = commandEncoder126.beginComputePass();
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true});
try {
computePassEncoder98.setBindGroup(2, bindGroup1);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup53, new Uint32Array(361), 254, 0);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder21.setBindGroup(2, bindGroup23, new Uint32Array(4330), 79, 0);
} catch {}
try {
commandEncoder76.copyBufferToTexture({
  /* bytesInLastRow: 352 widthInBlocks: 88 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1636 */
  offset: 1636,
  bytesPerRow: 11520,
  buffer: buffer16,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 29, y: 2, z: 0},
  aspect: 'all',
}, {width: 88, height: 10, depthOrArrayLayers: 0});
} catch {}
let buffer89 = device0.createBuffer({size: 10947, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let computePassEncoder107 = commandEncoder76.beginComputePass({});
try {
computePassEncoder42.setBindGroup(3, bindGroup36, new Uint32Array(116), 35, 0);
} catch {}
try {
computePassEncoder104.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle5, renderBundle4]);
} catch {}
try {
renderPassEncoder10.setViewport(151.12527476012806, 248.3580324486086, 67.36691231004855, 0.26984897361093796, 0.08339239491167116, 0.8532131388957873);
} catch {}
try {
renderPassEncoder4.drawIndexed(30, 116, 186, 203_708_530, 226_720_303);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer76, 4_004);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer81, 36);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer3, 'uint16', 678, 3_300);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer9, 'uint16', 282, 4);
} catch {}
let pipeline19 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x79b6f0e},
  fragment: {
  module: shaderModule4,
  constants: {},
  targets: [{format: 'rgba16float', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {module: shaderModule0, entryPoint: 'vertex1', buffers: []},
  primitive: {cullMode: 'front'},
});
let imageData17 = new ImageData(28, 20);
let texture109 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 17},
  mipLevelCount: 5,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder107.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder4.draw(0, 201, 0, 39_886_225);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer8, 264);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(3, buffer58, 92);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline19);
} catch {}
let promise23 = device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  fragment: {module: shaderModule5, targets: [{format: 'rgb10a2unorm'}]},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 332,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 80, shaderLocation: 3}],
      },
    ],
  },
  primitive: {cullMode: 'front'},
});
let pipelineLayout19 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout5]});
let commandEncoder127 = device0.createCommandEncoder({});
let renderPassEncoder31 = commandEncoder127.beginRenderPass({
  colorAttachments: [{view: textureView107, depthSlice: 91, loadOp: 'clear', storeOp: 'discard'}],
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 552},
  maxDrawCount: 152323216,
});
let sampler76 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.73,
  maxAnisotropy: 18,
});
try {
computePassEncoder52.setBindGroup(1, bindGroup75, new Uint32Array(3933), 98, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle3, renderBundle7]);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer66, 0, 1_474);
} catch {}
try {
buffer70.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 11, height: 5, depthOrArrayLayers: 55}
*/
{
  source: videoFrame10,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture47,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 21},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup77 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 282, resource: externalTexture5},
    {binding: 7, resource: textureView14},
    {binding: 37, resource: {buffer: buffer7, offset: 768, size: 428}},
  ],
});
let buffer90 = device0.createBuffer({size: 11890, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView145 = texture38.createView({format: 'rgba16uint', baseArrayLayer: 1, arrayLayerCount: 3});
let renderBundle21 = renderBundleEncoder21.finish({});
try {
computePassEncoder77.setBindGroup(1, bindGroup33);
} catch {}
try {
computePassEncoder20.setBindGroup(3, bindGroup11, new Uint32Array(1458), 15, 0);
} catch {}
try {
computePassEncoder106.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup50, new Uint32Array(4012), 24, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle13, renderBundle13, renderBundle13]);
} catch {}
try {
renderPassEncoder4.drawIndexed(1_257, 435, 42, 525_792_657, 1_564_032_242);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer25, 664);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer70, 11_220);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(5, buffer47);
} catch {}
try {
computePassEncoder23.pushDebugGroup('\u{1f8c3}');
} catch {}
try {
computePassEncoder81.setBindGroup(3, bindGroup23);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
renderPassEncoder4.draw(0, 416, 0, 497_769_478);
} catch {}
try {
renderPassEncoder4.drawIndexed(25, 245, 144, 392_570_477, 420_482_261);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer77, 636);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer25, 'uint16', 1_942, 256);
} catch {}
let bindGroup78 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 37, resource: {buffer: buffer79, offset: 0, size: 632}},
    {binding: 282, resource: externalTexture1},
    {binding: 7, resource: textureView79},
  ],
});
let texture110 = device0.createTexture({size: [90, 1, 1], mipLevelCount: 2, format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING});
let sampler77 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 30.09,
});
try {
computePassEncoder105.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup30);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup49, new Uint32Array(560), 32, 0);
} catch {}
try {
renderPassEncoder4.draw(0, 74, 0, 953_850_766);
} catch {}
try {
renderPassEncoder4.drawIndexed(23, 436, 1, 547_389_026, 415_058_600);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer34, 5_036);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer81, 92);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer32, 0, 7_552);
} catch {}
let texture111 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 622},
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView146 = texture71.createView({mipLevelCount: 1});
try {
computePassEncoder59.setBindGroup(0, bindGroup50, new Uint32Array(982), 134, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup33);
} catch {}
try {
renderPassEncoder8.setScissorRect(7, 0, 7, 0);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer79, 204);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer76, 232);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer87, 'uint16', 364, 837);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {binding: 47, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 169,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 192,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 267, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 359,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let textureView147 = texture104.createView({});
let texture112 = device0.createTexture({
  size: [90, 40, 51],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView148 = texture44.createView({baseArrayLayer: 2, arrayLayerCount: 1});
let sampler78 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 90.98});
try {
computePassEncoder53.setBindGroup(2, bindGroup26);
} catch {}
try {
renderPassEncoder4.drawIndexed(17, 22, 19, -1_611_285_040, 497_790_026);
} catch {}
let bindGroup79 = device0.createBindGroup({layout: veryExplicitBindGroupLayout18, entries: [{binding: 8, resource: externalTexture7}]});
let buffer91 = device0.createBuffer({
  size: 14355,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder128 = device0.createCommandEncoder({});
let computePassEncoder108 = commandEncoder128.beginComputePass({});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4});
let externalTexture16 = device0.importExternalTexture({source: videoFrame11});
try {
computePassEncoder92.setBindGroup(0, bindGroup64, new Uint32Array(24), 2, 0);
} catch {}
try {
computePassEncoder18.end();
} catch {}
try {
computePassEncoder108.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder26.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder4.drawIndexed(11, 101, 19, -1_925_450_485, 617_232_517);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer73, 84);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline17);
} catch {}
try {
commandEncoder21.copyTextureToTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 5, y: 4, z: 7},
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: {x: 10, y: 4, z: 0},
  aspect: 'all',
},
{width: 15, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer24, 372, new Int16Array(1723), 101, 40);
} catch {}
let buffer92 = device0.createBuffer({
  size: 2354,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder69.setBindGroup(3, bindGroup33);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer54, 508);
} catch {}
try {
renderBundleEncoder22.setBindGroup(3, bindGroup31, new Uint32Array(4465), 3_217, 0);
} catch {}
try {
pipeline6.label = '\u0acf\u{1fbf5}\u{1f93d}\u0725\u6830\ufb2a\u08f3';
} catch {}
try {
computePassEncoder104.setBindGroup(1, bindGroup6, new Uint32Array(1954), 162, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer25, 'uint32', 500, 730);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(7, buffer31, 404);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture71,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(244).fill(30), /* required buffer size: 244 */
{offset: 244, bytesPerRow: 552}, {width: 69, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame17,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 10, y: 9, z: 8},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline20 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x56fcd1d0},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment4',
  targets: [{format: 'rgb10a2unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    constants: {},
    buffers: [
      {
        arrayStride: 856,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x2', offset: 132, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 24, shaderLocation: 5},
          {format: 'sint32x2', offset: 24, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 204, shaderLocation: 14},
          {format: 'sint32x4', offset: 24, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
await gc();
let commandEncoder129 = device0.createCommandEncoder();
let computePassEncoder109 = commandEncoder129.beginComputePass({});
try {
computePassEncoder12.setBindGroup(3, bindGroup18);
} catch {}
try {
computePassEncoder1.setBindGroup(3, bindGroup70, new Uint32Array(4027), 1_149, 0);
} catch {}
try {
renderPassEncoder4.draw(0, 107, 0, 553_446_841);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer55, 5_516);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer92, 'uint16', 734, 168);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline19);
} catch {}
try {
commandEncoder21.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1104 */
  offset: 1104,
  bytesPerRow: 2048,
  buffer: buffer68,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 16, depthOrArrayLayers: 0});
} catch {}
let texture113 = device0.createTexture({size: [129, 7, 1155], dimension: '3d', format: 'rgba16uint', usage: GPUTextureUsage.STORAGE_BINDING});
let computePassEncoder110 = commandEncoder21.beginComputePass({});
try {
computePassEncoder100.setBindGroup(0, bindGroup16, new Uint32Array(2628), 21, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroupsIndirect(buffer91, 2_456); };
} catch {}
try {
computePassEncoder110.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder26.setBindGroup(2, bindGroup39, new Uint32Array(2573), 796, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder4.drawIndexed(38, 133, 20, 193_138_918, 487_369_544);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer8, 'uint32', 1_328, 751);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(7, buffer8, 0, 314);
} catch {}
let arrayBuffer5 = buffer37.getMappedRange(1312, 12);
document.body.prepend(img1);
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte240m', transfer: 'log'} });
let commandEncoder130 = device0.createCommandEncoder({});
let texture114 = device0.createTexture({size: {width: 360}, dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let computePassEncoder111 = commandEncoder130.beginComputePass({});
try {
computePassEncoder102.setBindGroup(0, bindGroup13);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup11, new Uint32Array(4547), 2_780, 0);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer62, 20);
} catch {}
try {
renderPassEncoder29.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(4, buffer41, 176, 477);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup17);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(5, buffer46);
} catch {}
let promise24 = shaderModule2.getCompilationInfo();
try {
computePassEncoder23.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer76, 3640, new Int16Array(1190), 50, 236);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let videoFrame19 = new VideoFrame(videoFrame8, {timestamp: 0});
let commandEncoder131 = device0.createCommandEncoder({});
let renderBundle22 = renderBundleEncoder22.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder37.setPipeline(pipeline16);
} catch {}
try {
computePassEncoder111.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder4.drawIndexed(28, 123, 2, 176_397_217, 1_008_543_925);
} catch {}
try {
renderPassEncoder18.popDebugGroup();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder132 = device0.createCommandEncoder({});
let computePassEncoder112 = commandEncoder131.beginComputePass({});
try {
renderPassEncoder4.drawIndexedIndirect(buffer25, 440);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer34, 468);
} catch {}
let pipeline21 = await device0.createComputePipelineAsync({layout: pipelineLayout13, compute: {module: shaderModule1, entryPoint: 'compute1'}});
let computePassEncoder113 = commandEncoder132.beginComputePass();
let sampler79 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 84.64,
});
try {
{ clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroupsIndirect(buffer26, 604); };
} catch {}
try {
renderPassEncoder31.setBindGroup(2, bindGroup7, new Uint32Array(6653), 353, 0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer27, 1_164);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 90, height: 40, depthOrArrayLayers: 45}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture103,
  mipLevel: 0,
  origin: {x: 8, y: 10, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline22 = device0.createComputePipeline({layout: pipelineLayout19, compute: {module: shaderModule0, entryPoint: 'compute0'}});
document.body.prepend(canvas5);
let autogeneratedBindGroupLayout6 = pipeline20.getBindGroupLayout(0);
let bindGroup80 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 8, resource: externalTexture12}]});
let buffer93 = device0.createBuffer({
  size: 9592,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView149 = texture47.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 11});
try {
renderPassEncoder13.setBindGroup(1, bindGroup12);
} catch {}
try {
renderPassEncoder21.setStencilReference(442);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer26, 'uint32', 1_348, 880);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline20);
} catch {}
try {
buffer3.unmap();
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

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

var<workgroup> vw24: f32;

/* used global variables: buffer95 */
fn fn1(a0: ptr<storage, vec2u, read_write>) -> mat2x2h {
  var out: mat2x2h;
  for (var it6=u32((*&buffer95)[unconst_u32(79)][5][0][0][unconst_u32(180)][unconst_u32(256)][unconst_u32(279)][16][unconst_u32(149)][0][unconst_u32(217)][0]); it6<u32((*&buffer95)[15][unconst_u32(164)][0][unconst_u32(79)][0][0][0][unconst_u32(468)][unconst_u32(69)][unconst_u32(218)][0][0]); it6++) {
  vp3 = mat2x3h(buffer95[unconst_u32(307)][5][u32((*&buffer95)[15][5][0][unconst_u32(344)][0][unconst_u32(141)][0][16][0][0][0][0])][u32(buffer95[unconst_u32(1)][5][unconst_u32(33)][0][unconst_u32(193)][unconst_u32(35)][unconst_u32(144)][unconst_u32(133)][unconst_u32(394)][u32((*&buffer95)[15][unconst_u32(59)][0][unconst_u32(570)][unconst_u32(120)][unconst_u32(86)][u32((*&buffer95)[unconst_u32(128)][5][unconst_u32(285)][unconst_u32(137)][unconst_u32(43)][unconst_u32(88)][0][unconst_u32(3)][0][0][unconst_u32(294)][unconst_u32(187)])][unconst_u32(120)][u32(buffer95[15][5][unconst_u32(337)][0][0][unconst_u32(644)][unconst_u32(191)][unconst_u32(381)][0][unconst_u32(39)][0][0])][0][0][0])][0][0])][unconst_u32(222)][0][0][unconst_u32(428)][0][0][unconst_u32(483)][unconst_u32(302)], buffer95[unconst_u32(307)][5][u32((*&buffer95)[15][5][0][unconst_u32(344)][0][unconst_u32(141)][0][16][0][0][0][0])][u32(buffer95[unconst_u32(1)][5][unconst_u32(33)][0][unconst_u32(193)][unconst_u32(35)][unconst_u32(144)][unconst_u32(133)][unconst_u32(394)][u32((*&buffer95)[15][unconst_u32(59)][0][unconst_u32(570)][unconst_u32(120)][unconst_u32(86)][u32((*&buffer95)[unconst_u32(128)][5][unconst_u32(285)][unconst_u32(137)][unconst_u32(43)][unconst_u32(88)][0][unconst_u32(3)][0][0][unconst_u32(294)][unconst_u32(187)])][unconst_u32(120)][u32(buffer95[15][5][unconst_u32(337)][0][0][unconst_u32(644)][unconst_u32(191)][unconst_u32(381)][0][unconst_u32(39)][0][0])][0][0][0])][0][0])][unconst_u32(222)][0][0][unconst_u32(428)][0][0][unconst_u32(483)][unconst_u32(302)], buffer95[unconst_u32(307)][5][u32((*&buffer95)[15][5][0][unconst_u32(344)][0][unconst_u32(141)][0][16][0][0][0][0])][u32(buffer95[unconst_u32(1)][5][unconst_u32(33)][0][unconst_u32(193)][unconst_u32(35)][unconst_u32(144)][unconst_u32(133)][unconst_u32(394)][u32((*&buffer95)[15][unconst_u32(59)][0][unconst_u32(570)][unconst_u32(120)][unconst_u32(86)][u32((*&buffer95)[unconst_u32(128)][5][unconst_u32(285)][unconst_u32(137)][unconst_u32(43)][unconst_u32(88)][0][unconst_u32(3)][0][0][unconst_u32(294)][unconst_u32(187)])][unconst_u32(120)][u32(buffer95[15][5][unconst_u32(337)][0][0][unconst_u32(644)][unconst_u32(191)][unconst_u32(381)][0][unconst_u32(39)][0][0])][0][0][0])][0][0])][unconst_u32(222)][0][0][unconst_u32(428)][0][0][unconst_u32(483)][unconst_u32(302)], buffer95[unconst_u32(307)][5][u32((*&buffer95)[15][5][0][unconst_u32(344)][0][unconst_u32(141)][0][16][0][0][0][0])][u32(buffer95[unconst_u32(1)][5][unconst_u32(33)][0][unconst_u32(193)][unconst_u32(35)][unconst_u32(144)][unconst_u32(133)][unconst_u32(394)][u32((*&buffer95)[15][unconst_u32(59)][0][unconst_u32(570)][unconst_u32(120)][unconst_u32(86)][u32((*&buffer95)[unconst_u32(128)][5][unconst_u32(285)][unconst_u32(137)][unconst_u32(43)][unconst_u32(88)][0][unconst_u32(3)][0][0][unconst_u32(294)][unconst_u32(187)])][unconst_u32(120)][u32(buffer95[15][5][unconst_u32(337)][0][0][unconst_u32(644)][unconst_u32(191)][unconst_u32(381)][0][unconst_u32(39)][0][0])][0][0][0])][0][0])][unconst_u32(222)][0][0][unconst_u32(428)][0][0][unconst_u32(483)][unconst_u32(302)], buffer95[unconst_u32(307)][5][u32((*&buffer95)[15][5][0][unconst_u32(344)][0][unconst_u32(141)][0][16][0][0][0][0])][u32(buffer95[unconst_u32(1)][5][unconst_u32(33)][0][unconst_u32(193)][unconst_u32(35)][unconst_u32(144)][unconst_u32(133)][unconst_u32(394)][u32((*&buffer95)[15][unconst_u32(59)][0][unconst_u32(570)][unconst_u32(120)][unconst_u32(86)][u32((*&buffer95)[unconst_u32(128)][5][unconst_u32(285)][unconst_u32(137)][unconst_u32(43)][unconst_u32(88)][0][unconst_u32(3)][0][0][unconst_u32(294)][unconst_u32(187)])][unconst_u32(120)][u32(buffer95[15][5][unconst_u32(337)][0][0][unconst_u32(644)][unconst_u32(191)][unconst_u32(381)][0][unconst_u32(39)][0][0])][0][0][0])][0][0])][unconst_u32(222)][0][0][unconst_u32(428)][0][0][unconst_u32(483)][unconst_u32(302)], buffer95[unconst_u32(307)][5][u32((*&buffer95)[15][5][0][unconst_u32(344)][0][unconst_u32(141)][0][16][0][0][0][0])][u32(buffer95[unconst_u32(1)][5][unconst_u32(33)][0][unconst_u32(193)][unconst_u32(35)][unconst_u32(144)][unconst_u32(133)][unconst_u32(394)][u32((*&buffer95)[15][unconst_u32(59)][0][unconst_u32(570)][unconst_u32(120)][unconst_u32(86)][u32((*&buffer95)[unconst_u32(128)][5][unconst_u32(285)][unconst_u32(137)][unconst_u32(43)][unconst_u32(88)][0][unconst_u32(3)][0][0][unconst_u32(294)][unconst_u32(187)])][unconst_u32(120)][u32(buffer95[15][5][unconst_u32(337)][0][0][unconst_u32(644)][unconst_u32(191)][unconst_u32(381)][0][unconst_u32(39)][0][0])][0][0][0])][0][0])][unconst_u32(222)][0][0][unconst_u32(428)][0][0][unconst_u32(483)][unconst_u32(302)]);
  vp3 += mat2x3h((*&buffer95)[15][5][unconst_u32(416)][0][0][unconst_u32(31)][unconst_u32(527)][unconst_u32(200)][unconst_u32(296)][unconst_u32(286)][0][0], (*&buffer95)[15][5][unconst_u32(416)][0][0][unconst_u32(31)][unconst_u32(527)][unconst_u32(200)][unconst_u32(296)][unconst_u32(286)][0][0], (*&buffer95)[15][5][unconst_u32(416)][0][0][unconst_u32(31)][unconst_u32(527)][unconst_u32(200)][unconst_u32(296)][unconst_u32(286)][0][0], (*&buffer95)[15][5][unconst_u32(416)][0][0][unconst_u32(31)][unconst_u32(527)][unconst_u32(200)][unconst_u32(296)][unconst_u32(286)][0][0], (*&buffer95)[15][5][unconst_u32(416)][0][0][unconst_u32(31)][unconst_u32(527)][unconst_u32(200)][unconst_u32(296)][unconst_u32(286)][0][0], (*&buffer95)[15][5][unconst_u32(416)][0][0][unconst_u32(31)][unconst_u32(527)][unconst_u32(200)][unconst_u32(296)][unconst_u32(286)][0][0]);
  let ptr66: ptr<storage, f16, read> = &(*&buffer95)[unconst_u32(165)][5][unconst_u32(54)][unconst_u32(12)][0][0][0][16][u32((*&buffer95)[unconst_u32(9)][unconst_u32(164)][unconst_u32(89)][0][0][u32((*&buffer95)[15][unconst_u32(15)][0][unconst_u32(476)][0][0][unconst_u32(131)][unconst_u32(261)][0][0][0][0])][0][unconst_u32(33)][u32(buffer95[15][5][unconst_u32(49)][0][unconst_u32(235)][unconst_u32(127)][unconst_u32(62)][unconst_u32(615)][unconst_u32(217)][0][0][0])][0][0][0])][unconst_u32(155)][0][unconst_u32(129)];
  _ = buffer95;
}
  switch i32(buffer95[unconst_u32(129)][5][u32((*&buffer95)[unconst_u32(115)][5][0][unconst_u32(113)][unconst_u32(40)][0][unconst_u32(0)][u32((*&buffer95)[15][5][0][0][unconst_u32(15)][unconst_u32(26)][unconst_u32(69)][16][unconst_u32(284)][0][unconst_u32(248)][0])][0][unconst_u32(45)][unconst_u32(167)][0])][0][0][0][unconst_u32(128)][16][0][unconst_u32(297)][unconst_u32(458)][0]) { 
  default {
  let ptr67: ptr<storage, f16, read> = &buffer95[15][5][0][unconst_u32(437)][0][u32(buffer95[u32((*&buffer95)[unconst_u32(59)][unconst_u32(448)][unconst_u32(222)][unconst_u32(169)][unconst_u32(52)][unconst_u32(416)][unconst_u32(85)][unconst_u32(25)][0][u32(buffer95[unconst_u32(39)][unconst_u32(139)][0][u32((*&buffer95)[15][5][0][unconst_u32(648)][unconst_u32(625)][unconst_u32(179)][0][16][unconst_u32(101)][0][0][0])][0][unconst_u32(24)][unconst_u32(293)][unconst_u32(85)][unconst_u32(7)][unconst_u32(107)][unconst_u32(76)][unconst_u32(148)])][0][unconst_u32(12)])][5][0][unconst_u32(101)][0][u32((*&buffer95)[unconst_u32(1)][unconst_u32(25)][unconst_u32(519)][unconst_u32(58)][0][unconst_u32(27)][unconst_u32(127)][16][0][0][0][0])][unconst_u32(22)][unconst_u32(116)][unconst_u32(25)][0][0][unconst_u32(200)])][0][unconst_u32(8)][0][unconst_u32(4)][unconst_u32(235)][unconst_u32(193)];
  out = mat2x2h(buffer95[unconst_u32(22)][unconst_u32(407)][0][unconst_u32(176)][0][unconst_u32(137)][u32(buffer95[15][unconst_u32(269)][0][0][0][unconst_u32(112)][unconst_u32(11)][unconst_u32(253)][unconst_u32(32)][unconst_u32(122)][0][unconst_u32(250)])][16][0][0][unconst_u32(286)][0], buffer95[unconst_u32(22)][unconst_u32(407)][0][unconst_u32(176)][0][unconst_u32(137)][u32(buffer95[15][unconst_u32(269)][0][0][0][unconst_u32(112)][unconst_u32(11)][unconst_u32(253)][unconst_u32(32)][unconst_u32(122)][0][unconst_u32(250)])][16][0][0][unconst_u32(286)][0], buffer95[unconst_u32(22)][unconst_u32(407)][0][unconst_u32(176)][0][unconst_u32(137)][u32(buffer95[15][unconst_u32(269)][0][0][0][unconst_u32(112)][unconst_u32(11)][unconst_u32(253)][unconst_u32(32)][unconst_u32(122)][0][unconst_u32(250)])][16][0][0][unconst_u32(286)][0], buffer95[unconst_u32(22)][unconst_u32(407)][0][unconst_u32(176)][0][unconst_u32(137)][u32(buffer95[15][unconst_u32(269)][0][0][0][unconst_u32(112)][unconst_u32(11)][unconst_u32(253)][unconst_u32(32)][unconst_u32(122)][0][unconst_u32(250)])][16][0][0][unconst_u32(286)][0]);
  vp3 = mat2x3h(buffer95[unconst_u32(116)][5][0][0][0][0][0][16][0][u32((*&buffer95)[unconst_u32(35)][5][0][unconst_u32(9)][0][0][0][unconst_u32(2)][0][0][0][0])][unconst_u32(321)][0], buffer95[unconst_u32(116)][5][0][0][0][0][0][16][0][u32((*&buffer95)[unconst_u32(35)][5][0][unconst_u32(9)][0][0][0][unconst_u32(2)][0][0][0][0])][unconst_u32(321)][0], buffer95[unconst_u32(116)][5][0][0][0][0][0][16][0][u32((*&buffer95)[unconst_u32(35)][5][0][unconst_u32(9)][0][0][0][unconst_u32(2)][0][0][0][0])][unconst_u32(321)][0], buffer95[unconst_u32(116)][5][0][0][0][0][0][16][0][u32((*&buffer95)[unconst_u32(35)][5][0][unconst_u32(9)][0][0][0][unconst_u32(2)][0][0][0][0])][unconst_u32(321)][0], buffer95[unconst_u32(116)][5][0][0][0][0][0][16][0][u32((*&buffer95)[unconst_u32(35)][5][0][unconst_u32(9)][0][0][0][unconst_u32(2)][0][0][0][0])][unconst_u32(321)][0], buffer95[unconst_u32(116)][5][0][0][0][0][0][16][0][u32((*&buffer95)[unconst_u32(35)][5][0][unconst_u32(9)][0][0][0][unconst_u32(2)][0][0][0][0])][unconst_u32(321)][0]);
  let ptr68: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &buffer95[15][unconst_u32(242)][unconst_u32(80)][0][unconst_u32(183)][0][0][16][unconst_u32(263)];
  break;
  _ = buffer95;
}
  }
  let ptr69: ptr<storage, f16, read> = &(*&buffer95)[15][unconst_u32(344)][0][unconst_u32(8)][0][0][0][16][unconst_u32(162)][u32((*&buffer95)[15][5][unconst_u32(310)][0][0][u32(buffer95[unconst_u32(174)][5][0][0][unconst_u32(17)][u32(buffer95[unconst_u32(117)][unconst_u32(27)][0][0][unconst_u32(342)][unconst_u32(106)][0][16][unconst_u32(886)][0][0][0])][0][unconst_u32(130)][unconst_u32(272)][u32((*&buffer95)[unconst_u32(25)][unconst_u32(23)][unconst_u32(13)][0][unconst_u32(4)][0][unconst_u32(272)][unconst_u32(309)][unconst_u32(263)][unconst_u32(239)][0][0])][0][u32(buffer95[15][5][0][0][0][0][0][unconst_u32(36)][0][0][0][unconst_u32(79)])])][0][unconst_u32(4)][0][0][0][0])][0][0];
  let ptr70: ptr<storage, f16, read> = &(*&buffer95)[unconst_u32(29)][unconst_u32(126)][0][unconst_u32(11)][unconst_u32(146)][0][0][16][unconst_u32(131)][0][unconst_u32(97)][unconst_u32(267)];
  loop {
  let ptr71: ptr<storage, f16, read> = &(*&buffer95)[15][unconst_u32(611)][0][unconst_u32(74)][0][unconst_u32(162)][0][16][0][0][0][0];
  let ptr72: ptr<storage, array<f16, 1>, read> = &buffer95[unconst_u32(327)][5][0][0][unconst_u32(236)][unconst_u32(146)][0][unconst_u32(31)][unconst_u32(321)][unconst_u32(95)][0];
  vp3 = mat2x3h((*&buffer95)[15][unconst_u32(197)][0][unconst_u32(28)][unconst_u32(114)][0][0][unconst_u32(6)][unconst_u32(30)][0][0][0], (*&buffer95)[15][unconst_u32(197)][0][unconst_u32(28)][unconst_u32(114)][0][0][unconst_u32(6)][unconst_u32(30)][0][0][0], (*&buffer95)[15][unconst_u32(197)][0][unconst_u32(28)][unconst_u32(114)][0][0][unconst_u32(6)][unconst_u32(30)][0][0][0], (*&buffer95)[15][unconst_u32(197)][0][unconst_u32(28)][unconst_u32(114)][0][0][unconst_u32(6)][unconst_u32(30)][0][0][0], (*&buffer95)[15][unconst_u32(197)][0][unconst_u32(28)][unconst_u32(114)][0][0][unconst_u32(6)][unconst_u32(30)][0][0][0], (*&buffer95)[15][unconst_u32(197)][0][unconst_u32(28)][unconst_u32(114)][0][0][unconst_u32(6)][unconst_u32(30)][0][0][0]);
  let ptr73: ptr<storage, f16, read> = &buffer95[unconst_u32(121)][5][unconst_u32(12)][0][0][0][0][unconst_u32(75)][0][0][unconst_u32(124)][0];
  break;
  _ = buffer95;
}
  let ptr74: ptr<storage, array<f16, 1>, read> = &(*&buffer95)[unconst_u32(267)][unconst_u32(397)][0][0][unconst_u32(8)][0][0][16][0][0][0];
  let ptr75: ptr<storage, f16, read> = &buffer95[unconst_u32(138)][5][unconst_u32(45)][0][0][0][unconst_u32(150)][16][0][0][0][0];
  let ptr76: ptr<storage, array<array<f16, 1>, 1>, read> = &(*&buffer95)[u32(buffer95[unconst_u32(187)][5][unconst_u32(24)][unconst_u32(515)][u32(buffer95[15][5][0][0][0][0][0][16][0][u32((*&buffer95)[unconst_u32(156)][5][0][unconst_u32(7)][0][0][unconst_u32(230)][16][unconst_u32(108)][0][unconst_u32(57)][unconst_u32(1)])][0][0])][0][0][unconst_u32(154)][0][0][0][unconst_u32(5)])][5][0][unconst_u32(76)][0][0][unconst_u32(446)][unconst_u32(38)][unconst_u32(165)][unconst_u32(577)];
  let ptr77: ptr<storage, array<array<f16, 1>, 1>, read> = &(*&buffer95)[15][unconst_u32(146)][unconst_u32(266)][u32(buffer95[15][unconst_u32(6)][unconst_u32(202)][0][unconst_u32(5)][unconst_u32(65)][0][16][unconst_u32(312)][u32(buffer95[unconst_u32(168)][unconst_u32(39)][0][unconst_u32(166)][unconst_u32(113)][0][unconst_u32(279)][16][0][unconst_u32(49)][0][0])][0][0])][0][0][unconst_u32(115)][u32((*&buffer95)[unconst_u32(33)][unconst_u32(185)][0][0][unconst_u32(91)][0][0][16][0][0][u32((*&buffer95)[unconst_u32(13)][unconst_u32(324)][0][0][0][0][0][16][0][unconst_u32(260)][0][unconst_u32(201)])][unconst_u32(29)])][unconst_u32(524)][0];
  out = mat2x2h(buffer95[unconst_u32(141)][5][unconst_u32(176)][0][u32(buffer95[unconst_u32(94)][5][0][0][unconst_u32(174)][0][0][16][0][unconst_u32(139)][0][0])][unconst_u32(266)][0][unconst_u32(21)][0][0][unconst_u32(230)][unconst_u32(112)], buffer95[unconst_u32(141)][5][unconst_u32(176)][0][u32(buffer95[unconst_u32(94)][5][0][0][unconst_u32(174)][0][0][16][0][unconst_u32(139)][0][0])][unconst_u32(266)][0][unconst_u32(21)][0][0][unconst_u32(230)][unconst_u32(112)], buffer95[unconst_u32(141)][5][unconst_u32(176)][0][u32(buffer95[unconst_u32(94)][5][0][0][unconst_u32(174)][0][0][16][0][unconst_u32(139)][0][0])][unconst_u32(266)][0][unconst_u32(21)][0][0][unconst_u32(230)][unconst_u32(112)], buffer95[unconst_u32(141)][5][unconst_u32(176)][0][u32(buffer95[unconst_u32(94)][5][0][0][unconst_u32(174)][0][0][16][0][unconst_u32(139)][0][0])][unconst_u32(266)][0][unconst_u32(21)][0][0][unconst_u32(230)][unconst_u32(112)]);
  switch i32((*&buffer95)[unconst_u32(394)][unconst_u32(92)][0][unconst_u32(690)][u32(buffer95[unconst_u32(124)][5][unconst_u32(34)][0][unconst_u32(156)][0][unconst_u32(224)][16][0][unconst_u32(317)][0][0])][unconst_u32(116)][0][unconst_u32(89)][unconst_u32(69)][0][0][0]) { 
  default {
  out = mat2x2h((*&buffer95)[unconst_u32(39)][5][unconst_u32(53)][0][unconst_u32(263)][0][unconst_u32(136)][16][unconst_u32(108)][unconst_u32(150)][unconst_u32(454)][0], (*&buffer95)[unconst_u32(39)][5][unconst_u32(53)][0][unconst_u32(263)][0][unconst_u32(136)][16][unconst_u32(108)][unconst_u32(150)][unconst_u32(454)][0], (*&buffer95)[unconst_u32(39)][5][unconst_u32(53)][0][unconst_u32(263)][0][unconst_u32(136)][16][unconst_u32(108)][unconst_u32(150)][unconst_u32(454)][0], (*&buffer95)[unconst_u32(39)][5][unconst_u32(53)][0][unconst_u32(263)][0][unconst_u32(136)][16][unconst_u32(108)][unconst_u32(150)][unconst_u32(454)][0]);
  _ = buffer95;
}
  }
  let ptr78: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 1>, read> = &(*&buffer95)[unconst_u32(259)][5][unconst_u32(60)][unconst_u32(533)][unconst_u32(226)][u32((*&buffer95)[15][unconst_u32(214)][unconst_u32(195)][unconst_u32(423)][unconst_u32(112)][unconst_u32(99)][unconst_u32(179)][unconst_u32(42)][unconst_u32(49)][0][0][0])][unconst_u32(382)][16];
  let ptr79: ptr<storage, f16, read> = &(*&buffer95)[15][5][unconst_u32(4)][unconst_u32(30)][0][0][0][unconst_u32(93)][unconst_u32(21)][u32((*&buffer95)[15][5][0][unconst_u32(28)][0][unconst_u32(177)][unconst_u32(81)][unconst_u32(211)][0][0][unconst_u32(85)][0])][unconst_u32(44)][unconst_u32(31)];
  return out;
  _ = buffer95;
}

@group(0) @binding(578) var<storage, read> buffer95: array<array<array<array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 17>, 1>, 1>, 1>, 1>, 1>, 6>, 16>;

var<workgroup> vw26: atomic<u32>;

var<workgroup> vw25: vec4u;

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

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

/* used global variables: buffer95 */
fn fn3(a0: array<FragmentOutput5, 1>) -> mat4x3h {
  var out: mat4x3h;
  let ptr92: ptr<storage, array<array<f16, 1>, 1>, read> = &buffer95[15][unconst_u32(102)][unconst_u32(291)][u32((*&buffer95)[15][5][0][0][unconst_u32(90)][u32(buffer95[u32(buffer95[unconst_u32(207)][unconst_u32(561)][unconst_u32(90)][0][unconst_u32(242)][0][u32(buffer95[15][5][0][0][unconst_u32(78)][0][unconst_u32(150)][16][0][0][0][0])][unconst_u32(25)][0][0][unconst_u32(130)][0])][unconst_u32(171)][u32(buffer95[15][5][0][0][0][u32((*&buffer95)[unconst_u32(176)][5][0][unconst_u32(536)][0][0][0][16][unconst_u32(49)][0][0][0])][unconst_u32(29)][16][0][unconst_u32(153)][0][0])][unconst_u32(253)][0][0][unconst_u32(8)][unconst_u32(145)][0][unconst_u32(210)][unconst_u32(140)][0])][0][unconst_u32(355)][unconst_u32(54)][0][0][0])][unconst_u32(1)][unconst_u32(135)][u32(buffer95[unconst_u32(7)][unconst_u32(126)][0][0][0][0][0][16][u32(buffer95[15][unconst_u32(8)][0][0][0][unconst_u32(181)][unconst_u32(53)][16][0][0][0][0])][0][unconst_u32(58)][0])][u32(buffer95[unconst_u32(166)][unconst_u32(0)][0][unconst_u32(196)][0][0][0][unconst_u32(605)][unconst_u32(120)][unconst_u32(16)][0][0])][0][unconst_u32(3)];
  return out;
  _ = buffer95;
}

/* used global variables: buffer95 */
@must_use 
fn fn0() -> vec4h {
  var out: vec4h;
  for (var it5=u32(buffer95[unconst_u32(49)][5][0][unconst_u32(22)][unconst_u32(100)][0][0][unconst_u32(48)][0][0][0][0]); it5<u32((*&buffer95)[unconst_u32(243)][unconst_u32(231)][unconst_u32(220)][0][0][unconst_u32(78)][unconst_u32(121)][unconst_u32(20)][0][unconst_u32(81)][unconst_u32(501)][0]); it5++) {
  vp3 = mat2x3h((*&buffer95)[15][unconst_u32(111)][0][0][0][0][unconst_u32(333)][unconst_u32(506)][0][unconst_u32(152)][u32((*&buffer95)[15][unconst_u32(67)][unconst_u32(92)][0][unconst_u32(562)][0][0][16][unconst_u32(489)][0][0][0])][0], (*&buffer95)[15][unconst_u32(111)][0][0][0][0][unconst_u32(333)][unconst_u32(506)][0][unconst_u32(152)][u32((*&buffer95)[15][unconst_u32(67)][unconst_u32(92)][0][unconst_u32(562)][0][0][16][unconst_u32(489)][0][0][0])][0], (*&buffer95)[15][unconst_u32(111)][0][0][0][0][unconst_u32(333)][unconst_u32(506)][0][unconst_u32(152)][u32((*&buffer95)[15][unconst_u32(67)][unconst_u32(92)][0][unconst_u32(562)][0][0][16][unconst_u32(489)][0][0][0])][0], (*&buffer95)[15][unconst_u32(111)][0][0][0][0][unconst_u32(333)][unconst_u32(506)][0][unconst_u32(152)][u32((*&buffer95)[15][unconst_u32(67)][unconst_u32(92)][0][unconst_u32(562)][0][0][16][unconst_u32(489)][0][0][0])][0], (*&buffer95)[15][unconst_u32(111)][0][0][0][0][unconst_u32(333)][unconst_u32(506)][0][unconst_u32(152)][u32((*&buffer95)[15][unconst_u32(67)][unconst_u32(92)][0][unconst_u32(562)][0][0][16][unconst_u32(489)][0][0][0])][0], (*&buffer95)[15][unconst_u32(111)][0][0][0][0][unconst_u32(333)][unconst_u32(506)][0][unconst_u32(152)][u32((*&buffer95)[15][unconst_u32(67)][unconst_u32(92)][0][unconst_u32(562)][0][0][16][unconst_u32(489)][0][0][0])][0]);
  let ptr65: ptr<storage, array<f16, 1>, read> = &(*&buffer95)[unconst_u32(380)][5][unconst_u32(108)][unconst_u32(335)][unconst_u32(21)][unconst_u32(18)][unconst_u32(285)][16][0][unconst_u32(188)][unconst_u32(22)];
  return out;
  _ = buffer95;
}
  return out;
  _ = buffer95;
}

var<workgroup> vw21: array<vec2f, 26>;

@id(13179) override override8 = false;

/* used global variables: buffer95 */
fn fn4(a0: ptr<function, array<array<vec4u, 9>, 1>>) -> mat3x2f {
  var out: mat3x2f;
  {
  (*a0)[unconst_u32(110)][unconst_u32(98)] -= vec4u(u32(buffer95[15][5][0][0][unconst_u32(495)][0][0][16][unconst_u32(204)][unconst_u32(459)][unconst_u32(37)][0]));
  (*a0)[unconst_u32(452)][unconst_u32(53)] = vec4u(u32(buffer95[15][unconst_u32(13)][unconst_u32(27)][unconst_u32(32)][0][unconst_u32(66)][0][16][unconst_u32(31)][0][0][0]));
  out = mat3x2f(f32(buffer95[15][unconst_u32(11)][0][unconst_u32(93)][0][unconst_u32(470)][0][16][unconst_u32(197)][unconst_u32(44)][0][unconst_u32(250)]), f32(buffer95[15][unconst_u32(11)][0][unconst_u32(93)][0][unconst_u32(470)][0][16][unconst_u32(197)][unconst_u32(44)][0][unconst_u32(250)]), f32(buffer95[15][unconst_u32(11)][0][unconst_u32(93)][0][unconst_u32(470)][0][16][unconst_u32(197)][unconst_u32(44)][0][unconst_u32(250)]), f32(buffer95[15][unconst_u32(11)][0][unconst_u32(93)][0][unconst_u32(470)][0][16][unconst_u32(197)][unconst_u32(44)][0][unconst_u32(250)]), f32(buffer95[15][unconst_u32(11)][0][unconst_u32(93)][0][unconst_u32(470)][0][16][unconst_u32(197)][unconst_u32(44)][0][unconst_u32(250)]), f32(buffer95[15][unconst_u32(11)][0][unconst_u32(93)][0][unconst_u32(470)][0][16][unconst_u32(197)][unconst_u32(44)][0][unconst_u32(250)]));
  fn3(array<FragmentOutput5, 1>(FragmentOutput5(unpack4xU8(u32(buffer95[15][unconst_u32(132)][0][0][unconst_u32(168)][unconst_u32(67)][unconst_u32(237)][16][unconst_u32(12)][unconst_u32(447)][unconst_u32(35)][unconst_u32(57)])))));
  fn3(array<FragmentOutput5, 1>(FragmentOutput5(vec4u(u32((*&buffer95)[15][u32((*&buffer95)[15][5][0][unconst_u32(386)][0][unconst_u32(570)][0][16][unconst_u32(160)][unconst_u32(63)][0][0])][0][0][unconst_u32(63)][unconst_u32(91)][unconst_u32(28)][16][unconst_u32(22)][unconst_u32(109)][0][0])))));
  (*a0)[unconst_u32(118)][unconst_u32(342)] = vec4u(u32(buffer95[unconst_u32(49)][unconst_u32(5)][unconst_u32(211)][unconst_u32(729)][unconst_u32(335)][unconst_u32(450)][unconst_u32(2)][16][0][unconst_u32(372)][0][0]));
  _ = buffer95;
}
  (*a0)[unconst_u32(61)][unconst_u32(343)] *= vec4u(u32((*&buffer95)[15][unconst_u32(686)][0][0][0][unconst_u32(95)][0][unconst_u32(187)][unconst_u32(203)][0][0][0]));
  switch i32(buffer95[15][u32(buffer95[unconst_u32(648)][unconst_u32(121)][0][0][0][unconst_u32(16)][unconst_u32(360)][unconst_u32(170)][unconst_u32(23)][0][0][0])][0][0][0][0][unconst_u32(450)][unconst_u32(508)][unconst_u32(225)][0][0][unconst_u32(61)]) { 
  default {
  out = mat3x2f(f32((*&buffer95)[unconst_u32(328)][unconst_u32(489)][0][unconst_u32(357)][unconst_u32(546)][unconst_u32(152)][0][16][0][0][0][0]), f32((*&buffer95)[unconst_u32(328)][unconst_u32(489)][0][unconst_u32(357)][unconst_u32(546)][unconst_u32(152)][0][16][0][0][0][0]), f32((*&buffer95)[unconst_u32(328)][unconst_u32(489)][0][unconst_u32(357)][unconst_u32(546)][unconst_u32(152)][0][16][0][0][0][0]), f32((*&buffer95)[unconst_u32(328)][unconst_u32(489)][0][unconst_u32(357)][unconst_u32(546)][unconst_u32(152)][0][16][0][0][0][0]), f32((*&buffer95)[unconst_u32(328)][unconst_u32(489)][0][unconst_u32(357)][unconst_u32(546)][unconst_u32(152)][0][16][0][0][0][0]), f32((*&buffer95)[unconst_u32(328)][unconst_u32(489)][0][unconst_u32(357)][unconst_u32(546)][unconst_u32(152)][0][16][0][0][0][0]));
  let ptr93: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 1>, read> = &(*&buffer95)[15][5][unconst_u32(132)][unconst_u32(208)][0][0][unconst_u32(50)][unconst_u32(275)];
  let ptr94: ptr<storage, array<f16, 1>, read> = &(*&buffer95)[u32(buffer95[u32((*&buffer95)[15][unconst_u32(368)][0][unconst_u32(17)][unconst_u32(599)][0][0][unconst_u32(7)][0][unconst_u32(138)][unconst_u32(132)][0])][unconst_u32(120)][unconst_u32(639)][0][unconst_u32(16)][unconst_u32(477)][0][16][unconst_u32(89)][0][unconst_u32(239)][u32(buffer95[15][5][unconst_u32(98)][unconst_u32(30)][unconst_u32(185)][unconst_u32(82)][unconst_u32(147)][16][0][unconst_u32(7)][0][0])])][unconst_u32(88)][u32((*&buffer95)[15][5][unconst_u32(113)][0][u32(buffer95[unconst_u32(223)][unconst_u32(204)][0][0][0][0][0][unconst_u32(113)][unconst_u32(276)][0][0][unconst_u32(53)])][unconst_u32(59)][0][unconst_u32(190)][0][unconst_u32(33)][0][unconst_u32(127)])][0][unconst_u32(44)][unconst_u32(36)][unconst_u32(110)][unconst_u32(129)][u32((*&buffer95)[15][5][0][unconst_u32(2)][0][0][0][unconst_u32(190)][0][0][0][0])][unconst_u32(32)][0];
  break;
  _ = buffer95;
}
  }
  let ptr95: ptr<storage, f16, read> = &(*&buffer95)[15][5][unconst_u32(38)][0][0][unconst_u32(190)][unconst_u32(7)][u32(buffer95[15][5][unconst_u32(64)][unconst_u32(66)][unconst_u32(106)][unconst_u32(459)][unconst_u32(93)][unconst_u32(79)][unconst_u32(478)][unconst_u32(39)][0][0])][0][0][u32(buffer95[unconst_u32(180)][5][unconst_u32(359)][unconst_u32(237)][0][unconst_u32(288)][0][unconst_u32(13)][unconst_u32(22)][unconst_u32(42)][0][0])][0];
  out = mat3x2f(f32((*&buffer95)[15][5][0][u32(buffer95[unconst_u32(106)][5][0][unconst_u32(179)][unconst_u32(70)][0][unconst_u32(103)][unconst_u32(353)][0][0][0][0])][0][unconst_u32(212)][0][unconst_u32(29)][0][0][unconst_u32(76)][0]), f32((*&buffer95)[15][5][0][u32(buffer95[unconst_u32(106)][5][0][unconst_u32(179)][unconst_u32(70)][0][unconst_u32(103)][unconst_u32(353)][0][0][0][0])][0][unconst_u32(212)][0][unconst_u32(29)][0][0][unconst_u32(76)][0]), f32((*&buffer95)[15][5][0][u32(buffer95[unconst_u32(106)][5][0][unconst_u32(179)][unconst_u32(70)][0][unconst_u32(103)][unconst_u32(353)][0][0][0][0])][0][unconst_u32(212)][0][unconst_u32(29)][0][0][unconst_u32(76)][0]), f32((*&buffer95)[15][5][0][u32(buffer95[unconst_u32(106)][5][0][unconst_u32(179)][unconst_u32(70)][0][unconst_u32(103)][unconst_u32(353)][0][0][0][0])][0][unconst_u32(212)][0][unconst_u32(29)][0][0][unconst_u32(76)][0]), f32((*&buffer95)[15][5][0][u32(buffer95[unconst_u32(106)][5][0][unconst_u32(179)][unconst_u32(70)][0][unconst_u32(103)][unconst_u32(353)][0][0][0][0])][0][unconst_u32(212)][0][unconst_u32(29)][0][0][unconst_u32(76)][0]), f32((*&buffer95)[15][5][0][u32(buffer95[unconst_u32(106)][5][0][unconst_u32(179)][unconst_u32(70)][0][unconst_u32(103)][unconst_u32(353)][0][0][0][0])][0][unconst_u32(212)][0][unconst_u32(29)][0][0][unconst_u32(76)][0]));
  return out;
  _ = buffer95;
}

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

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

var<workgroup> vw22: atomic<u32>;

struct T2 {
  f0: T0,
}

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

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

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

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

/* used global variables: buffer95 */
fn fn2(a0: mat3x3f) -> i32 {
  var out: i32;
  out = i32(buffer95[15][5][0][unconst_u32(595)][unconst_u32(168)][0][unconst_u32(624)][16][0][unconst_u32(165)][0][0]);
  let ptr80: ptr<storage, f16, read> = &(*&buffer95)[15][unconst_u32(92)][unconst_u32(3)][0][unconst_u32(56)][unconst_u32(40)][unconst_u32(5)][unconst_u32(104)][unconst_u32(134)][unconst_u32(61)][unconst_u32(63)][0];
  if bool((*&buffer95)[15][5][0][unconst_u32(96)][unconst_u32(204)][unconst_u32(45)][0][16][unconst_u32(22)][0][0][unconst_u32(365)]) {
  while bool(buffer95[15][5][0][0][unconst_u32(143)][0][0][unconst_u32(78)][unconst_u32(181)][0][unconst_u32(143)][unconst_u32(74)]) {
  out = i32(buffer95[unconst_u32(796)][unconst_u32(125)][unconst_u32(203)][0][0][0][unconst_u32(24)][16][u32(buffer95[unconst_u32(172)][5][0][unconst_u32(65)][0][unconst_u32(100)][0][unconst_u32(679)][0][0][0][0])][unconst_u32(76)][0][0]);
  let ptr81: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &buffer95[15][5][0][unconst_u32(270)][unconst_u32(16)][0][0][16][0];
  break;
  _ = buffer95;
}
  let ptr82: ptr<storage, array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 17>, 1>, read> = &(*&buffer95)[unconst_u32(116)][unconst_u32(11)][0][unconst_u32(168)][0][unconst_u32(27)];
  _ = buffer95;
}
  let ptr83: ptr<storage, f16, read> = &(*&buffer95)[unconst_u32(169)][5][0][0][0][0][0][unconst_u32(323)][unconst_u32(32)][unconst_u32(377)][unconst_u32(37)][unconst_u32(112)];
  let ptr84: ptr<storage, array<array<f16, 1>, 1>, read> = &(*&buffer95)[unconst_u32(110)][unconst_u32(863)][0][unconst_u32(224)][unconst_u32(402)][unconst_u32(3)][unconst_u32(186)][unconst_u32(276)][unconst_u32(417)][unconst_u32(85)];
  vp3 = mat2x3h(buffer95[15][unconst_u32(236)][0][0][0][0][unconst_u32(73)][16][unconst_u32(152)][0][0][0], buffer95[15][unconst_u32(236)][0][0][0][0][unconst_u32(73)][16][unconst_u32(152)][0][0][0], buffer95[15][unconst_u32(236)][0][0][0][0][unconst_u32(73)][16][unconst_u32(152)][0][0][0], buffer95[15][unconst_u32(236)][0][0][0][0][unconst_u32(73)][16][unconst_u32(152)][0][0][0], buffer95[15][unconst_u32(236)][0][0][0][0][unconst_u32(73)][16][unconst_u32(152)][0][0][0], buffer95[15][unconst_u32(236)][0][0][0][0][unconst_u32(73)][16][unconst_u32(152)][0][0][0]);
  let ptr85: ptr<storage, array<array<f16, 1>, 1>, read> = &buffer95[15][unconst_u32(18)][0][unconst_u32(12)][0][0][unconst_u32(115)][16][unconst_u32(120)][0];
  if bool(buffer95[15][5][unconst_u32(536)][unconst_u32(12)][unconst_u32(173)][unconst_u32(107)][0][u32(buffer95[unconst_u32(130)][unconst_u32(1)][unconst_u32(558)][unconst_u32(739)][0][unconst_u32(236)][unconst_u32(712)][unconst_u32(76)][unconst_u32(19)][unconst_u32(42)][0][0])][0][unconst_u32(41)][0][0]) {
  let ptr86: ptr<storage, array<f16, 1>, read> = &buffer95[15][5][unconst_u32(74)][0][0][unconst_u32(430)][unconst_u32(43)][unconst_u32(113)][0][0][u32(buffer95[unconst_u32(353)][5][unconst_u32(19)][0][0][0][0][unconst_u32(31)][0][unconst_u32(0)][0][0])];
  vp3 += mat2x3h(buffer95[15][5][0][unconst_u32(271)][0][0][0][unconst_u32(55)][unconst_u32(275)][0][0][0], buffer95[15][5][0][unconst_u32(271)][0][0][0][unconst_u32(55)][unconst_u32(275)][0][0][0], buffer95[15][5][0][unconst_u32(271)][0][0][0][unconst_u32(55)][unconst_u32(275)][0][0][0], buffer95[15][5][0][unconst_u32(271)][0][0][0][unconst_u32(55)][unconst_u32(275)][0][0][0], buffer95[15][5][0][unconst_u32(271)][0][0][0][unconst_u32(55)][unconst_u32(275)][0][0][0], buffer95[15][5][0][unconst_u32(271)][0][0][0][unconst_u32(55)][unconst_u32(275)][0][0][0]);
  loop {
  let ptr87: ptr<storage, array<f16, 1>, read> = &buffer95[15][5][unconst_u32(15)][unconst_u32(482)][0][0][0][16][0][0][0];
  out &= i32(buffer95[u32(buffer95[15][5][u32(buffer95[15][5][0][0][0][0][0][16][0][0][0][0])][unconst_u32(364)][0][0][0][unconst_u32(310)][unconst_u32(54)][0][0][0])][5][0][0][0][0][unconst_u32(97)][16][0][0][0][unconst_u32(169)]);
  break;
  _ = buffer95;
}
  if bool((*&buffer95)[15][5][0][unconst_u32(4)][0][unconst_u32(107)][u32((*&buffer95)[15][5][0][0][unconst_u32(51)][unconst_u32(324)][unconst_u32(13)][unconst_u32(4)][unconst_u32(65)][unconst_u32(356)][0][0])][unconst_u32(163)][unconst_u32(223)][unconst_u32(302)][0][0]) {
  out |= i32((*&buffer95)[15][5][0][0][0][unconst_u32(339)][0][unconst_u32(74)][unconst_u32(26)][0][unconst_u32(1)][0]);
  let ptr88: ptr<storage, array<f16, 1>, read> = &(*&buffer95)[15][5][0][0][0][0][0][unconst_u32(57)][unconst_u32(323)][0][0];
  out -= i32((*&buffer95)[15][5][0][0][0][0][0][unconst_u32(113)][unconst_u32(274)][unconst_u32(36)][0][0]);
  vp3 = mat2x3h((*&buffer95)[unconst_u32(701)][5][unconst_u32(81)][unconst_u32(9)][u32(buffer95[15][u32((*&buffer95)[15][unconst_u32(16)][u32((*&buffer95)[15][5][0][0][unconst_u32(238)][unconst_u32(33)][unconst_u32(54)][unconst_u32(82)][unconst_u32(28)][unconst_u32(5)][unconst_u32(90)][0])][0][unconst_u32(138)][0][0][16][unconst_u32(403)][0][unconst_u32(494)][unconst_u32(150)])][unconst_u32(227)][unconst_u32(106)][0][0][unconst_u32(44)][unconst_u32(199)][u32((*&buffer95)[15][5][0][unconst_u32(346)][u32(buffer95[15][5][unconst_u32(56)][unconst_u32(18)][unconst_u32(76)][unconst_u32(107)][0][16][unconst_u32(131)][0][0][0])][0][0][unconst_u32(27)][unconst_u32(6)][0][unconst_u32(413)][u32((*&buffer95)[unconst_u32(21)][5][unconst_u32(424)][unconst_u32(39)][0][0][unconst_u32(22)][16][0][unconst_u32(96)][0][unconst_u32(490)])])][0][0][0])][unconst_u32(34)][unconst_u32(181)][16][unconst_u32(37)][unconst_u32(181)][unconst_u32(202)][0], (*&buffer95)[unconst_u32(701)][5][unconst_u32(81)][unconst_u32(9)][u32(buffer95[15][u32((*&buffer95)[15][unconst_u32(16)][u32((*&buffer95)[15][5][0][0][unconst_u32(238)][unconst_u32(33)][unconst_u32(54)][unconst_u32(82)][unconst_u32(28)][unconst_u32(5)][unconst_u32(90)][0])][0][unconst_u32(138)][0][0][16][unconst_u32(403)][0][unconst_u32(494)][unconst_u32(150)])][unconst_u32(227)][unconst_u32(106)][0][0][unconst_u32(44)][unconst_u32(199)][u32((*&buffer95)[15][5][0][unconst_u32(346)][u32(buffer95[15][5][unconst_u32(56)][unconst_u32(18)][unconst_u32(76)][unconst_u32(107)][0][16][unconst_u32(131)][0][0][0])][0][0][unconst_u32(27)][unconst_u32(6)][0][unconst_u32(413)][u32((*&buffer95)[unconst_u32(21)][5][unconst_u32(424)][unconst_u32(39)][0][0][unconst_u32(22)][16][0][unconst_u32(96)][0][unconst_u32(490)])])][0][0][0])][unconst_u32(34)][unconst_u32(181)][16][unconst_u32(37)][unconst_u32(181)][unconst_u32(202)][0], (*&buffer95)[unconst_u32(701)][5][unconst_u32(81)][unconst_u32(9)][u32(buffer95[15][u32((*&buffer95)[15][unconst_u32(16)][u32((*&buffer95)[15][5][0][0][unconst_u32(238)][unconst_u32(33)][unconst_u32(54)][unconst_u32(82)][unconst_u32(28)][unconst_u32(5)][unconst_u32(90)][0])][0][unconst_u32(138)][0][0][16][unconst_u32(403)][0][unconst_u32(494)][unconst_u32(150)])][unconst_u32(227)][unconst_u32(106)][0][0][unconst_u32(44)][unconst_u32(199)][u32((*&buffer95)[15][5][0][unconst_u32(346)][u32(buffer95[15][5][unconst_u32(56)][unconst_u32(18)][unconst_u32(76)][unconst_u32(107)][0][16][unconst_u32(131)][0][0][0])][0][0][unconst_u32(27)][unconst_u32(6)][0][unconst_u32(413)][u32((*&buffer95)[unconst_u32(21)][5][unconst_u32(424)][unconst_u32(39)][0][0][unconst_u32(22)][16][0][unconst_u32(96)][0][unconst_u32(490)])])][0][0][0])][unconst_u32(34)][unconst_u32(181)][16][unconst_u32(37)][unconst_u32(181)][unconst_u32(202)][0], (*&buffer95)[unconst_u32(701)][5][unconst_u32(81)][unconst_u32(9)][u32(buffer95[15][u32((*&buffer95)[15][unconst_u32(16)][u32((*&buffer95)[15][5][0][0][unconst_u32(238)][unconst_u32(33)][unconst_u32(54)][unconst_u32(82)][unconst_u32(28)][unconst_u32(5)][unconst_u32(90)][0])][0][unconst_u32(138)][0][0][16][unconst_u32(403)][0][unconst_u32(494)][unconst_u32(150)])][unconst_u32(227)][unconst_u32(106)][0][0][unconst_u32(44)][unconst_u32(199)][u32((*&buffer95)[15][5][0][unconst_u32(346)][u32(buffer95[15][5][unconst_u32(56)][unconst_u32(18)][unconst_u32(76)][unconst_u32(107)][0][16][unconst_u32(131)][0][0][0])][0][0][unconst_u32(27)][unconst_u32(6)][0][unconst_u32(413)][u32((*&buffer95)[unconst_u32(21)][5][unconst_u32(424)][unconst_u32(39)][0][0][unconst_u32(22)][16][0][unconst_u32(96)][0][unconst_u32(490)])])][0][0][0])][unconst_u32(34)][unconst_u32(181)][16][unconst_u32(37)][unconst_u32(181)][unconst_u32(202)][0], (*&buffer95)[unconst_u32(701)][5][unconst_u32(81)][unconst_u32(9)][u32(buffer95[15][u32((*&buffer95)[15][unconst_u32(16)][u32((*&buffer95)[15][5][0][0][unconst_u32(238)][unconst_u32(33)][unconst_u32(54)][unconst_u32(82)][unconst_u32(28)][unconst_u32(5)][unconst_u32(90)][0])][0][unconst_u32(138)][0][0][16][unconst_u32(403)][0][unconst_u32(494)][unconst_u32(150)])][unconst_u32(227)][unconst_u32(106)][0][0][unconst_u32(44)][unconst_u32(199)][u32((*&buffer95)[15][5][0][unconst_u32(346)][u32(buffer95[15][5][unconst_u32(56)][unconst_u32(18)][unconst_u32(76)][unconst_u32(107)][0][16][unconst_u32(131)][0][0][0])][0][0][unconst_u32(27)][unconst_u32(6)][0][unconst_u32(413)][u32((*&buffer95)[unconst_u32(21)][5][unconst_u32(424)][unconst_u32(39)][0][0][unconst_u32(22)][16][0][unconst_u32(96)][0][unconst_u32(490)])])][0][0][0])][unconst_u32(34)][unconst_u32(181)][16][unconst_u32(37)][unconst_u32(181)][unconst_u32(202)][0], (*&buffer95)[unconst_u32(701)][5][unconst_u32(81)][unconst_u32(9)][u32(buffer95[15][u32((*&buffer95)[15][unconst_u32(16)][u32((*&buffer95)[15][5][0][0][unconst_u32(238)][unconst_u32(33)][unconst_u32(54)][unconst_u32(82)][unconst_u32(28)][unconst_u32(5)][unconst_u32(90)][0])][0][unconst_u32(138)][0][0][16][unconst_u32(403)][0][unconst_u32(494)][unconst_u32(150)])][unconst_u32(227)][unconst_u32(106)][0][0][unconst_u32(44)][unconst_u32(199)][u32((*&buffer95)[15][5][0][unconst_u32(346)][u32(buffer95[15][5][unconst_u32(56)][unconst_u32(18)][unconst_u32(76)][unconst_u32(107)][0][16][unconst_u32(131)][0][0][0])][0][0][unconst_u32(27)][unconst_u32(6)][0][unconst_u32(413)][u32((*&buffer95)[unconst_u32(21)][5][unconst_u32(424)][unconst_u32(39)][0][0][unconst_u32(22)][16][0][unconst_u32(96)][0][unconst_u32(490)])])][0][0][0])][unconst_u32(34)][unconst_u32(181)][16][unconst_u32(37)][unconst_u32(181)][unconst_u32(202)][0]);
  _ = buffer95;
}
  out = i32(buffer95[unconst_u32(193)][unconst_u32(63)][0][unconst_u32(130)][unconst_u32(387)][unconst_u32(194)][0][unconst_u32(111)][0][0][unconst_u32(587)][0]);
  out += i32(buffer95[unconst_u32(103)][u32((*&buffer95)[15][unconst_u32(21)][0][0][0][unconst_u32(176)][unconst_u32(56)][16][0][0][unconst_u32(64)][0])][0][0][unconst_u32(227)][unconst_u32(13)][0][16][0][0][0][0]);
  let ptr89: ptr<storage, array<array<f16, 1>, 1>, read> = &(*&buffer95)[unconst_u32(170)][u32(buffer95[unconst_u32(264)][5][0][0][0][0][0][16][0][0][0][0])][unconst_u32(40)][unconst_u32(209)][unconst_u32(42)][unconst_u32(165)][0][unconst_u32(560)][0][0];
  _ = buffer95;
}
  vp3 = mat2x3h((*&buffer95)[15][unconst_u32(87)][unconst_u32(328)][0][0][unconst_u32(57)][0][16][unconst_u32(20)][0][0][0], (*&buffer95)[15][unconst_u32(87)][unconst_u32(328)][0][0][unconst_u32(57)][0][16][unconst_u32(20)][0][0][0], (*&buffer95)[15][unconst_u32(87)][unconst_u32(328)][0][0][unconst_u32(57)][0][16][unconst_u32(20)][0][0][0], (*&buffer95)[15][unconst_u32(87)][unconst_u32(328)][0][0][unconst_u32(57)][0][16][unconst_u32(20)][0][0][0], (*&buffer95)[15][unconst_u32(87)][unconst_u32(328)][0][0][unconst_u32(57)][0][16][unconst_u32(20)][0][0][0], (*&buffer95)[15][unconst_u32(87)][unconst_u32(328)][0][0][unconst_u32(57)][0][16][unconst_u32(20)][0][0][0]);
  let ptr90: ptr<storage, array<array<f16, 1>, 1>, read> = &(*&buffer95)[15][5][unconst_u32(38)][unconst_u32(315)][0][0][0][u32(buffer95[15][unconst_u32(5)][unconst_u32(72)][unconst_u32(61)][0][unconst_u32(156)][0][16][unconst_u32(150)][0][0][0])][0][0];
  out += i32((*&buffer95)[unconst_u32(148)][unconst_u32(182)][0][unconst_u32(132)][0][0][unconst_u32(88)][16][unconst_u32(93)][0][0][0]);
  let ptr91: ptr<storage, f16, read> = &(*&buffer95)[15][unconst_u32(27)][0][unconst_u32(182)][unconst_u32(131)][0][0][unconst_u32(153)][unconst_u32(78)][0][unconst_u32(205)][unconst_u32(101)];
  return out;
  _ = buffer95;
}

var<workgroup> vw23: array<FragmentOutput5, 1>;

struct T0 {
  f0: array<f16>,
}

/* used global variables: buffer95 */
@fragment
fn fragment5() -> FragmentOutput5 {
  var out: FragmentOutput5;
  var vf82 = fn2(mat3x3f(f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0]), f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0]), f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0]), f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0]), f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0]), f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0]), f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0]), f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0]), f32((*&buffer95)[unconst_u32(30)][unconst_u32(37)][u32((*&buffer95)[unconst_u32(181)][unconst_u32(199)][unconst_u32(881)][unconst_u32(205)][0][unconst_u32(143)][0][unconst_u32(34)][unconst_u32(204)][unconst_u32(144)][unconst_u32(369)][0])][unconst_u32(142)][unconst_u32(26)][0][unconst_u32(506)][16][0][unconst_u32(76)][0][0])));
  out.f0 = unpack4xU8(u32((*&buffer95)[15][5][0][0][0][unconst_u32(265)][0][16][unconst_u32(112)][0][0][0]));
  vp3 -= mat2x3h((*&buffer95)[unconst_u32(87)][5][0][0][u32(buffer95[unconst_u32(335)][5][0][unconst_u32(138)][unconst_u32(168)][0][0][unconst_u32(175)][unconst_u32(13)][unconst_u32(61)][unconst_u32(110)][unconst_u32(158)])][u32(buffer95[unconst_u32(2)][5][0][0][u32(buffer95[unconst_u32(458)][5][0][0][unconst_u32(12)][unconst_u32(134)][unconst_u32(8)][unconst_u32(9)][0][0][0][0])][unconst_u32(133)][0][unconst_u32(108)][unconst_u32(263)][unconst_u32(38)][unconst_u32(678)][0])][0][16][0][unconst_u32(91)][0][0], (*&buffer95)[unconst_u32(87)][5][0][0][u32(buffer95[unconst_u32(335)][5][0][unconst_u32(138)][unconst_u32(168)][0][0][unconst_u32(175)][unconst_u32(13)][unconst_u32(61)][unconst_u32(110)][unconst_u32(158)])][u32(buffer95[unconst_u32(2)][5][0][0][u32(buffer95[unconst_u32(458)][5][0][0][unconst_u32(12)][unconst_u32(134)][unconst_u32(8)][unconst_u32(9)][0][0][0][0])][unconst_u32(133)][0][unconst_u32(108)][unconst_u32(263)][unconst_u32(38)][unconst_u32(678)][0])][0][16][0][unconst_u32(91)][0][0], (*&buffer95)[unconst_u32(87)][5][0][0][u32(buffer95[unconst_u32(335)][5][0][unconst_u32(138)][unconst_u32(168)][0][0][unconst_u32(175)][unconst_u32(13)][unconst_u32(61)][unconst_u32(110)][unconst_u32(158)])][u32(buffer95[unconst_u32(2)][5][0][0][u32(buffer95[unconst_u32(458)][5][0][0][unconst_u32(12)][unconst_u32(134)][unconst_u32(8)][unconst_u32(9)][0][0][0][0])][unconst_u32(133)][0][unconst_u32(108)][unconst_u32(263)][unconst_u32(38)][unconst_u32(678)][0])][0][16][0][unconst_u32(91)][0][0], (*&buffer95)[unconst_u32(87)][5][0][0][u32(buffer95[unconst_u32(335)][5][0][unconst_u32(138)][unconst_u32(168)][0][0][unconst_u32(175)][unconst_u32(13)][unconst_u32(61)][unconst_u32(110)][unconst_u32(158)])][u32(buffer95[unconst_u32(2)][5][0][0][u32(buffer95[unconst_u32(458)][5][0][0][unconst_u32(12)][unconst_u32(134)][unconst_u32(8)][unconst_u32(9)][0][0][0][0])][unconst_u32(133)][0][unconst_u32(108)][unconst_u32(263)][unconst_u32(38)][unconst_u32(678)][0])][0][16][0][unconst_u32(91)][0][0], (*&buffer95)[unconst_u32(87)][5][0][0][u32(buffer95[unconst_u32(335)][5][0][unconst_u32(138)][unconst_u32(168)][0][0][unconst_u32(175)][unconst_u32(13)][unconst_u32(61)][unconst_u32(110)][unconst_u32(158)])][u32(buffer95[unconst_u32(2)][5][0][0][u32(buffer95[unconst_u32(458)][5][0][0][unconst_u32(12)][unconst_u32(134)][unconst_u32(8)][unconst_u32(9)][0][0][0][0])][unconst_u32(133)][0][unconst_u32(108)][unconst_u32(263)][unconst_u32(38)][unconst_u32(678)][0])][0][16][0][unconst_u32(91)][0][0], (*&buffer95)[unconst_u32(87)][5][0][0][u32(buffer95[unconst_u32(335)][5][0][unconst_u32(138)][unconst_u32(168)][0][0][unconst_u32(175)][unconst_u32(13)][unconst_u32(61)][unconst_u32(110)][unconst_u32(158)])][u32(buffer95[unconst_u32(2)][5][0][0][u32(buffer95[unconst_u32(458)][5][0][0][unconst_u32(12)][unconst_u32(134)][unconst_u32(8)][unconst_u32(9)][0][0][0][0])][unconst_u32(133)][0][unconst_u32(108)][unconst_u32(263)][unconst_u32(38)][unconst_u32(678)][0])][0][16][0][unconst_u32(91)][0][0]);
  let ptr96: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &(*&buffer95)[15][unconst_u32(33)][unconst_u32(5)][0][0][unconst_u32(180)][0][unconst_u32(115)][unconst_u32(320)];
  let ptr97: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &buffer95[15][5][unconst_u32(292)][unconst_u32(1)][0][u32((*&buffer95)[15][5][unconst_u32(371)][0][unconst_u32(72)][0][0][16][0][0][0][0])][0][16][unconst_u32(296)];
  out = FragmentOutput5(vec4u(u32(buffer95[unconst_u32(113)][unconst_u32(10)][0][unconst_u32(98)][0][u32((*&buffer95)[15][unconst_u32(8)][0][0][0][0][0][16][unconst_u32(95)][unconst_u32(110)][0][unconst_u32(52)])][unconst_u32(24)][16][unconst_u32(511)][unconst_u32(9)][unconst_u32(90)][0])));
  let ptr98: ptr<storage, f16, read> = &(*&buffer95)[15][5][unconst_u32(115)][0][unconst_u32(179)][0][unconst_u32(26)][16][unconst_u32(217)][0][u32((*&buffer95)[unconst_u32(123)][unconst_u32(218)][unconst_u32(244)][unconst_u32(54)][0][unconst_u32(394)][0][unconst_u32(51)][unconst_u32(29)][unconst_u32(194)][unconst_u32(1)][0])][unconst_u32(311)];
  vf82 &= i32((*&buffer95)[15][unconst_u32(26)][0][0][unconst_u32(125)][0][unconst_u32(25)][unconst_u32(794)][0][unconst_u32(92)][unconst_u32(53)][unconst_u32(38)]);
  return out;
  _ = buffer95;
}

/* used global variables: buffer95 */
@compute @workgroup_size(1, 1, 1)
fn compute5() {
  atomicAdd(&vw26, unconst_u32(51));
  let ptr99: ptr<storage, f16, read> = &(*&buffer95)[15][unconst_u32(325)][0][0][0][0][unconst_u32(0)][16][0][unconst_u32(77)][0][unconst_u32(126)];
  let ptr100: ptr<storage, array<array<f16, 1>, 1>, read> = &buffer95[unconst_u32(23)][5][0][unconst_u32(113)][unconst_u32(364)][0][unconst_u32(9)][unconst_u32(35)][unconst_u32(209)][unconst_u32(96)];
  atomicAnd(&vw20[unconst_u32(29)][unconst_u32(30)], unconst_u32(46));
  {
  vw25 += unpack4xU8(u32(buffer95[unconst_u32(226)][unconst_u32(177)][unconst_u32(26)][0][unconst_u32(745)][unconst_u32(110)][0][unconst_u32(102)][0][0][unconst_u32(76)][0]));
  _ = buffer95;
}
  vw23[0] = FragmentOutput5(vec4u(u32((*&buffer95)[15][unconst_u32(26)][0][unconst_u32(37)][0][unconst_u32(39)][unconst_u32(8)][16][0][0][0][unconst_u32(402)])));
  _ = fn0();
  vw23[unconst_u32(206)] = FragmentOutput5(vec4u(u32(buffer95[unconst_u32(58)][unconst_u32(49)][0][unconst_u32(3)][unconst_u32(265)][unconst_u32(76)][unconst_u32(696)][16][unconst_u32(90)][0][unconst_u32(84)][unconst_u32(29)])));
  var vf83 = fn0();
  var vf84 = fn0();
  _ = buffer95;
}

/* used global variables: buffer95 */
@compute @workgroup_size(1, 1, 1)
fn compute6() {
  var vf85 = fn0();
  vw24 = f32(buffer95[15][unconst_u32(242)][0][0][0][unconst_u32(435)][0][16][0][0][0][0]);
  var vf86 = fn0();
  _ = fn0();
  var vf87 = fn0();
  atomicCompareExchangeWeak(&vw20[0][unconst_u32(147)], unconst_u32(63), unconst_u32(226));
  let ptr101: ptr<storage, array<f16, 1>, read> = &buffer95[15][unconst_u32(88)][0][unconst_u32(7)][0][unconst_u32(22)][0][unconst_u32(423)][0][0][unconst_u32(47)];
  let ptr102: ptr<storage, f16, read> = &buffer95[unconst_u32(13)][unconst_u32(79)][0][0][unconst_u32(122)][0][0][unconst_u32(90)][unconst_u32(226)][unconst_u32(185)][0][0];
  _ = fn0();
  let ptr103: ptr<storage, array<f16, 1>, read> = &(*&buffer95)[15][unconst_u32(160)][0][0][unconst_u32(110)][0][0][16][0][0][0];
  _ = buffer95;
}

/* used global variables: buffer95 */
@compute @workgroup_size(3, 1, 1)
fn compute7() {
  storageBarrier();
  let ptr104: ptr<storage, f16, read> = &(*&buffer95)[15][5][0][unconst_u32(176)][0][unconst_u32(806)][unconst_u32(306)][16][0][unconst_u32(15)][unconst_u32(62)][0];
  let ptr105: ptr<storage, f16, read> = &(*&buffer95)[15][unconst_u32(29)][unconst_u32(480)][0][unconst_u32(47)][0][unconst_u32(5)][16][unconst_u32(186)][u32((*&buffer95)[unconst_u32(10)][5][unconst_u32(31)][0][unconst_u32(69)][0][0][unconst_u32(260)][unconst_u32(48)][unconst_u32(80)][0][0])][u32(buffer95[15][unconst_u32(105)][0][0][0][unconst_u32(61)][0][unconst_u32(23)][unconst_u32(255)][0][0][0])][0];
  return;
  _ = buffer95;
}`,
});
let bindGroup81 = device0.createBindGroup({layout: veryExplicitBindGroupLayout17, entries: [{binding: 328, resource: textureView39}]});
let buffer96 = device0.createBuffer({size: 3797, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let texture115 = device0.createTexture({
  size: [45, 20, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView150 = texture40.createView({baseArrayLayer: 0, arrayLayerCount: 2});
try {
computePassEncoder64.setBindGroup(2, bindGroup4, new Uint32Array(277), 33, 0);
} catch {}
try {
computePassEncoder59.end();
} catch {}
try {
computePassEncoder113.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup62, new Uint32Array(3073), 45, 0);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer34, 324);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer8, 688);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline7);
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 136 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1408 */
  offset: 1408,
  bytesPerRow: 12288,
  buffer: buffer7,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline23 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2}});
let textureView151 = texture98.createView({baseMipLevel: 0, baseArrayLayer: 14, arrayLayerCount: 5});
try {
computePassEncoder88.setBindGroup(0, bindGroup49, new Uint32Array(1461), 783, 0);
} catch {}
try {
computePassEncoder41.end();
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer27, 192);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer61, 'uint16', 2_640, 1_030);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline2);
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1064 */
  offset: 1064,
  rowsPerImage: 373,
  buffer: buffer55,
}, {
  texture: texture89,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 2},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
let computePassEncoder114 = commandEncoder50.beginComputePass({});
try {
computePassEncoder64.setBindGroup(0, bindGroup10, new Uint32Array(675), 276, 0);
} catch {}
try {
computePassEncoder114.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder4.drawIndexed(4, 8, 21, 151_681_162, 1_027_734_515);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline12);
} catch {}
let promise25 = shaderModule1.getCompilationInfo();
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 284 */
  offset: 284,
  bytesPerRow: 2560,
  buffer: buffer29,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
}, {width: 1, height: 59, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder68.clearBuffer(buffer79, 820, 0);
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte432', transfer: 'bt709'} });
let textureView152 = texture43.createView({});
let renderPassEncoder32 = commandEncoder68.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 398,
  clearValue: { r: 255.5, g: 746.9, b: 276.2, a: 165.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet8, beginningOfPassWriteIndex: 194, endOfPassWriteIndex: 189},
});
try {
computePassEncoder112.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder4.end();
} catch {}
try {
renderPassEncoder13.draw(1, 56, 1, 341_806_241);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer81, 2_368);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer55, 'uint32', 1_748, 1_740);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline20);
} catch {}
try {
commandEncoder25.copyBufferToTexture({
  /* bytesInLastRow: 60 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2920 */
  offset: 2920,
  bytesPerRow: 2048,
  buffer: buffer2,
}, {
  texture: texture65,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
}, {width: 15, height: 4, depthOrArrayLayers: 0});
} catch {}
let querySet11 = device0.createQuerySet({type: 'timestamp', count: 1453});
try {
computePassEncoder109.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder13.draw(1, 93, 5, 93_217_530);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer5, 240);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer52, 144);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(4, buffer47, 0, 171);
} catch {}
try {
device0.queue.writeBuffer(buffer30, 988, new DataView(new ArrayBuffer(2122)), 78, 188);
} catch {}
let commandEncoder133 = device0.createCommandEncoder({});
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 560});
let computePassEncoder115 = commandEncoder133.beginComputePass({timestampWrites: {querySet: querySet5, beginningOfPassWriteIndex: 34}});
try {
computePassEncoder28.setBindGroup(1, bindGroup53);
} catch {}
try {
computePassEncoder101.setBindGroup(3, bindGroup58, new Uint32Array(4653), 427, 0);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer62, 188);
} catch {}
try {
commandEncoder25.copyBufferToBuffer(buffer47, 572, buffer59, 544, 640);
} catch {}
try {
commandEncoder25.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 152 */
  offset: 152,
  bytesPerRow: 21760,
  buffer: buffer1,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder25.copyTextureToBuffer({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 152 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 7744 */
  offset: 7744,
  buffer: buffer51,
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView153 = texture75.createView({arrayLayerCount: 1});
let computePassEncoder116 = commandEncoder25.beginComputePass({});
try {
renderPassEncoder16.setVertexBuffer(1, buffer81, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let buffer97 = device0.createBuffer({
  size: 784,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture116 = device0.createTexture({size: [90, 40, 45], dimension: '3d', format: 'rgba16uint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView154 = texture109.createView({dimension: '2d', baseMipLevel: 2, mipLevelCount: 1, baseArrayLayer: 1});
try {
renderPassEncoder12.setBindGroup(0, bindGroup55, new Uint32Array(1125), 593, 0);
} catch {}
try {
renderPassEncoder13.drawIndexed(0, 100, 0, -1_005_990_498, 2_139_906_241);
} catch {}
let buffer98 = device0.createBuffer({size: 965, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let texture117 = device0.createTexture({
  size: [45, 20, 1],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder16.setBindGroup(2, bindGroup49, new Uint32Array(2261), 82, 0);
} catch {}
try {
renderPassEncoder13.draw(0, 101, 1, 333_014_566);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer9, 'uint32', 404, 88);
} catch {}
let imageData18 = new ImageData(16, 12);
try {
computePassEncoder115.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder13.draw(0, 63, 4, 865_488_611);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder134 = device0.createCommandEncoder({});
let computePassEncoder117 = commandEncoder134.beginComputePass({timestampWrites: {querySet: querySet5}});
try {
computePassEncoder117.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer92, 480);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(27).fill(139), /* required buffer size: 27 */
{offset: 27}, {width: 3, height: 0, depthOrArrayLayers: 1});
} catch {}
let videoFrame21 = new VideoFrame(videoFrame0, {timestamp: 0});
let bindGroup82 = device0.createBindGroup({
  label: '\u4b36\u{1f708}\u{1f639}\u008c',
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 254, resource: {buffer: buffer16, offset: 256, size: 508}},
    {binding: 578, resource: {buffer: buffer75, offset: 512}},
    {binding: 62, resource: textureView9},
  ],
});
let pipelineLayout20 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout16]});
let commandEncoder135 = device0.createCommandEncoder();
try {
computePassEncoder69.setBindGroup(0, bindGroup20, []);
} catch {}
try {
computePassEncoder1.setBindGroup(2, bindGroup41, new Uint32Array(1077), 19, 0);
} catch {}
try {
renderPassEncoder13.drawIndexed(2, 195, 0, 616_981_187, 131_102_559);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer97, 296);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(1, buffer32, 2_100);
} catch {}
try {
commandEncoder135.copyBufferToTexture({
  /* bytesInLastRow: 280 widthInBlocks: 70 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 956 */
  offset: 956,
  bytesPerRow: 83456,
  buffer: buffer56,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 5, y: 3, z: 0},
  aspect: 'all',
}, {width: 70, height: 4, depthOrArrayLayers: 0});
} catch {}
let commandEncoder136 = device0.createCommandEncoder({});
let computePassEncoder118 = commandEncoder135.beginComputePass({});
try {
renderPassEncoder12.setBindGroup(3, bindGroup46, new Uint32Array(1689), 585, 0);
} catch {}
try {
renderPassEncoder13.draw(5, 209, 0, 113_986_517);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(2, buffer32, 0, 2_475);
} catch {}
try {
commandEncoder136.copyTextureToBuffer({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 6 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1299 */
  offset: 1299,
  rowsPerImage: 429,
  buffer: buffer29,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
let promise27 = device0.createRenderPipelineAsync({
  layout: pipelineLayout14,
  fragment: {
  module: shaderModule6,
  constants: {},
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex5',
    constants: {},
    buffers: [
      {
        arrayStride: 232,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x2', offset: 96, shaderLocation: 3}],
      },
    ],
  },
});
let commandEncoder137 = device0.createCommandEncoder({});
let computePassEncoder119 = commandEncoder136.beginComputePass({});
let renderPassEncoder33 = commandEncoder137.beginRenderPass({
  colorAttachments: [{
  view: textureView114,
  clearValue: { r: 497.2, g: 863.8, b: 461.6, a: 296.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet12,
  timestampWrites: {querySet: querySet8, endOfPassWriteIndex: 364},
  maxDrawCount: 252921138,
});
try {
renderPassEncoder26.setBindGroup(1, bindGroup40, new Uint32Array(222), 85, 0);
} catch {}
try {
renderPassEncoder13.draw(1, 22, 6, 327_154_932);
} catch {}
try {
renderPassEncoder13.drawIndexed(1, 161, 0, 347_321_148, 1_010_839_758);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer54, 104);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer63, 'uint32', 3_796, 738);
} catch {}
try {
device0.queue.writeBuffer(buffer96, 396, new Int16Array(2616), 106, 348);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

enable f16;

diagnostic(info, xyz);

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

struct FragmentOutput7 {
  @location(0) @interpolate(flat, first) f0: vec4u,
  @builtin(sample_mask) f1: u32,
}

struct T5 {
  f0: T0,
}

var<workgroup> vw28: array<T5, 1>;

struct T1 {
  f0: array<f16>,
}

/* zero global variables used */
@must_use 
fn fn5(a0: T3) -> T3 {
  var out: T3;
  var vf114 = fn4();
  out = T3(array<f16, 1>(a0.f0[unconst_u32(8)]));
  _ = fn4();
  _ = fn4();
  return out;
}

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

/* zero global variables used */
fn fn2(a0: ptr<storage, T4, read_write>) -> FragmentOutput7 {
  var out: FragmentOutput7;
  out.f0 = vec4u((vec3u(unconst_u32(337), unconst_u32(86), unconst_u32(52)) < vec3u(unconst_u32(258), unconst_u32(201), unconst_u32(308))).yzxx);
  let vf106: f16 = step(unconst_f16(1732.2), unconst_f16(12487.9));
  var vf107: bool = any(vec2<bool>(bool(step(unconst_f16(20343.8), unconst_f16(17227.9)))));
  out.f0 -= vec4u(u32(step(unconst_f16(653.4), unconst_f16(1759.9))));
  (*a0).f0 = (*a0).f0;
  return out;
}

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

struct T6 {
  f0: f16,
}

struct T3 {
  @align(4) @size(4) f0: array<f16, 1>,
}

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

@group(0) @binding(254) var<storage, read> buffer99: array<array<f16, 1>, 1>;

struct FragmentOutput6 {
  @location(0) f0: vec4f,
  @builtin(sample_mask) f1: u32,
}

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

struct T0 {
  f0: f16,
}

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

@group(0) @binding(62) var tex7: texture_depth_2d;

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

/* zero global variables used */
fn fn4() -> T6 {
  var out: T6;
  out.f0 *= f16(pack4xI8(vec4i(unconst_i32(465), unconst_i32(-160), unconst_i32(19), unconst_i32(73))));
  return out;
}

var<workgroup> vw29: FragmentOutput7;

struct T4 {
  f0: T1,
}

/* used global variables: tex7 */
@must_use 
fn fn1(a0: S1) -> T5 {
  var out: T5;
  var vf102 = fn0(T6(vw28[unconst_u32(186)].f0.f0));
  var vf103: f32 = ceil(unconst_f32(0.02206));
  let ptr107: ptr<workgroup, f16> = &(*&vw28)[unconst_u32(395)].f0.f0;
  switch i32(acos(vec4h(unconst_f16(36267.2), unconst_f16(4412.2), unconst_f16(8332.9), unconst_f16(2513.5))).r) { 
  default {
  vw28[unconst_u32(54)].f0.f0 = (*&vw28)[0].f0.f0;
  workgroupBarrier();
  return out;
}
  }
  var vf104: vec4h = cosh(vec4h(unconst_f16(7482.0), unconst_f16(57.89), unconst_f16(15538.5), unconst_f16(9263.5)));
  vf103 += f32((*&vw28)[0].f0.f0);
  for (var it8=u32(vw28[0].f0.f0); it8<textureNumLevels(tex7); it8++) {
  var vf105 = fn0(T6(f16(textureDimensions(tex7, unconst_i32(14))[1])));
  vw30[unconst_u32(70)] = T0((*&vw27).f0);
  let ptr108: ptr<workgroup, u32> = &vw29.f1;
  let ptr109: ptr<workgroup, T5> = &(*&vw28)[unconst_u32(34)];
  _ = fn0(T6(vec4h((*&vw29).f0).z));
  _ = tex7;
}
  out.f0.f0 = f16(pack4xI8Clamp(unpack4xI8(vw29.f0[unconst_u32(45)])));
  vf102.f0[unconst_u32(491)] -= vw30[0].f0;
  let ptr110: ptr<workgroup, T6> = &(*&vw27);
  return out;
  _ = tex7;
}

/* zero global variables used */
fn fn6(a0: T6, a1: T0, a2: T3, a3: T5) -> FragmentOutput7 {
  var out: FragmentOutput7;
  _ = fn4();
  _ = fn5(T3(array<f16, 1>((mat2x2h() * mat2x2h(unconst_f16(5548.0), unconst_f16(4020.5), unconst_f16(5210.8), unconst_f16(12887.6)))[unconst_i32(1)].r)));
  var vf115: vec3h = sin(vec3h(unconst_f16(1786.0), unconst_f16(8945.1), unconst_f16(9576.5)));
  for (var it10=u32(pow(f16(acosh(unconst_f32(0.1142))), unconst_f16(22315.3))); it10<pack4xU8Clamp(vec4u(unconst_u32(0), unconst_u32(134), unconst_u32(292), unconst_u32(56))); it10++) {
  fn4();
  break;
}
  vf115 -= vec3h(saturate(vec4f(unconst_f32(0.01676), unconst_f32(0.1211), unconst_f32(0.3204), unconst_f32(0.1354))).rgr);
  var vf116: vec4f = quantizeToF16(bitcast<vec4f>(reverseBits(vec2u(unconst_u32(88), unconst_u32(30))).rggg));
  var vf117 = fn4();
  out.f0 = unpack4xU8(u32(a2.f0[0]));
  var vf118 = fn5(T3(array<f16, 1>(a0.f0)));
  return out;
}

/* zero global variables used */
fn fn0(a0: T6) -> T3 {
  var out: T3;
  let vf88: vec2f = unpack2x16unorm(unconst_u32(314));
  for (var it7=vec4u((vec2h(unconst_f16(3326.3), unconst_f16(9067.2)) * mat4x2h(unconst_f16(16223.4), unconst_f16(24110.6), unconst_f16(1978.1), unconst_f16(2546.6), unconst_f16(36282.9), unconst_f16(20171.1), unconst_f16(14407.9), unconst_f16(14783.5))))[2]; it7<vec3u(refract(vec3h(unconst_f16(3607.7), unconst_f16(22657.3), unconst_f16(2568.9)), vec3h(unconst_f16(1119.5), unconst_f16(9444.2), unconst_f16(2110.0)), unconst_f16(11408.0)))[0]; it7++) {
  switch bitcast<i32>(pack4x8unorm(vec4f(unconst_f32(-0.1382), unconst_f32(0.1058), unconst_f32(0.06571), unconst_f32(0.2992)))) { 
  default {
  out = T3(array<f16, 1>(a0.f0));
  {
  var vf89: f16 = a0.f0;
  vf89 = vec4h((vec4h(unconst_f16(7881.4), unconst_f16(7993.4), unconst_f16(13953.9), unconst_f16(7190.5)) < vec4h(unconst_f16(-613.1), unconst_f16(1509.4), unconst_f16(16365.9), unconst_f16(1228.7))))[2];
}
  var vf90: vec4h = faceForward(vec4h(unconst_f16(3355.9), unconst_f16(9314.3), unconst_f16(8494.2), unconst_f16(7743.2)), vec4h(unconst_f16(1241.2), unconst_f16(9710.4), unconst_f16(2745.7), unconst_f16(5663.7)), vec4h(unconst_f16(127.0), unconst_f16(11036.6), unconst_f16(21749.1), unconst_f16(14815.6)));
  out.f0[unconst_u32(144)] = trunc(vec2h(unconst_f16(22404.9), unconst_f16(4264.0))).g;
  if bool(clamp(vec2u(unconst_u32(505), unconst_u32(45)), vec2u(unconst_u32(18), unconst_u32(145)), vec2u(transpose(mat3x3f(unconst_f32(0.04676), unconst_f32(0.01855), unconst_f32(0.01663), unconst_f32(0.01101), unconst_f32(0.01628), unconst_f32(0.01841), unconst_f32(0.2386), unconst_f32(0.1374), unconst_f32(0.2007)))[unconst_i32(1)].rb))[1]) {
  var vf91: u32 = pack4x8unorm(vec4f(unconst_f32(-0.05674), unconst_f32(0.5812), unconst_f32(0.2723), unconst_f32(0.2126)));
  break;
}
}
  }
  var vf92: vec4f = ldexp(vec4f(unconst_f32(0.01027), unconst_f32(0.02446), unconst_f32(0.4391), unconst_f32(0.1536)), vec4i(unconst_i32(11), unconst_i32(-3), unconst_i32(-198), unconst_i32(256)));
  let vf93: u32 = pack2x16float(vec2f(f32(floor(a0.f0))));
  break;
}
  out.f0[unconst_u32(118)] = asin(vec3h(unconst_f16(-38435.5), unconst_f16(-10748.9), unconst_f16(30137.0))).z;
  out.f0[0] += f16(ldexp(vec4f(unconst_f32(0.02636), unconst_f32(0.06685), unconst_f32(0.00171), unconst_f32(0.3277)), vec4i(unconst_i32(-27), unconst_i32(357), unconst_i32(16), unconst_i32(1)))[0]);
  let vf94: vec3h = refract(vec3h(unconst_f16(22952.5), unconst_f16(517.9), unconst_f16(2872.7)), vec3h(unconst_f16(3630.8), unconst_f16(11494.4), unconst_f16(9432.0)), f16(abs(vec2u(unconst_u32(229), unconst_u32(248)))[0]));
  var vf95: vec3h = asin(vec3h(unconst_f16(1005.8), unconst_f16(3627.0), unconst_f16(9050.6)));
  let ptr106: ptr<function, vec3h> = &vf95;
  var vf96: vec3h = refract(vec3h(unconst_f16(4340.8), unconst_f16(3851.1), unconst_f16(10305.6)), vec3h(unconst_f16(13360.2), unconst_f16(374.6), unconst_f16(23023.5)), unconst_f16(909.5));
  var vf97: f16 = vf94[unconst_u32(91)];
  let vf98: f16 = (*ptr106)[unconst_u32(34)];
  let vf99: vec4h = tan(vec4h(unconst_f16(7482.4), unconst_f16(3940.2), unconst_f16(7879.8), unconst_f16(16235.7)));
  let vf100: f16 = vf96[unconst_u32(108)];
  var vf101: bool = (unconst_i32(247) != unconst_i32(452));
  return out;
}

/* zero global variables used */
fn fn7(a0: FragmentOutput6, a1: T6) {
  let vf119: vec2<bool> = (vec2u(unconst_u32(29), unconst_u32(4)) >= vec2u(unconst_u32(90), unconst_u32(187)));
  vw28[unconst_u32(115)] = T5(T0( -vec4h(unconst_f16(13430.3), unconst_f16(18988.5), unconst_f16(19335.0), unconst_f16(3678.1)).w));
  vw28[unconst_u32(45)] = (*&vw28)[0];
}

/* used global variables: buffer99, tex7 */
fn fn3(a0: array<T5, 1>, a1: T3) {
  if bool((*&buffer99)[unconst_u32(29)][0]) {
  let ptr111: ptr<storage, f16, read> = &buffer99[0][unconst_u32(75)];
  _ = buffer99;
}
  var vf108: vec3<bool> = (vec3f(unconst_f32(-0.2690), unconst_f32(0.1338), unconst_f32(0.4830)) >= vec3f(unconst_f32(-0.1411), unconst_f32(0.3905), unconst_f32(0.2274)));
  let ptr112: ptr<storage, f16, read> = &buffer99[unconst_u32(360)][unconst_u32(21)];
  let vf109: f16 = a0[unconst_u32(324)].f0.f0;
  let vf110: f16 = a0[0].f0.f0;
  for (var it9=textureDimensions(tex7, bitcast<i32>(unpack4x8snorm(unconst_u32(110)).w))[1]; it9<vec3u(vf108)[0]; it9++) {
  let ptr113: ptr<storage, array<f16, 1>, read> = &buffer99[unconst_u32(145)];
  var vf111: f32 = determinant(mat4x4f(unconst_f32(0.3069), unconst_f32(0.1205), unconst_f32(0.08749), unconst_f32(0.1357), unconst_f32(0.1211), unconst_f32(0.3281), unconst_f32(0.2647), unconst_f32(0.2252), unconst_f32(0.08179), unconst_f32(0.03253), unconst_f32(0.1156), unconst_f32(0.01296), unconst_f32(0.06429), unconst_f32(0.3072), unconst_f32(0.3080), unconst_f32(0.03054)));
  let ptr114: ptr<storage, f16, read> = &(*ptr113)[unconst_u32(280)];
  let vf112: f32 = textureLoad(tex7, vec2i(i32((*ptr114))), unconst_i32(58));
  let ptr115: ptr<storage, f16, read> = &buffer99[unconst_u32(72)][unconst_u32(136)];
  break;
  _ = tex7;
  _ = buffer99;
}
  let vf113: vec2h = tan(vec2h((vec3f(unconst_f32(0.4246), unconst_f32(0.2031), unconst_f32(0.07234)) >= vec3f(unconst_f32(0.3750), unconst_f32(0.08733), unconst_f32(0.3224))).zy));
  let ptr116: ptr<storage, f16, read> = &buffer99[unconst_u32(16)][unconst_u32(469)];
  vf108 = vec3<bool>(bool((*&buffer99)[0][0]));
  _ = tex7;
  _ = buffer99;
}

struct S1 {
  @location(10) f0: f16,
  @location(7) @interpolate(linear) f1: f32,
  @builtin(instance_index) f2: u32,
}

var<workgroup> vw27: T6;

struct T7 {
  @size(3264) f0: array<T5>,
}

/* used global variables: buffer99, tex7 */
@vertex @must_use
fn vertex7(@location(3) @interpolate(linear, centroid) a0: vec2h, a1: S1) -> @builtin(position) vec4f {
  var out: vec4f;
  var vf120 = fn6(T6((*&buffer99)[unconst_u32(260)][0]), T0((*&buffer99)[unconst_u32(162)][0]), T3(array<f16, 1>(buffer99[0][0])), T5(T0(f16(pack2x16float(vec2f(unconst_f32(0.03410), unconst_f32(-0.1553)))))));
  let vf121: vec2h = a0;
  {
  fn4();
  out = vec4f(f32((*&buffer99)[0][firstTrailingBit(vec3u(unconst_u32(273), unconst_u32(48), unconst_u32(257))).x]));
  let ptr117: ptr<storage, f16, read> = &(*&buffer99)[0][unconst_u32(27)];
  _ = buffer99;
}
  let ptr118: ptr<storage, f16, read> = &(*&buffer99)[0][unconst_u32(114)];
  out -= trunc(vec4f(unconst_f32(0.1577), unconst_f32(-0.3359), unconst_f32(0.6879), unconst_f32(0.04110)));
  fn3(array<T5, 1>(T5(T0(buffer99[unconst_u32(45)][0]))), T3(array<f16, 1>(buffer99[unconst_u32(186)][unconst_u32(253)])));
  out += vec4f((vec2<bool>(bool(buffer99[0][0])) | vec2<bool>(sqrt(vec2h(unconst_f16(900.5), unconst_f16(4214.2))))).xyxy);
  vf120.f0 |= vec4u(u32(textureLoad(tex7, vec2i(unconst_i32(215), unconst_i32(267)), bitcast<i32>(radians(vec2h(unconst_f16(33764.9), unconst_f16(9691.2)))))));
  vf120.f0 += unpack4xU8(u32((*&buffer99)[0][unconst_u32(55)]));
  out = vec4f(a1.f1);
  let ptr119: ptr<function, u32> = &vf120.f1;
  fn3(array<T5, 1>(T5(T0(vec4h(exp(vec4f(unconst_f32(0.06940), unconst_f32(-0.08563), unconst_f32(0.1084), unconst_f32(0.3627))))[1]))), T3(array<f16, 1>((*&buffer99)[unconst_u32(56)][unconst_u32(52)])));
  var vf122: vec2h = vf121;
  return out;
  _ = tex7;
  _ = buffer99;
}

/* zero global variables used */
@fragment
fn fragment6() -> @location(200) vec4f {
  var out: vec4f;
  _ = fn4();
  let vf123: vec4<bool> = (vec4h(unconst_f16(711.0), unconst_f16(3442.5), unconst_f16(12414.6), unconst_f16(11878.8)) == vec4h(unconst_f16(20505.7), unconst_f16(14096.3), unconst_f16(5699.8), unconst_f16(4691.9)));
  var vf124 = fn4();
  var vf125 = fn0(T6(vec4h(unpack4x8snorm(unconst_u32(1))).b));
  return out;
}

/* zero global variables used */
@fragment
fn fragment7() -> FragmentOutput6 {
  var out: FragmentOutput6;
  var vf126: u32 = pack2x16float(vec2f(unconst_f32(0.07928), unconst_f32(0.5949)));
  out = FragmentOutput6(vec4f(ldexp(vec2h(unconst_f16(3177.8), unconst_f16(9563.8)), vec2i(unconst_i32(61), unconst_i32(-110))).yyyy), bitcast<u32>(ldexp(vec2h(unconst_f16(3177.8), unconst_f16(9563.8)), vec2i(unconst_i32(61), unconst_i32(-110)))));
  vf126 = u32(determinant(mat2x2h(unconst_f16(14586.1), unconst_f16(306.0), unconst_f16(2237.3), unconst_f16(720.5))));
  let ptr120: ptr<function, u32> = &vf126;
  var vf127: u32 = pack4x8snorm(vec4f(unconst_f32(0.00695), unconst_f32(0.07667), unconst_f32(0.04411), unconst_f32(0.2119)));
  var vf128 = fn5(T3(array<f16, 1>(f16(pack2x16float(vec2f(unconst_f32(0.2654), unconst_f32(0.1700)))))));
  vf127 <<= u32(sqrt(sign(vec2h(unconst_f16(279.8), unconst_f16(35273.8))).rgg).g);
  out.f1 |= vf126;
  vf127 *= pack4x8snorm(vec4f(unconst_f32(0.3977), unconst_f32(0.00714), unconst_f32(0.1317), unconst_f32(0.1457)));
  let vf129: vec2f = unpack2x16snorm(unconst_u32(82));
  {
  var vf130 = fn0(T6(f16(pack2x16snorm(vec2f(unconst_f32(0.4214), unconst_f32(0.05036))))));
  out.f0 = unpack4x8unorm(pack4xI8(vec4i(unconst_i32(139), unconst_i32(360), unconst_i32(-27), unconst_i32(10))));
  out.f1 = pack4x8snorm(vec4f(unconst_f32(0.1647), unconst_f32(0.01383), unconst_f32(0.04612), unconst_f32(0.05877)));
  vf130.f0[unconst_u32(115)] = length(vec4h(unconst_f16(33374.1), unconst_f16(25504.9), unconst_f16(-2474.4), unconst_f16(564.9)));
  let ptr121: ptr<function, array<f16, 1>> = &vf130.f0;
  fn4();
}
  let vf131: u32 = dot4U8Packed(vf126, unconst_u32(128));
  return out;
}

/* zero global variables used */
@fragment
fn fragment8() -> @location(200) vec4f {
  var out: vec4f;
  var vf132: u32 = pack4xU8Clamp(vec4u(unconst_u32(29), unconst_u32(8), unconst_u32(114), unconst_u32(377)));
  vf132 = u32(cosh(vec3h(unconst_f16(2326.4), unconst_f16(7011.3), unconst_f16(16125.4))).x);
  vf132 *= max(unconst_u32(128), unconst_u32(603));
  var vf133: bool = any(unconst_bool(false));
  _ = fn5(T3(array<f16, 1>(vec2h( -(unconst_f32(0.09999) * vec2f(unconst_f32(0.02269), unconst_f32(0.2862))))[1])));
  let vf134: vec2i = (vec2i(unconst_i32(150), unconst_i32(90)) * vec2i(unconst_i32(-301), unconst_i32(297)));
  switch abs(vec3i(unconst_i32(-249), unconst_i32(27), unconst_i32(35))).b { 
  default {
  _ = fn6(T6(f16(all( !vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(false))))), T0(vec4h(extractBits(vec4i(unconst_i32(27), unconst_i32(74), unconst_i32(-115), unconst_i32(323)), unconst_u32(491), vec3u(faceForward(vec3h(unconst_f16(1307.1), unconst_f16(-16352.4), unconst_f16(1504.6)), vec3h(f16((unconst_u32(442) / unconst_u32(881)))), vec3h(unconst_f16(1973.9), unconst_f16(394.5), unconst_f16(-130.9))))[0]))[0]), T3(array<f16, 1>(f16(asinh(vec4f(unconst_f32(0.3656), unconst_f32(0.1510), unconst_f32(0.09805), unconst_f32(0.1514))).w))), T5(T0(f16( ~vec2i(i32(max(unconst_f16(12085.0), unconst_f16(22920.7))))[0]))));
  out *= vec4f(f32(acosh(unconst_f16(13395.1))));
  out = vec4f(f32(length(unconst_f16(-31144.3))));
  let vf135: vec2h = exp(vec2h(unconst_f16(10463.6), unconst_f16(25401.7)));
  let vf136: f16 = vf135[unconst_u32(88)];
  out = vec4f((vec2u(unconst_u32(7), unconst_u32(84)) > vec2u(unconst_u32(312), unconst_u32(29))).xxyx);
  return out;
}
  }
  fn4();
  vf132 <<= bitcast<vec3u>(cross(vec3f( -vec2i(unconst_i32(39), unconst_i32(297)).rrr), vec3f(unconst_f32(0.1198), unconst_f32(0.03219), unconst_f32(0.1653))))[2];
  var vf137 = fn5(T3(array<f16, 1>(ldexp(vec2h(unconst_f16(-1298.8), unconst_f16(7546.1)), vec2i(unconst_i32(230), unconst_i32(311))).r)));
  var vf138: vec2h = ldexp(vec2h(unconst_f16(-4470.7), unconst_f16(33741.9)), vec2i(bitcast<i32>(vf132)));
  let ptr122: ptr<function, f16> = &vf137.f0[unconst_u32(12)];
  return out;
}

/* zero global variables used */
@fragment
fn fragment9(@invariant @builtin(position) a0: vec4f) -> FragmentOutput7 {
  var out: FragmentOutput7;
  var vf139 = fn5(T3(array<f16, 1>(f16(all(unconst_bool(true))))));
  var vf140: vec2f = atan(vec2f(unconst_f32(0.03389), unconst_f32(-0.1955)));
  discard;
  out.f0 ^= vec4u(unpack2x16snorm(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true), unconst_bool(false)) == vec4<bool>(extractBits(vec4i(unconst_i32(125), unconst_i32(279), unconst_i32(324), unconst_i32(563)), u32(any(unconst_bool(true))), unconst_u32(810)))))[1]).yyxx);
  vf140 *= vec2f(f32(all(vec3<bool>(inverseSqrt(vec3f(unconst_f32(0.6943), unconst_f32(0.00867), unconst_f32(0.03238)))))));
  vf139 = T3(array<f16, 1>(vec3h( ~vec3i(unconst_i32(423), unconst_i32(128), unconst_i32(18)))[0]));
  out = FragmentOutput7(vec4u(refract(vec3h(unconst_f16(30464.6), unconst_f16(987.0), unconst_f16(4533.5)), vec3h(f16(all(vec3<bool>(bool(vf140[unconst_u32(87)]))))), unconst_f16(-7122.4)).xyyx), vec3u(refract(vec3h(unconst_f16(30464.6), unconst_f16(987.0), unconst_f16(4533.5)), vec3h(f16(all(vec3<bool>(bool(vf140[unconst_u32(87)]))))), unconst_f16(-7122.4)))[1]);
  return out;
}

/* used global variables: tex7 */
@compute @workgroup_size(2, 1, 1)
fn compute8() {
  for (var it11=u32(vw27.f0); it11<u32(dot(vec4f(unconst_f32(0.2180), unconst_f32(0.02557), unconst_f32(0.2417), unconst_f32(0.01973)), vec4f(unconst_f32(0.3259), unconst_f32(0.1072), unconst_f32(0.2499), unconst_f32(0.1701)))); it11++) {
  textureBarrier();
  vw28[unconst_u32(96)] = T5(T0(vec2h(textureDimensions(tex7)).y));
  let ptr123: ptr<workgroup, f16> = &(*&vw30)[0].f0;
  var vf141: bool = (unconst_bool(true) || unconst_bool(false));
  vf141 = bool(vw27.f0);
  vf141 = bool((*&vw29).f1);
  _ = tex7;
}
  var vf142 = fn1(S1(f16(workgroupUniformLoad(&vw29).f0[3]), bitcast<vec4f>(workgroupUniformLoad(&vw29).f0)[2], pack4xU8Clamp(workgroupUniformLoad(&vw29).f0)));
  _ = fn5(T3(array<f16, 1>(vf142.f0.f0)));
  vw27.f0 = f16(transpose(mat2x2f(unconst_f32(0.01628), unconst_f32(0.3985), unconst_f32(0.00027), unconst_f32(0.1005)))[unconst_i32(0)][1]);
  var vf143 = fn4();
  for (var it12=pack4xU8(unpack4xU8(unconst_u32(71))); it12<u32((*&vw30)[0].f0); it12++) {
  let ptr124: ptr<workgroup, u32> = &(*&vw29).f1;
  vw30[unconst_u32(33)] = T0((*&vw30)[unconst_u32(293)].f0);
  workgroupBarrier();
  break;
}
  var vf144: vec4h = mix(vec4h(f16((unconst_bool(true) || bool(reverseBits(vec4i(unconst_i32(233), unconst_i32(66), unconst_i32(65), unconst_i32(160)))[0])))), bitcast<vec4h>(textureDimensions(tex7, unconst_i32(-121))), unconst_f16(1925.4));
  _ = fn5(T3(array<f16, 1>((*&vw30)[0].f0)));
  var vf145: u32 = dot4U8Packed(unconst_u32(276), unconst_u32(116));
  fn7(FragmentOutput6(vec4f(f32((*&vw28)[0].f0.f0)), u32((*&vw28)[0].f0.f0)), (*&vw27));
  var vf146: array<T0, 1> = workgroupUniformLoad(&vw30);
  _ = tex7;
}`,
});
let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 16,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 5, hasDynamicOffset: false },
    },
  ],
});
let commandEncoder138 = device0.createCommandEncoder({});
let texture118 = gpuCanvasContext5.getCurrentTexture();
try {
renderPassEncoder13.end();
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle3, renderBundle7]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 6, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(5_206).fill(189), /* required buffer size: 5_206 */
{offset: 400, bytesPerRow: 178, rowsPerImage: 27}, {width: 48, height: 0, depthOrArrayLayers: 2});
} catch {}
document.body.append(img1);
let buffer100 = device0.createBuffer({size: 11096, usage: GPUBufferUsage.MAP_READ});
let texture119 = device0.createTexture({
  size: {width: 360, height: 1, depthOrArrayLayers: 50},
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder48.setBindGroup(1, bindGroup49, new Uint32Array(73), 7, 0);
} catch {}
try {
computePassEncoder118.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline20);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 14, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(4_833).fill(26), /* required buffer size: 4_833 */
{offset: 127, bytesPerRow: 81, rowsPerImage: 29}, {width: 2, height: 1, depthOrArrayLayers: 3});
} catch {}
let texture120 = device0.createTexture({
  size: [22],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView155 = texture109.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 6});
let computePassEncoder120 = commandEncoder61.beginComputePass({});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
let renderBundle23 = renderBundleEncoder23.finish({});
try {
computePassEncoder74.setBindGroup(0, bindGroup17, new Uint32Array(82), 37, 0);
} catch {}
try {
computePassEncoder116.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup30);
} catch {}
try {
renderPassEncoder26.executeBundles([renderBundle11, renderBundle13, renderBundle11]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer93, 'uint32', 128, 1_990);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline14);
} catch {}
try {
commandEncoder138.copyBufferToBuffer(buffer27, 360, buffer86, 21752, 248);
} catch {}
try {
commandEncoder138.copyTextureToBuffer({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4640 */
  offset: 4640,
  rowsPerImage: 156,
  buffer: buffer67,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline24 = device0.createComputePipeline({layout: pipelineLayout6, compute: {module: shaderModule4, entryPoint: 'compute4', constants: {}}});
try {
  await promise25;
} catch {}
let commandEncoder139 = device0.createCommandEncoder({});
let texture121 = device0.createTexture({
  size: [129],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroups(2, 1, 1); };
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer56, 'uint16', 4_234, 825);
} catch {}
try {
commandEncoder138.copyBufferToBuffer(buffer91, 548, buffer10, 1532, 2356);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer38, 0, new DataView(new ArrayBuffer(10425)), 358, 724);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 11, height: 5, depthOrArrayLayers: 55}
*/
{
  source: img1,
  origin: { x: 0, y: 5 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas2);
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'bt470bg', transfer: 'bt2020_12bit'} });
let commandEncoder140 = device0.createCommandEncoder({});
let texture122 = device0.createTexture({
  size: [45, 1, 25],
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderPassEncoder34 = commandEncoder140.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 88,
  clearValue: { r: 321.1, g: 649.2, b: -935.6, a: -489.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet2,
});
try {
computePassEncoder43.setBindGroup(0, bindGroup68, new Uint32Array(1668), 544, 0);
} catch {}
try {
computePassEncoder120.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup67);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer9, 'uint32', 412, 239);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(3, buffer79, 0);
} catch {}
try {
sampler60.label = '\ubf2c\ub90e\u8e7f\ue4a8';
} catch {}
let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {binding: 5, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {binding: 152, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 264,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
  ],
});
let bindGroup83 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout7,
  entries: [
    {binding: 254, resource: {buffer: buffer75, offset: 5888}},
    {binding: 578, resource: {buffer: buffer19, offset: 0, size: 3808}},
    {binding: 62, resource: textureView9},
  ],
});
let buffer101 = device0.createBuffer({size: 7667, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder141 = device0.createCommandEncoder({});
let texture123 = device0.createTexture({size: {width: 256}, dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder21.setBindGroup(3, bindGroup36, new Uint32Array(75), 23, 0);
} catch {}
try {
renderPassEncoder33.setScissorRect(6, 0, 5, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder141.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3096 */
  offset: 3096,
  buffer: buffer47,
}, {
  texture: texture117,
  mipLevel: 0,
  origin: {x: 9, y: 2, z: 0},
  aspect: 'all',
}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder142 = device0.createCommandEncoder({});
let querySet13 = device0.createQuerySet({type: 'timestamp', count: 889});
let textureView156 = texture25.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder119.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup38);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup73, new Uint32Array(3241), 225, 0);
} catch {}
try {
renderPassEncoder10.setBlendConstant({ r: 413.4, g: 17.07, b: 344.6, a: -171.0, });
} catch {}
let textureView157 = texture26.createView({
  label: '\u06e9\u0386\u{1fa29}\uaae6\u35b6\uf9ae\u30b2\ud8af\u{1fd38}\u0091\u2033',
  dimension: '2d-array',
  mipLevelCount: 1,
  arrayLayerCount: 1,
});
try {
computePassEncoder10.setBindGroup(2, bindGroup35);
} catch {}
try {
computePassEncoder74.dispatchWorkgroups(1);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroupsIndirect(buffer27, 2_108); };
} catch {}
try {
renderPassEncoder33.setPipeline(pipeline17);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: imageData6,
  origin: { x: 1, y: 16 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 20, y: 25, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 4, depthOrArrayLayers: 0});
} catch {}
let commandEncoder143 = device0.createCommandEncoder({});
let computePassEncoder121 = commandEncoder143.beginComputePass({});
let renderPassEncoder35 = commandEncoder142.beginRenderPass({
  colorAttachments: [{
  view: textureView70,
  depthSlice: 27,
  clearValue: { r: -78.63, g: 329.1, b: 593.8, a: 763.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder4.setBindGroup(1, bindGroup43, new Uint32Array(205), 30, 0);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder31.setPipeline(pipeline20);
} catch {}
let arrayBuffer6 = buffer37.getMappedRange(920, 0);
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(137_835).fill(155), /* required buffer size: 137_835 */
{offset: 173, bytesPerRow: 134, rowsPerImage: 194}, {width: 22, height: 58, depthOrArrayLayers: 6});
} catch {}
try {
  await promise26;
} catch {}
let bindGroup84 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout4,
  entries: [
    {binding: 62, resource: textureView7},
    {binding: 254, resource: {buffer: buffer7, offset: 256, size: 948}},
    {binding: 578, resource: {buffer: buffer19, offset: 0, size: 3840}},
  ],
});
let textureView158 = texture73.createView({dimension: '2d', baseArrayLayer: 1});
let textureView159 = texture3.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1});
let renderPassEncoder36 = commandEncoder141.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 178,
  clearValue: { r: 661.2, g: -352.1, b: -684.2, a: -834.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet13, endOfPassWriteIndex: 485},
  maxDrawCount: 234049585,
});
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rg32float']});
try {
{ clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroupsIndirect(buffer93, 2_096); };
} catch {}
try {
computePassEncoder121.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup55);
} catch {}
try {
commandEncoder138.copyBufferToTexture({
  /* bytesInLastRow: 664 widthInBlocks: 83 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 72 */
  offset: 72,
  bytesPerRow: 9216,
  buffer: buffer101,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 33, y: 3, z: 0},
  aspect: 'all',
}, {width: 83, height: 8, depthOrArrayLayers: 0});
} catch {}
let imageData19 = new ImageData(48, 80);
let bindGroup85 = device0.createBindGroup({layout: veryExplicitBindGroupLayout17, entries: [{binding: 328, resource: textureView154}]});
let commandEncoder144 = device0.createCommandEncoder();
let texture124 = device0.createTexture({
  size: [129, 7, 11],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture125 = device0.createTexture({
  size: {width: 180, height: 80, depthOrArrayLayers: 91},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder122 = commandEncoder138.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 543}});
try {
computePassEncoder99.setBindGroup(0, bindGroup57, new Uint32Array(188), 5, 0);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle18]);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(5, buffer92, 0, 186);
} catch {}
try {
renderBundleEncoder24.setBindGroup(2, bindGroup17);
} catch {}
try {
  await buffer57.mapAsync(GPUMapMode.READ, 0, 712);
} catch {}
try {
computePassEncoder54.pushDebugGroup('\u33ce');
} catch {}
try {
device0.queue.writeBuffer(buffer75, 1080, new BigUint64Array(12981), 1043, 68);
} catch {}
let commandEncoder145 = device0.createCommandEncoder({});
let textureView160 = texture60.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 4});
let computePassEncoder123 = commandEncoder145.beginComputePass({});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder123.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup2);
} catch {}
try {
renderBundleEncoder24.setBindGroup(3, bindGroup61, new Uint32Array(547), 33, 0);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(2, buffer97, 0);
} catch {}
try {
computePassEncoder54.popDebugGroup();
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
});
} catch {}
let autogeneratedBindGroupLayout7 = pipeline0.getBindGroupLayout(0);
let commandEncoder146 = device0.createCommandEncoder();
let texture126 = device0.createTexture({
  size: {width: 180, height: 1, depthOrArrayLayers: 50},
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView161 = texture70.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder124 = commandEncoder146.beginComputePass();
try {
computePassEncoder124.setPipeline(pipeline23);
} catch {}
try {
renderBundleEncoder24.setBindGroup(1, bindGroup66, new Uint32Array(5), 4, 0);
} catch {}
try {
  await promise24;
} catch {}
document.body.prepend(canvas4);
let commandEncoder147 = device0.createCommandEncoder({});
let texture127 = device0.createTexture({
  label: '\u3dd8\u0f4a\uf555\u0220\uc3d6\u028a\uff06\u806a\uc884\u567c',
  size: [180, 1, 26],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture128 = device0.createTexture({
  size: [180],
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder35.setBindGroup(3, bindGroup18);
} catch {}
try {
computePassEncoder122.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer81, 'uint16', 474, 54);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(2, buffer45);
} catch {}
try {
commandEncoder147.copyBufferToBuffer(buffer93, 1396, buffer4, 752, 252);
} catch {}
try {
commandEncoder144.copyBufferToTexture({
  /* bytesInLastRow: 152 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 136 */
  offset: 136,
  rowsPerImage: 688,
  buffer: buffer71,
}, {
  texture: texture90,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt709', transfer: 'linear'} });
let textureView162 = texture127.createView({});
let computePassEncoder125 = commandEncoder147.beginComputePass({timestampWrites: {querySet: querySet10, endOfPassWriteIndex: 78}});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({
  label: '\u0ffd\u0872\u{1fac4}\ue521\u60e3\u{1fd40}\u2e5a\u20ff\u462d\u5395',
  colorFormats: ['rg32float'],
  depthReadOnly: false,
});
let renderBundle24 = renderBundleEncoder25.finish({});
try {
computePassEncoder125.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer56, 'uint32', 664, 3_330);
} catch {}
try {
commandEncoder144.copyBufferToTexture({
  /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 860 */
  offset: 860,
  bytesPerRow: 1536,
  buffer: buffer3,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 25, y: 9, z: 0},
  aspect: 'all',
}, {width: 13, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 1, depthOrArrayLayers: 50}
*/
{
  source: imageData18,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 23},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline25 = await promise18;
document.body.append(img0);
let textureView163 = texture126.createView({});
let renderPassEncoder37 = commandEncoder144.beginRenderPass({
  colorAttachments: [{view: textureView72, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet12,
  timestampWrites: {querySet: querySet9, beginningOfPassWriteIndex: 474, endOfPassWriteIndex: 479},
});
let renderBundle25 = renderBundleEncoder24.finish({label: '\u{1f8fa}\u{1fa43}\u07ab\u{1faf4}\ud5ff\u0e4a\u{1fe5b}\u6bfa'});
let sampler80 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 7,
});
try {
{ clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroupsIndirect(buffer79, 204); };
} catch {}
try {
renderPassEncoder34.setBindGroup(1, bindGroup10, new Uint32Array(4574), 556, 0);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer19, 'uint32', 1_868, 3_901);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(0, buffer40);
} catch {}
try {
device0.queue.writeBuffer(buffer96, 296, new DataView(new ArrayBuffer(13182)), 69, 308);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 20, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 27, y: 12 },
  flipY: false,
}, {
  texture: texture115,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas4);
try {
computePassEncoder77.setBindGroup(0, bindGroup9);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 1, depthOrArrayLayers: 50}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 69, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline26 = device0.createComputePipeline({layout: pipelineLayout14, compute: {module: shaderModule1}});
let pipelineLayout21 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout3]});
let texture129 = device0.createTexture({
  size: [180, 80, 1],
  dimension: '2d',
  format: 'astc-6x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView164 = texture56.createView({aspect: 'all', mipLevelCount: 1});
let renderPassEncoder38 = commandEncoder139.beginRenderPass({
  colorAttachments: [{
  view: textureView157,
  clearValue: { r: 205.8, g: 123.8, b: -957.4, a: 353.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let renderBundle26 = renderBundleEncoder26.finish();
try {
renderPassEncoder6.setIndexBuffer(buffer61, 'uint32', 4_724, 805);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(5, buffer0, 3_940, 5_289);
} catch {}
try {
adapter1.label = '\u0075\u{1fd21}\u5aac';
} catch {}
let bindGroup86 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [
    {binding: 254, resource: {buffer: buffer92, offset: 1024, size: 52}},
    {binding: 62, resource: textureView9},
    {binding: 578, resource: {buffer: buffer63, offset: 256, size: 3292}},
  ],
});
let sampler81 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  lodMaxClamp: 52.00,
  compare: 'greater-equal',
});
try {
renderPassEncoder18.setBindGroup(1, bindGroup44, new Uint32Array(3362), 75, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let bindGroup87 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout10,
  entries: [
    {binding: 62, resource: textureView18},
    {binding: 254, resource: {buffer: buffer54, offset: 0, size: 200}},
    {binding: 578, resource: {buffer: buffer25, offset: 1024, size: 3432}},
  ],
});
let texture130 = device0.createTexture({
  size: [90],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder81.setBindGroup(3, bindGroup51);
} catch {}
try {
computePassEncoder33.setBindGroup(1, bindGroup49, new Uint32Array(2938), 138, 0);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(2, buffer66, 0, 3_973);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let commandEncoder148 = device0.createCommandEncoder();
let computePassEncoder126 = commandEncoder148.beginComputePass({});
let sampler82 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.58,
  compare: 'less',
  maxAnisotropy: 20,
});
try {
computePassEncoder48.setBindGroup(2, bindGroup72, new Uint32Array(1215), 992, 0);
} catch {}
try {
renderPassEncoder33.setBindGroup(3, bindGroup40, new Uint32Array(6049), 178, 0);
} catch {}
try {
renderPassEncoder36.executeBundles([renderBundle11, renderBundle18, renderBundle11]);
} catch {}
let promise28 = device0.queue.onSubmittedWorkDone();
let bindGroup88 = device0.createBindGroup({
  label: '\u4768\u8623\u02e5\ua821\u4600\u8959\u{1fd3f}\ubf8b',
  layout: veryExplicitBindGroupLayout2,
  entries: [{binding: 8, resource: externalTexture10}],
});
let commandEncoder149 = device0.createCommandEncoder({});
let texture131 = device0.createTexture({
  size: {width: 180, height: 80, depthOrArrayLayers: 91},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder127 = commandEncoder149.beginComputePass({});
try {
computePassEncoder74.end();
} catch {}
try {
computePassEncoder127.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder29.insertDebugMarker('\u6a73');
} catch {}
let querySet14 = device0.createQuerySet({type: 'timestamp', count: 1085});
let computePassEncoder128 = commandEncoder89.beginComputePass({});
let sampler83 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMinClamp: 3.595});
try {
{ clearResourceUsages(device0, computePassEncoder77); computePassEncoder77.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(13);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer88, 'uint16', 2_652, 2_989);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(3, buffer43);
} catch {}
let buffer102 = device0.createBuffer({
  label: '\u575d\u05cb\u0eb5',
  size: 7697,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView165 = texture126.createView({aspect: 'all', format: 'r32float', mipLevelCount: 1});
try {
computePassEncoder99.setBindGroup(3, bindGroup44);
} catch {}
try {
computePassEncoder91.setBindGroup(0, bindGroup59, new Uint32Array(7406), 4_158, 0);
} catch {}
try {
computePassEncoder128.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup9, new Uint32Array(365), 24, 0);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer54, 224);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer52, 8);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer29, 'uint32', 2_124, 229);
} catch {}
try {
buffer86.unmap();
} catch {}
let pipeline27 = device0.createComputePipeline({layout: pipelineLayout19, compute: {module: shaderModule7}});
let buffer103 = device0.createBuffer({size: 34, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let texture132 = device0.createTexture({
  size: {width: 129, height: 7, depthOrArrayLayers: 73},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let texture133 = gpuCanvasContext3.getCurrentTexture();
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer55, 1_440); };
} catch {}
try {
renderPassEncoder10.draw(0, 34, 0, 44_601_094);
} catch {}
try {
renderPassEncoder10.drawIndexed(34, 132, 3, 16_934_602, 76_533_836);
} catch {}
try {
renderPassEncoder37.setPipeline(pipeline7);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(121).fill(126), /* required buffer size: 121 */
{offset: 121, bytesPerRow: 251}, {width: 26, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline28 = await promise14;
await gc();
let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 7,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32uint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 37, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 282, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let buffer104 = device0.createBuffer({size: 1792, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let textureView166 = texture20.createView({arrayLayerCount: 1});
try {
computePassEncoder126.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder10.draw(0, 83, 0, 897_465_251);
} catch {}
try {
renderPassEncoder10.drawIndexed(30, 70, 1, 165_403_647, 1_590_936_534);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer39, 8);
} catch {}
let shaderModule8 = device0.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

requires pointer_composite_access;

requires readonly_and_readwrite_storage_textures;

var<workgroup> vw42: mat4x3f;

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

@id(57193) override override9: u32 = 339;

/* zero global variables used */
@must_use 
fn fn4(a0: array<u32, 1>) -> VertexOutput6 {
  var out: VertexOutput6;
  out.f20 += unpack4x8unorm(a0[0]);
  _ = fn2(mat4x2h(vec2h(transpose(mat3x4f())[unconst_i32(2)].yy), vec2h(transpose(mat3x4f())[unconst_i32(2)].zz), vec2h(transpose(mat3x4f())[unconst_i32(0)].xz), vec2h(transpose(mat3x4f())[unconst_i32(2)].bb)));
  return out;
  _ = override9;
}

var<workgroup> vw35: vec4i;

/* zero global variables used */
@must_use 
fn fn2(a0: mat4x2h) -> VertexOutput6 {
  var out: VertexOutput6;
  switch bitcast<i32>(floor(vec3f(unconst_f32(0.07511), unconst_f32(0.01208), unconst_f32(0.1678))).b) { 
  default {
  let vf168: u32 = override9;
  out.f19 = unpack4xU8(dot4U8Packed(unconst_u32(173), unconst_u32(64)));
  let vf169: vec3h = normalize(vec3h(f16(vp5.f19[unconst_u32(185)])));
  _ = override9;
}
  }
  let ptr131: ptr<private, vec4u> = &vp5.f19;
  return out;
  _ = override9;
}

var<workgroup> vw40: mat4x2h;

var<workgroup> vw33: vec4f;

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

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

var<private> vp5: VertexOutput6 = VertexOutput6();

@group(0) @binding(264) var<storage, read_write> buffer106: array<array<array<f16, 1>, 6>, 144>;

/* zero global variables used */
fn fn0() -> VertexOutput6 {
  var out: VertexOutput6;
  var vf147: vec3<bool> = (vec3h(unconst_f16(8283.6), unconst_f16(19695.4), unconst_f16(-1935.3)) <= vec3h(countLeadingZeros(vec4u(unconst_u32(182), unconst_u32(0), unconst_u32(11), unconst_u32(22))).xyy));
  let vf148: mat2x3h = transpose(mat3x2h(unconst_f16(1848.5), unconst_f16(10668.2), unconst_f16(2197.3), unconst_f16(-4272.8), unconst_f16(4282.6), unconst_f16(3594.9)));
  var vf149: vec4u = countLeadingZeros(vec4u(unconst_u32(352), unconst_u32(55), unconst_u32(50), unconst_u32(2)));
  let vf150: u32 = pack4x8snorm(vec4f(unconst_f32(0.1095), unconst_f32(0.06567), unconst_f32(0.03142), unconst_f32(0.2086)));
  out.f20 -= bitcast<vec4f>( ~vec4u(unconst_u32(44), unconst_u32(128), unconst_u32(139), unconst_u32(201)));
  {
  let vf151: f16 = inverseSqrt(unconst_f16(233.3));
  let vf152: f32 = vp4.f0[unconst_u32(229)];
  var vf153: u32 = (bitcast<u32>(tan(vec3f(unconst_f32(0.3291), unconst_f32(0.04020), unconst_f32(0.04869)))[1]) ^ pack4xU8Clamp(firstLeadingBit(vec4u(unconst_u32(145), unconst_u32(180), unconst_u32(459), unconst_u32(225)))));
  var vf154: bool = (unconst_bool(false) && unconst_bool(false));
  var vf155: vec3h = floor(vec3h(unconst_f16(19105.2), unconst_f16(8753.6), unconst_f16(4375.5)));
  vf153 = u32((unconst_bool(true) && unconst_bool(true)));
}
  switch bitcast<i32>(vf150) { 
  default {
  switch bitcast<i32>(vp5.f20[3]) { 
  default {
  let vf156: u32 = pack4x8unorm(vec4f(unconst_f32(0.06431), unconst_f32(0.03866), unconst_f32(0.3251), unconst_f32(0.1101)));
  var vf157: f32 = ceil(unconst_f32(0.2840));
}
  }
  vp5.f19 = bitcast<vec4u>(unpack2x16unorm(bitcast<u32>(round(vec2h(unconst_f16(9610.6), unconst_f16(60000.0))))).xxyx);
  vp5 = VertexOutput6(firstLeadingBit(vp5.f19), vec4f(firstLeadingBit(vp5.f19)));
  let vf158: vec4u = firstLeadingBit(vec4u(unconst_u32(0), unconst_u32(91), unconst_u32(223), unconst_u32(21)));
  let vf159: vec2f = degrees(vec2f(unconst_f32(0.04293), unconst_f32(0.5262)));
  let ptr125: ptr<private, vec4u> = &vp5.f19;
  let vf160: vec2f = vf159;
  break;
}
  }
  let ptr126: ptr<private, vec4f> = &vp4.f0;
  let ptr127: ptr<private, vec4u> = &vp5.f19;
  var vf161: u32 = (*ptr127)[unconst_u32(50)];
  {
  let vf162: vec3h = faceForward(vec3h(unconst_f16(-13000.7), unconst_f16(-11703.8), unconst_f16(7546.7)), vec3h(unconst_f16(9456.7), unconst_f16(10430.5), unconst_f16(-10676.9)), vec3h(unconst_f16(-4964.1), unconst_f16(2254.9), unconst_f16(1532.9)));
  var vf163: f16 = abs(unconst_f16(3633.9));
  let ptr128: ptr<private, vec4f> = &vp5.f20;
}
  let ptr129: ptr<private, vec4u> = &(*ptr127);
  let vf164: f32 = vp5.f20[pack4x8snorm(vec4f((vec4i(unconst_i32(174), unconst_i32(158), unconst_i32(759), unconst_i32(50)) <= unpack4xI8(unconst_u32(93)))))];
  var vf165: vec4u =  ~vec4u(unconst_u32(63), unconst_u32(122), unconst_u32(294), unconst_u32(180));
  return out;
}

/* zero global variables used */
fn fn1(a0: VertexOutput6) -> VertexOutput6 {
  var out: VertexOutput6;
  vp5.f20 = vec4f(a0.f19);
  var vf166: vec4f = a0.f20;
  let ptr130: ptr<function, vec4f> = &vf166;
  vf166 *= vec4f(f32(vp5.f19[unconst_u32(298)]));
  var vf167 = fn0();
  _ = fn0();
  return out;
}

var<workgroup> vw39: array<vec2h, 1>;

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

/* zero global variables used */
fn fn5(a0: ptr<function, vec2i>) {
  _ = fn0();
  _ = fn2(mat4x2h(vec2h(unpack4xU8(unconst_u32(11)).ww), vec2h(unpack4xU8(unconst_u32(11)).ga), vec2h(unpack4xU8(unconst_u32(11)).zz), vec2h(unpack4xU8(unconst_u32(11)).ra)));
  var vf174 = fn0();
  vp5 = VertexOutput6(vec4u( ~vec3i(unconst_i32(232), unconst_i32(641), unconst_i32(40)).brgb), vec4f( ~vec3i(unconst_i32(232), unconst_i32(641), unconst_i32(40)).rgrg));
  let ptr133: ptr<private, vec4f> = &vp5.f20;
  _ = override9;
}

var<workgroup> vw41: FragmentOutput8;

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

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

/* used global variables: buffer106 */
fn fn3(a0: VertexOutput6, a1: array<VertexOutput6, 1>, a2: ptr<uniform, array<array<FragmentOutput8, 1>, 3>>) -> VertexOutput6 {
  var out: VertexOutput6;
  var vf170: u32 = vw34.f19[unconst_u32(486)];
  var vf171 = fn2(mat4x2h((*&buffer106)[143][5][0], (*&buffer106)[143][5][0], (*&buffer106)[143][5][0], (*&buffer106)[143][5][0], (*&buffer106)[143][5][0], (*&buffer106)[143][5][0], (*&buffer106)[143][5][0], (*&buffer106)[143][5][0]));
  vw42 = mat4x3f(vec3f((*&vw34).f19.ywx), vec3f((*&vw34).f19.raa), bitcast<vec3f>((*&vw34).f19.www), vec3f((*&vw34).f19.agr));
  _ = fn2(mat4x2h(f16(a0.f20[unconst_u32(370)]), f16(a0.f20[unconst_u32(370)]), f16(a0.f20[unconst_u32(370)]), f16(a0.f20[unconst_u32(370)]), f16(a0.f20[unconst_u32(370)]), f16(a0.f20[unconst_u32(370)]), f16(a0.f20[unconst_u32(370)]), f16(a0.f20[unconst_u32(370)])));
  var vf172 = fn2(mat4x2h(f16((*&vw33)[unconst_u32(0)]), f16((*&vw33)[unconst_u32(0)]), f16((*&vw33)[unconst_u32(0)]), f16((*&vw33)[unconst_u32(0)]), f16((*&vw33)[unconst_u32(0)]), f16((*&vw33)[unconst_u32(0)]), f16((*&vw33)[unconst_u32(0)]), f16((*&vw33)[unconst_u32(0)])));
  loop {
  if bool(ldexp(vec2h(unconst_f16(2619.6), unconst_f16(20285.4)), vec2i(unconst_i32(231), unconst_i32(304))).r) {
  break;
}
  buffer106[bitcast<u32>((*&vw35).a)][unconst_u32(41)][unconst_u32(101)] = (*&buffer106)[143][unconst_u32(63)][unconst_u32(47)];
  break;
  _ = buffer106;
}
  let vf173: f32 = vf171.f20[unconst_u32(115)];
  out.f20 -= vw34.f20;
  vp5.f19 ^= vf171.f19;
  let ptr132: ptr<uniform, FragmentOutput8> = &(*a2)[unconst_u32(37)][0];
  return out;
  _ = override9;
  _ = buffer106;
}

var<workgroup> vw43: VertexOutput6;

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

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

var<workgroup> vw36: atomic<i32>;

var<workgroup> vw38: atomic<i32>;

var<private> vp4: FragmentOutput8 = FragmentOutput8();

struct FragmentOutput8 {
  @location(0) @interpolate(linear, either) f0: vec4f,
}

alias vec3b = vec3<bool>;

var<workgroup> vw34: VertexOutput6;

var<workgroup> vw32: atomic<i32>;

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

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

struct VertexOutput6 {
  @location(7) @interpolate(flat, sample) f19: vec4u,
  @builtin(position) f20: vec4f,
}

/* zero global variables used */
@vertex
fn vertex8(@location(13) @interpolate(flat) a0: u32) -> VertexOutput6 {
  var out: VertexOutput6;
  {
  {
  _ = fn1(VertexOutput6(bitcast<vec4u>(vp4.f0), vp4.f0));
}
  out.f19 = unpack4xU8(u32(vp5.f20[unconst_u32(8)]));
}
  _ = fn2(mat4x2h(vec2h(unpack4x8snorm(unconst_u32(164)).gg), vec2h(unpack4x8snorm(unconst_u32(164)).yy), vec2h(unpack4x8snorm(unconst_u32(164)).rr), vec2h(unpack4x8snorm(unconst_u32(164)).ab)));
  let vf175: vec2i = (vec2i(unconst_i32(148), unconst_i32(-183)) | vec2i(unconst_i32(63), unconst_i32(214)));
  var vf176 = fn1(VertexOutput6(bitcast<vec4u>(vp4.f0), vp4.f0));
  let ptr134: ptr<private, vec4u> = &vp5.f19;
  vf176 = VertexOutput6(vec4u(override9), vec4f(f32(override9)));
  vf176.f20 = vec4f(f32((*ptr134)[unconst_u32(157)]));
  var vf177: f32 = vp4.f0[unconst_u32(343)];
  var vf178 = fn1(VertexOutput6(vec4u(vp4.f0), vp4.f0));
  return out;
  _ = override9;
}

/* used global variables: et0 */
@fragment
fn fragment10(@location(5) a0: vec4f, @location(15) @interpolate(linear, sample) a1: f16) -> FragmentOutput8 {
  var out: FragmentOutput8;
  vp5.f19 = unpack4xU8(pack4xI8Clamp(vec4i(unconst_i32(565), unconst_i32(21), unconst_i32(44), unconst_i32(319))));
  let ptr135: ptr<private, vec4f> = &vp4.f0;
  vp5 = VertexOutput6(vec4u(vp5.f19[unconst_u32(54)]), unpack4x8unorm(vp5.f19[unconst_u32(54)]));
  out.f0 = textureLoad(et0, countTrailingZeros(vec2u(unconst_u32(106), unconst_u32(192))));
  let vf179: vec2u = countLeadingZeros(vec2u(pack4xI8Clamp(vec4i(vp4.f0))));
  out = FragmentOutput8(bitcast<vec4f>((vec2u(smoothstep(vec4f(unconst_f32(0.09916), unconst_f32(0.2664), unconst_f32(0.09424), unconst_f32(0.00909)), bitcast<vec4f>(min(vec3i(unconst_i32(69), unconst_i32(131), unconst_i32(280)), vec3i(unconst_i32(55), unconst_i32(-111), unconst_i32(47))).rggr), vec4f(unconst_f32(0.1572), unconst_f32(0.01595), unconst_f32(0.09762), unconst_f32(0.1593))).yz) + vec2u(unconst_u32(65), unconst_u32(46))).rggg));
  while bool(vp5.f20[1]) {
  var vf180: u32 = vp5.f19[u32(vp4.f0.w)];
}
  out.f0 = vp4.f0;
  out = FragmentOutput8(bitcast<vec4f>(clamp(vec4i(unconst_i32(221), unconst_i32(397), unconst_i32(28), unconst_i32(232)), vec4i(unconst_i32(-20), unconst_i32(24), unconst_i32(2), unconst_i32(77)), vec4i((vec3h(unconst_f16(4432.4), unconst_f16(2594.8), unconst_f16(13509.5)) != vec3h(f16(pack4xI8Clamp(vec4i(unconst_i32(113), unconst_i32(214), unconst_i32(347), unconst_i32(-687)))))).bbgb))));
  out.f0 = vec4f(f32(a1));
  vp4 = FragmentOutput8(unpack4x8unorm(pack4xI8Clamp(vec4i(unconst_i32(47), unconst_i32(17), unconst_i32(78), unconst_i32(314)))));
  var vf181: u32 = pack4x8unorm(vec4f(unconst_f32(0.1838), unconst_f32(0.1260), unconst_f32(0.2239), unconst_f32(0.5769)));
  if bool(clamp(vec4i(unconst_i32(10), unconst_i32(510), unconst_i32(121), unconst_i32(85)), vec4i(unconst_i32(133), unconst_i32(117), unconst_i32(4), unconst_i32(-28)), vec4i(unconst_i32(36), unconst_i32(385), unconst_i32(37), unconst_i32(205)))[0]) {
  _ = fn4(array<u32, 1>(pack4xU8Clamp(vp5.f19)));
  let vf182: f32 = degrees(a0[unconst_u32(115)]);
  let vf183: vec2f = radians(vec2f(f32(a1)));
  return out;
  _ = override9;
}
  out = FragmentOutput8(vec4f(f32(vp5.f19[unconst_u32(77)])));
  return out;
  _ = override9;
  _ = et0;
}`,
});
let texture134 = device0.createTexture({
  size: [258, 15, 538],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], depthReadOnly: true});
let renderBundle27 = renderBundleEncoder27.finish({});
try {
renderPassEncoder30.setBindGroup(1, bindGroup81);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup62, new Uint32Array(1573), 203, 0);
} catch {}
try {
renderPassEncoder10.draw(0, 7, 0, 937_080_212);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer40, 3_728);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer26, 'uint32', 2_452, 3_518);
} catch {}
let imageBitmap4 = await createImageBitmap(canvas1);
try {
computePassEncoder108.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer91, 876);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer29, 412);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer25, 'uint16', 3_410, 434);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(1, buffer79, 80, 646);
} catch {}
try {
adapter1.label = '\ua8b0\u2b88\u2d89';
} catch {}
let pipelineLayout22 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout21]});
let externalTexture17 = device0.importExternalTexture({source: videoFrame7});
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'smpteSt4281'} });
let shaderModule9 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

/* used global variables: tex8 */
@must_use 
fn fn7(a0: vec2h, a1: mat2x3h) -> array<vec2h, 1> {
  var out: array<vec2h, 1>;
  var vf214 = fn0();
  _ = fn3();
  while bool(vp6[0][48][0]) {
  var vf215 = fn0();
  break;
  _ = override11;
}
  fn3();
  return out;
  _ = override11;
  _ = tex8;
}

@group(0) @binding(176) var tex8: texture_2d<i32>;

/* used global variables: tex8 */
fn fn4(a0: mat2x2f) -> array<f16, 32> {
  var out: array<f16, 32>;
  let vf209: vec4u = firstLeadingBit(vec4u(unconst_u32(382), unconst_u32(197), unconst_u32(350), unconst_u32(2)));
  var vf210: vec3f = cosh(vec3f(unconst_f32(0.06808), unconst_f32(0.05692), unconst_f32(0.3178)));
  fn2();
  let ptr160: ptr<private, array<array<i32, 1>, 49>> = &vp6[unconst_u32(366)];
  vf210 += bitcast<vec3f>(firstLeadingBit(vec4u(unconst_u32(17), unconst_u32(14), unconst_u32(117), unconst_u32(147))).zxy);
  fn0();
  fn1(unpack4xI8(textureNumLevels(tex8)));
  vp8 += bitcast<vec4f>(vf209);
  vf210 = vec3f(f32(vp6[0][unconst_u32(428)][0]));
  var vf211: vec2u = textureDimensions(tex8, unconst_i32(56));
  var vf212 = fn1((vec2i(unconst_i32(303), unconst_i32(56)) / vec2i(unconst_i32(40), unconst_i32(17))).rrrr);
  vp8 = vec4f(bitcast<f32>(vp6[unconst_u32(210)][48][0]));
  let vf213: f16 = vf212[unconst_u32(209)][unconst_u32(81)][0][3][0][0][unconst_u32(17)];
  return out;
  _ = override11;
  _ = override10;
  _ = tex8;
}

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

/* zero global variables used */
fn fn1(a0: vec4i) -> array<array<array<array<array<array<vec4h, 1>, 1>, 4>, 1>, 1>, 1> {
  var out: array<array<array<array<array<array<vec4h, 1>, 1>, 4>, 1>, 1>, 1>;
  out[0][unconst_u32(39)][unconst_u32(28)][unconst_u32(238)][unconst_u32(50)][unconst_u32(136)] = sin(vec3h(unconst_f16(525.9), unconst_f16(2037.3), unconst_f16(18289.3))).rrbr;
  var vf192 = fn0();
  var vf193: u32 = pack2x16unorm(vec2f(unconst_f32(0.2643), unconst_f32(-0.1685)));
  _ = fn0();
  let ptr145: ptr<private, i32> = &vp6[0][48][0];
  vf193 = bitcast<u32>(vp6[unconst_u32(56)][48][0]);
  for (var it13=u32(vp6[0][48][0]); it13<bitcast<vec3u>(cosh(vec3f(unconst_f32(0.00113), unconst_f32(0.2978), unconst_f32(0.03256)))).x; it13++) {
  vp7 = mat2x2h(f16(vp6[unconst_u32(1000)][48][0]), f16(vp6[unconst_u32(1000)][48][0]), f16(vp6[unconst_u32(1000)][48][0]), f16(vp6[unconst_u32(1000)][48][0]));
  let ptr146: ptr<private, array<array<array<i32, 1>, 49>, 1>> = &vp6;
  {
  vp7 = mat2x2h(f16(dot(vec4f(unconst_f32(0.2029), unconst_f32(0.2386), unconst_f32(0.1543), unconst_f32(0.1208)), vec4f(unconst_f32(0.5899), unconst_f32(0.2254), unconst_f32(0.4442), unconst_f32(1.000)))), f16(dot(vec4f(unconst_f32(0.2029), unconst_f32(0.2386), unconst_f32(0.1543), unconst_f32(0.1208)), vec4f(unconst_f32(0.5899), unconst_f32(0.2254), unconst_f32(0.4442), unconst_f32(1.000)))), f16(dot(vec4f(unconst_f32(0.2029), unconst_f32(0.2386), unconst_f32(0.1543), unconst_f32(0.1208)), vec4f(unconst_f32(0.5899), unconst_f32(0.2254), unconst_f32(0.4442), unconst_f32(1.000)))), f16(dot(vec4f(unconst_f32(0.2029), unconst_f32(0.2386), unconst_f32(0.1543), unconst_f32(0.1208)), vec4f(unconst_f32(0.5899), unconst_f32(0.2254), unconst_f32(0.4442), unconst_f32(1.000)))));
}
  break;
}
  let ptr147: ptr<function, f16> = &vf192[unconst_u32(32)];
  let vf194: vec2f = reflect(vec2f(unconst_f32(0.2499), unconst_f32(0.00674)), vec2f(unconst_f32(0.01701), unconst_f32(0.1775)));
  return out;
  _ = override11;
}

/* zero global variables used */
fn fn2() -> array<array<array<f32, 1>, 1>, 40> {
  var out: array<array<array<f32, 1>, 1>, 40>;
  vp7 -= mat2x2h(f16(vp6[unconst_u32(11)][unconst_u32(103)][0]), f16(vp6[unconst_u32(11)][unconst_u32(103)][0]), f16(vp6[unconst_u32(11)][unconst_u32(103)][0]), f16(vp6[unconst_u32(11)][unconst_u32(103)][0]));
  let ptr148: ptr<private, array<i32, 1>> = &vp6[unconst_u32(231)][48];
  let vf195: vec2h = vp7[unconst_u32(155)];
  vp7 += mat2x2h(f16((*ptr148)[0]), f16((*ptr148)[0]), f16((*ptr148)[0]), f16((*ptr148)[0]));
  _ = fn1(vec4i(vp6[unconst_u32(112)][unconst_u32(352)][unconst_u32(47)]));
  loop {
  var vf196: vec2<bool> = (vec2f(unconst_f32(0.1326), unconst_f32(0.06572)) != vec2f(unconst_f32(-0.1907), unconst_f32(0.00193)));
  break;
}
  vp6[unconst_u32(242)][unconst_u32(49)][0] += i32(vp7[unconst_u32(113)][unconst_u32(48)]);
  loop {
  _ = fn1(vec4i(cross(vec3h(f16(override10)), vec3h(unconst_f16(2598.4), unconst_f16(13517.1), unconst_f16(205.9))).brgg));
  fn0();
  vp7 = mat2x2h(f16(vp6[unconst_u32(936)][48][0]), f16(vp6[unconst_u32(936)][48][0]), f16(vp6[unconst_u32(936)][48][0]), f16(vp6[unconst_u32(936)][48][0]));
  break;
  _ = override10;
  _ = override11;
}
  out[unconst_u32(25)][0][0] = bitcast<f32>(vp7[unconst_i32(0)]);
  out[unconst_u32(45)][unconst_u32(274)][unconst_u32(57)] = quantizeToF16(vec2f(unconst_f32(0.01853), unconst_f32(0.00396)))[0];
  {
  fn1(vec4i(vp6[unconst_u32(617)][48][0]));
  let ptr149: ptr<private, i32> = &vp6[unconst_u32(307)][unconst_u32(46)][0];
  let ptr150: ptr<private, i32> = &vp6[0][(vec3u(unconst_u32(207), unconst_u32(48), unconst_u32(176)) << (bitcast<u32>(vp6[unconst_u32(33)][48][unconst_u32(80)]) % vec2u(unconst_u32(137), unconst_u32(123))).yxx)[2]][unconst_u32(103)];
  vp6[unconst_u32(114)][unconst_u32(7)][unconst_u32(123)] *= i32(any((vec3u(unconst_u32(254), unconst_u32(15), unconst_u32(69)) != vec3u(unconst_u32(107), unconst_u32(56), unconst_u32(175)))));
  let ptr151: ptr<private, vec4f> = &vp8;
  var vf197: vec4h = reflect(vec4h(unconst_f16(27389.2), unconst_f16(4182.9), unconst_f16(14350.2), unconst_f16(26576.8)), vec4h(unconst_f16(7183.1), unconst_f16(846.0), unconst_f16(15612.3), unconst_f16(2263.5)));
  _ = override11;
}
  {
  let ptr152: ptr<private, i32> = &vp6[unconst_u32(95)][48][0];
  vp7 = mat2x2h(f16(vp6[0][48][unconst_u32(250)]), f16(vp6[0][48][unconst_u32(250)]), f16(vp6[0][48][unconst_u32(250)]), f16(vp6[0][48][unconst_u32(250)]));
  let vf198: vec3h = cosh(vec3h(unconst_f16(9035.1), unconst_f16(15453.1), unconst_f16(-1815.4)));
  loop {
  let ptr153: ptr<private, array<i32, 1>> = &vp6[unconst_u32(12)][48];
  var vf199 = fn1(vec4i(i32((unconst_f16(869.3) - unconst_f16(7529.0)))));
  let ptr154: ptr<function, vec4h> = &vf199[0][unconst_u32(115)][0][3][0][0];
  var vf200 = fn1(vec4i(vf199[0][unconst_u32(41)][vec4u(vf199[unconst_u32(166)][0][unconst_u32(119)][unconst_u32(38)][0][0]).b][u32(vf199[unconst_u32(10)][0][0][3][0][pack2x16float(vec2f(unconst_f32(0.1270), unconst_f32(0.09040)))][bitcast<u32>(vp7[unconst_u32(38)])])][unconst_u32(1)][0]));
  break;
  _ = override11;
}
  out[unconst_u32(390)][unconst_u32(209)][unconst_u32(187)] += vp8[unconst_u32(511)];
  vp7 -= mat2x2h(f16(select(unconst_u32(124), unconst_u32(87), unconst_bool(false))), f16(select(unconst_u32(124), unconst_u32(87), unconst_bool(false))), f16(select(unconst_u32(124), unconst_u32(87), unconst_bool(false))), f16(select(unconst_u32(124), unconst_u32(87), unconst_bool(false))));
  _ = override11;
}
  return out;
  _ = override10;
  _ = override11;
}

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

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

var<private> vp6: array<array<array<i32, 1>, 49>, 1> = array<array<array<i32, 1>, 49>, 1>();

@id(63796) override override10: i32;

var<private> vp8: vec4f = vec4f(0.2517, 0.09246, 0.05628, 0.2851);

var<workgroup> vw46: mat3x2h;

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

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

var<workgroup> vw45: array<mat2x4h, 1>;

/* zero global variables used */
fn fn6(a0: array<array<vec2i, 1>, 1>, a1: array<vec2h, 1>) -> array<i32, 1> {
  var out: array<i32, 1>;
  let ptr162: ptr<private, i32> = &vp6[0][unconst_u32(44)][unconst_u32(114)];
  vp6[unconst_u32(567)][48][unconst_u32(625)] = bitcast<i32>(quantizeToF16(unconst_f32(0.1132)));
  out[unconst_u32(183)] = a0[unconst_u32(7)][0][unconst_u32(650)];
  return out;
}

var<workgroup> vw44: u32;

alias vec3b = vec3<bool>;

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

/* zero global variables used */
fn fn0() -> array<f16, 32> {
  var out: array<f16, 32>;
  let vf184: vec2h = smoothstep(vec2h(unconst_f16(-10820.7), unconst_f16(12449.8)), vec2h(unconst_f16(-6312.3), unconst_f16(1046.3)), vec2h(unconst_f16(15821.2), unconst_f16(3210.5)));
  out[31] = vp7[unconst_u32(267)].g;
  out[pack4xU8Clamp(vec4u(transpose(mat4x3h())[unconst_i32(0)]))] -= f16(vp6[unconst_u32(515)][48][unconst_u32(109)]);
  let ptr136: ptr<private, array<i32, 1>> = &vp6[unconst_u32(10)][unconst_u32(72)];
  switch i32(reverseBits(vec4u(unconst_u32(417), unconst_u32(44), unconst_u32(185), unconst_u32(642))).w) { 
  default {
  let vf185: bool = all(vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false), unconst_bool(true)));
  let ptr137: ptr<private, i32> = &vp6[unconst_u32(104)][48][unconst_u32(26)];
  var vf186: f32 = fract(unconst_f32(0.05134));
  let vf187: vec3f = log(vec3f(unconst_f32(0.08066), unconst_f32(0.1490), unconst_f32(-0.07331)));
  let vf188: vec2h = ldexp(vec2h(unconst_f16(16925.6), unconst_f16(954.4)), vec2i(unconst_i32(568), unconst_i32(411)));
  let vf189: u32 = pack2x16float(radians(vec3f(unconst_f32(0.09113), unconst_f32(0.02322), unconst_f32(0.05006))).rb);
  break;
}
  }
  vp6[unconst_u32(163)][unconst_u32(3)][unconst_u32(45)] = vp6[unconst_u32(664)][48][0];
  let ptr138: ptr<private, array<i32, 1>> = &vp6[unconst_u32(124)][unconst_u32(2)];
  let vf190: u32 = pack4x8snorm(vec4f(unconst_f32(0.00130), unconst_f32(0.06602), unconst_f32(0.3089), unconst_f32(0.3544)));
  out[unconst_u32(181)] = f16((mat2x2f(unconst_f32(0.1437), unconst_f32(0.4011), unconst_f32(0.00970), unconst_f32(0.09912)) * unconst_f32(-0.00124))[unconst_i32(0)].g);
  let ptr139: ptr<private, i32> = &(*ptr138)[unconst_u32(79)];
  while bool(vp6[0][u32(cos(vec3h(unconst_f16(16547.0), unconst_f16(8950.9), unconst_f16(5265.3)))[0])][0]) {
  let ptr140: ptr<private, array<i32, 1>> = &vp6[0][48];
  vp8 = unpack4x8unorm(override11);
  break;
  _ = override11;
}
  loop {
  let ptr141: ptr<private, i32> = &vp6[unconst_u32(281)][unconst_u32(14)][unconst_u32(11)];
  let vf191: bool = all(unconst_bool(true));
  vp7 = mat2x2h(f16(vp6[0][unconst_u32(363)][0]), f16(vp6[0][unconst_u32(363)][0]), f16(vp6[0][unconst_u32(363)][0]), f16(vp6[0][unconst_u32(363)][0]));
  break;
}
  let ptr142: ptr<private, i32> = &vp6[unconst_u32(110)][unconst_u32(169)][unconst_u32(603)];
  let ptr143: ptr<private, array<array<i32, 1>, 49>> = &vp6[unconst_u32(356)];
  let ptr144: ptr<private, i32> = &(*ptr143)[unconst_u32(62)][unconst_u32(44)];
  return out;
  _ = override11;
}

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

/* used global variables: tex8 */
fn fn3() -> vec2h {
  var out: vec2h;
  var vf201 = fn0();
  vf201[bitcast<u32>(vp6[unconst_u32(210)][unconst_u32(55)][unconst_u32(56)])] = f16(vp6[unconst_u32(156)][48][0]);
  var vf202 = fn0();
  vp7 = mat2x2h(f16(vp6[unconst_u32(248)][48][0]), f16(vp6[unconst_u32(248)][48][0]), f16(vp6[unconst_u32(248)][48][0]), f16(vp6[unconst_u32(248)][48][0]));
  out = bitcast<vec2h>(vp6[bitcast<u32>(vp6[0][48][unconst_u32(244)])][unconst_u32(62)][unconst_u32(197)]);
  let ptr155: ptr<function, f16> = &vf202[unconst_u32(141)];
  {
  let ptr156: ptr<private, i32> = &vp6[0][48][unconst_u32(35)];
  fn0();
  var vf203 = fn0();
  var vf204: vec4i = textureLoad(tex8, vec2i(unconst_i32(-144), unconst_i32(1000)), unconst_i32(268));
  _ = override11;
  _ = tex8;
}
  let ptr157: ptr<function, f16> = &(*ptr155);
  {
  while bool(textureDimensions(tex8, unconst_i32(286)).y) {
  vp7 = mat2x2h(f16(pack2x16float(vec2f(unconst_f32(0.04584), unconst_f32(0.2067)))), f16(pack2x16float(vec2f(unconst_f32(0.04584), unconst_f32(0.2067)))), f16(pack2x16float(vec2f(unconst_f32(0.04584), unconst_f32(0.2067)))), f16(pack2x16float(vec2f(unconst_f32(0.04584), unconst_f32(0.2067)))));
  var vf205 = fn0();
  break;
  _ = override11;
}
  {
  let ptr158: ptr<private, array<i32, 1>> = &vp6[unconst_u32(106)][unconst_u32(202)];
  var vf206 = fn0();
  vp6[unconst_u32(557)][unconst_u32(344)][unconst_u32(271)] &= (*ptr158)[0];
  let vf207: bool = (unconst_bool(true) || unconst_bool(true));
  _ = override11;
}
  let ptr159: ptr<private, i32> = &vp6[unconst_u32(112)][unconst_u32(210)][0];
  _ = override11;
  _ = tex8;
}
  var vf208 = fn0();
  return out;
  _ = override11;
  _ = tex8;
}

/* zero global variables used */
fn fn5(a0: ptr<private, mat3x3f>, a1: array<vec4<bool>, 1>) -> array<array<mat2x3f, 2>, 1> {
  var out: array<array<mat2x3f, 2>, 1>;
  let ptr161: ptr<private, i32> = &vp6[0][48][0];
  fn0();
  _ = fn0();
  fn0();
  (*a0) += mat3x3f(bitcast<f32>(vp6[0][48][0]), bitcast<f32>(vp6[0][48][0]), bitcast<f32>(vp6[0][48][0]), bitcast<f32>(vp6[0][48][0]), f32(vp6[0][48][0]), f32(vp6[0][48][0]), f32(vp6[0][48][0]), f32(vp6[0][48][0]), f32(vp6[0][48][0]));
  return out;
  _ = override11;
}

@id(26995) override override11: u32;

var<private> vp7: mat2x2h = mat2x2h(1598.5, 3080.3, 6306.1, 18528.4);

/* zero global variables used */
@fragment
fn fragment11() -> @location(200) @interpolate(flat, either) vec4f {
  var out: vec4f;
  let ptr163: ptr<private, array<array<i32, 1>, 49>> = &vp6[unconst_u32(276)];
  let ptr164: ptr<private, i32> = &vp6[unconst_u32(68)][48][unconst_u32(186)];
  fn0();
  fn1(firstLeadingBit(vec2i(vp6[unconst_u32(476)][unconst_u32(202)][0])).xxxx);
  var vf216 = fn0();
  vp6[unconst_u32(154)][unconst_u32(100)][unconst_u32(58)] |= vp6[unconst_u32(15)][48][0];
  out += vec4f((vec3i(i32(vf216[31])) >> vec3u(unconst_u32(261), unconst_u32(98), unconst_u32(99))).rbbg);
  return out;
  _ = override11;
}

/* zero global variables used */
@compute @workgroup_size(2, 1, 1)
fn compute9() {
  _ = fn2();
  vp8 *= vec4f((*&vw46)[unconst_i32(2)].rrgg);
  let ptr165: ptr<workgroup, mat2x4h> = &(*&vw45)[0];
  _ = override11;
  _ = override10;
}

/* zero global variables used */
@compute @workgroup_size(1, 1, 1)
fn compute10() {
  let vf217: f16 = vw46[unconst_u32(29)][unconst_u32(217)];
  var vf218: vec3i = countTrailingZeros(vec3i(unconst_i32(350), unconst_i32(317), unconst_i32(1)));
  var vf219: u32 = pack2x16snorm(vec2f(unconst_f32(-0.2115), unconst_f32(0.1491)));
  fn2();
  vw46 += mat3x2h(ldexp(vec2h(unconst_f16(4548.9), unconst_f16(21581.4)), vec2i(unconst_i32(460), unconst_i32(43))), ldexp(vec2h(unconst_f16(4548.9), unconst_f16(21581.4)), vec2i(unconst_i32(460), unconst_i32(43))), ldexp(vec2h(unconst_f16(4548.9), unconst_f16(21581.4)), vec2i(unconst_i32(460), unconst_i32(43))));
  for (var it14=bitcast<u32>(vp6[unconst_u32(40)][unconst_u32(13)][0]); it14<u32(vw45[0][unconst_u32(305)][unconst_u32(12)]); it14++) {
  let ptr166: ptr<workgroup, mat2x4h> = &(*&vw45)[unconst_u32(73)];
  var vf220 = fn0();
  let ptr167: ptr<private, i32> = &vp6[0][48][0];
  let ptr168: ptr<private, i32> = &vp6[unconst_u32(66)][48][0];
  _ = override11;
}
  _ = override11;
  _ = override10;
}`,
});
let buffer107 = device0.createBuffer({
  size: 10003,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture135 = device0.createTexture({
  size: [258, 15, 11],
  format: 'stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['stencil8'],
});
try {
computePassEncoder35.setBindGroup(2, bindGroup57);
} catch {}
try {
computePassEncoder84.setPipeline(pipeline26);
} catch {}
try {
renderPassEncoder37.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder30.setBindGroup(1, bindGroup13, new Uint32Array(5617), 699, 0);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer54, 984);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer71, 10_192);
} catch {}
try {
computePassEncoder84.insertDebugMarker('\u0c1a');
} catch {}
let commandEncoder150 = device0.createCommandEncoder();
let texture136 = device0.createTexture({
  size: {width: 22, height: 10, depthOrArrayLayers: 9},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float', 'rgba16float'],
});
let textureView167 = texture110.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder11.beginOcclusionQuery(17);
} catch {}
try {
renderPassEncoder11.endOcclusionQuery();
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer62, 420);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer10, 'uint16', 7_220, 66);
} catch {}
let texture137 = device0.createTexture({
  size: [180, 80, 91],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder129 = commandEncoder150.beginComputePass({});
try {
computePassEncoder127.setBindGroup(2, bindGroup21);
} catch {}
try {
computePassEncoder2.setBindGroup(0, bindGroup11, new Uint32Array(1944), 1_280, 0);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle4, renderBundle1]);
} catch {}
try {
renderPassEncoder10.draw(0, 103, 0, 388_259_449);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer40, 444);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(7, buffer47);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({entries: [{binding: 3, visibility: GPUShaderStage.VERTEX, externalTexture: {}}]});
let textureView168 = texture137.createView({baseArrayLayer: 0});
let texture138 = device0.createTexture({
  size: {width: 180, height: 80, depthOrArrayLayers: 16},
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
computePassEncoder129.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder26.setBindGroup(3, bindGroup6);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup40, new Uint32Array(461), 39, 0);
} catch {}
try {
renderPassEncoder16.setBlendConstant({ r: 376.9, g: -996.9, b: 516.8, a: -520.0, });
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer6, 2_136);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer16, 732);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer82, 'uint16', 2_268, 2_180);
} catch {}
let commandEncoder151 = device0.createCommandEncoder({});
try {
computePassEncoder72.setBindGroup(1, bindGroup28);
} catch {}
try {
computePassEncoder30.setBindGroup(0, bindGroup78, new Uint32Array(5406), 115, 0);
} catch {}
try {
renderPassEncoder10.end();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({
  entries: [
    {binding: 5, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {binding: 152, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 264,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
  ],
});
let bindGroup89 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout16,
  entries: [
    {binding: 169, resource: {buffer: buffer19, offset: 3584, size: 123}},
    {binding: 359, resource: sampler70},
    {binding: 267, resource: {buffer: buffer11, offset: 256, size: 352}},
    {binding: 47, resource: externalTexture1},
    {binding: 192, resource: {buffer: buffer8, offset: 256, size: 2644}},
  ],
});
let commandEncoder152 = device0.createCommandEncoder();
let texture139 = gpuCanvasContext1.getCurrentTexture();
let textureView169 = texture102.createView({dimension: '2d-array', baseArrayLayer: 4, arrayLayerCount: 8});
let renderPassEncoder39 = commandEncoder152.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 442,
  clearValue: { r: 753.9, g: -343.0, b: -702.6, a: -386.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet5},
});
let sampler84 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 12,
});
try {
computePassEncoder35.setBindGroup(1, bindGroup42);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer1, 'uint16', 1_014, 17);
} catch {}
try {
commandEncoder10.resolveQuerySet(querySet2, 14, 75, buffer11, 3840);
} catch {}
try {
device0.queue.writeBuffer(buffer67, 40, new Float32Array(13111), 3222, 692);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline29 = device0.createRenderPipeline({
  layout: pipelineLayout13,
  fragment: {module: shaderModule5, constants: {}, targets: [{format: 'rgb10a2unorm'}]},
  vertex: {
    module: shaderModule5,
    entryPoint: 'vertex6',
    constants: {},
    buffers: [
      {
        arrayStride: 224,
        attributes: [
          {format: 'sint32x2', offset: 4, shaderLocation: 0},
          {format: 'uint32x2', offset: 76, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', cullMode: 'front', unclippedDepth: false},
});
let commandEncoder153 = device0.createCommandEncoder({});
try {
renderPassEncoder22.setBindGroup(1, bindGroup87);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer43, 'uint16', 2, 12);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 612, new Int16Array(1104), 4, 172);
} catch {}
document.body.append(img1);
let imageData20 = new ImageData(188, 24);
try {
adapter1.label = '\u9c87\u{1ffe2}\uf86e\ue414\u0eb3';
} catch {}
let bindGroup90 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout16,
  entries: [
    {binding: 169, resource: {buffer: buffer32, offset: 5120, size: 403}},
    {binding: 267, resource: {buffer: buffer87, offset: 512}},
    {binding: 47, resource: externalTexture11},
    {binding: 192, resource: {buffer: buffer49, offset: 3328}},
    {binding: 359, resource: sampler37},
  ],
});
let commandBuffer5 = commandEncoder10.finish();
let textureView170 = texture109.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 6});
try {
renderPassEncoder6.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer87, 'uint32', 372, 620);
} catch {}
try {
buffer72.unmap();
} catch {}
try {
commandEncoder151.copyBufferToBuffer(buffer92, 152, buffer57, 356, 56);
} catch {}
try {
commandEncoder151.copyTextureToTexture({
  texture: texture87,
  mipLevel: 0,
  origin: {x: 32, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture101,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(50, 359);
try {
adapter0.label = '\u06af\u{1faaf}\u0720\u2ef9\u43c9\u0380\u{1f8f7}\u0ab6\u532e\u{1fa59}\u9bba';
} catch {}
let autogeneratedBindGroupLayout8 = pipeline14.getBindGroupLayout(0);
let bindGroup91 = device0.createBindGroup({layout: veryExplicitBindGroupLayout23, entries: [{binding: 3, resource: externalTexture6}]});
let buffer108 = device0.createBuffer({size: 10499, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT, mappedAtCreation: false});
let sampler85 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
computePassEncoder81.setBindGroup(1, bindGroup33, []);
} catch {}
try {
commandEncoder151.copyTextureToTexture({
  texture: texture71,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture80,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
},
{width: 50, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 22, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData12,
  origin: { x: 0, y: 42 },
  flipY: true,
}, {
  texture: texture108,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let querySet15 = device0.createQuerySet({type: 'occlusion', count: 133});
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer103, 0); };
} catch {}
let arrayBuffer7 = buffer57.getMappedRange(8, 44);
try {
buffer92.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer5]);
} catch {}
await gc();
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpte432', transfer: 'iec61966-2-1'} });
let computePassEncoder130 = commandEncoder153.beginComputePass({});
try {
renderPassEncoder30.setBindGroup(3, bindGroup29);
} catch {}
let sampler86 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 92.37,
});
try {
computePassEncoder111.setBindGroup(1, bindGroup9, new Uint32Array(5993), 1_441, 0);
} catch {}
try {
computePassEncoder130.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder39.setIndexBuffer(buffer88, 'uint32', 648, 665);
} catch {}
try {
commandEncoder151.copyTextureToTexture({
  texture: texture13,
  mipLevel: 1,
  origin: {x: 5, y: 23, z: 0},
  aspect: 'all',
},
{
  texture: texture28,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeBuffer(buffer30, 336, new BigUint64Array(5168), 59, 12);
} catch {}
let commandEncoder154 = device0.createCommandEncoder({});
let texture140 = device0.createTexture({
  size: {width: 45, height: 20, depthOrArrayLayers: 39},
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder40 = commandEncoder151.beginRenderPass({colorAttachments: [{view: textureView107, depthSlice: 62, loadOp: 'load', storeOp: 'discard'}]});
try {
computePassEncoder103.setBindGroup(0, bindGroup6);
} catch {}
try {
computePassEncoder124.setBindGroup(3, bindGroup51, new Uint32Array(161), 16, 0);
} catch {}
try {
renderPassEncoder20.setStencilReference(378);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder154.copyTextureToTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture92,
  mipLevel: 1,
  origin: {x: 83, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer78, 1180, new BigUint64Array(6132), 3539, 40);
} catch {}
let gpuCanvasContext6 = offscreenCanvas3.getContext('webgpu');
let commandEncoder155 = device0.createCommandEncoder();
let texture141 = gpuCanvasContext2.getCurrentTexture();
let textureView171 = texture56.createView({mipLevelCount: 1});
let computePassEncoder131 = commandEncoder154.beginComputePass();
let sampler87 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 84.28});
try {
computePassEncoder115.setBindGroup(2, bindGroup88);
} catch {}
try {
computePassEncoder85.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup23, new Uint32Array(3077), 1_427, 0);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer71, 'uint16', 1_754, 8_225);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(3, buffer49);
} catch {}
let computePassEncoder132 = commandEncoder155.beginComputePass({});
try {
computePassEncoder81.setBindGroup(0, bindGroup75, new Uint32Array(1912), 386, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle1, renderBundle5, renderBundle2]);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer32, 'uint32', 528, 430);
} catch {}
try {
renderPassEncoder29.setPipeline(pipeline20);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 244, new BigUint64Array(1126), 83, 20);
} catch {}
let buffer109 = device0.createBuffer({
  size: 11085,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder156 = device0.createCommandEncoder();
let texture142 = device0.createTexture({
  size: {width: 45, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder133 = commandEncoder156.beginComputePass({timestampWrites: {querySet: querySet11, beginningOfPassWriteIndex: 617, endOfPassWriteIndex: 810}});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']});
let externalTexture18 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer71, 2_396); };
} catch {}
try {
computePassEncoder133.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer43, 'uint16', 10, 7);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer104, 0, 716);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup84);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer87, 'uint32', 996, 198);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(1, buffer34, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer58, 1548, new Float32Array(1522));
} catch {}
try {
device0.queue.writeTexture({
  texture: texture100,
  mipLevel: 0,
  origin: {x: 108, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(344_361).fill(53), /* required buffer size: 344_361 */
{offset: 17, bytesPerRow: 1204, rowsPerImage: 22}, {width: 150, height: 0, depthOrArrayLayers: 14});
} catch {}
try {
globalThis.someLabel = externalTexture9.label;
} catch {}
let externalTexture19 = device0.importExternalTexture({source: videoFrame10});
try {
computePassEncoder67.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder131.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup59, new Uint32Array(1008), 183, 0);
} catch {}
try {
renderPassEncoder33.beginOcclusionQuery(29);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle24, renderBundle18]);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup8);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(6, buffer7);
} catch {}
try {
buffer73.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer44, 1268, new Int16Array(2780), 193, 192);
} catch {}
let texture143 = device0.createTexture({
  size: {width: 258},
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder33.setBindGroup(0, bindGroup64, new Uint32Array(251), 17, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder103); computePassEncoder103.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder132.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer41, 'uint16', 446, 94);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer74, 'uint32', 156, 227);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline11);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 3260, new Int16Array(848));
} catch {}
let promise29 = device0.queue.onSubmittedWorkDone();
let commandEncoder157 = device0.createCommandEncoder();
let computePassEncoder134 = commandEncoder157.beginComputePass();
try {
computePassEncoder75.setBindGroup(1, bindGroup66, new Uint32Array(508), 68, 0);
} catch {}
try {
computePassEncoder134.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer46, 'uint16', 184, 43);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer74, 'uint16', 670, 184);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(6, undefined);
} catch {}
let imageData21 = new ImageData(16, 160);
let texture144 = device0.createTexture({
  size: [258, 15, 44],
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle28 = renderBundleEncoder28.finish({});
let sampler88 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat'});
try {
computePassEncoder30.setBindGroup(0, bindGroup57);
} catch {}
try {
renderPassEncoder36.setBindGroup(3, bindGroup39);
} catch {}
try {
renderPassEncoder24.setBindGroup(1, bindGroup69, new Uint32Array(1003), 49, 0);
} catch {}
try {
computePassEncoder49.setBindGroup(2, bindGroup69, new Uint32Array(1171), 70, 0);
} catch {}
try {
renderPassEncoder38.setBindGroup(2, bindGroup80);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline8);
} catch {}
let promise30 = device0.createRenderPipelineAsync({
  layout: pipelineLayout19,
  fragment: {
  module: shaderModule6,
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 260,
        attributes: [
          {format: 'unorm16x2', offset: 40, shaderLocation: 14},
          {format: 'sint32', offset: 28, shaderLocation: 3},
          {format: 'unorm16x4', offset: 28, shaderLocation: 5},
          {format: 'sint32x3', offset: 64, shaderLocation: 13},
          {format: 'uint8x4', offset: 80, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {cullMode: 'front'},
});
let commandEncoder158 = device0.createCommandEncoder({});
let texture145 = device0.createTexture({
  size: [45, 20, 22],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture146 = device0.createTexture({
  size: {width: 129, height: 7, depthOrArrayLayers: 11},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder29.setBindGroup(2, bindGroup22);
} catch {}
try {
renderPassEncoder33.endOcclusionQuery();
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer74, 'uint32', 120, 201);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let imageData22 = new ImageData(112, 100);
let buffer110 = device0.createBuffer({
  size: 13282,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let texture147 = device0.createTexture({
  size: [90, 1, 1],
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgb10a2unorm'],
});
let textureView172 = texture52.createView({});
let renderBundle29 = renderBundleEncoder29.finish({});
let sampler89 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat'});
let externalTexture20 = device0.importExternalTexture({source: videoFrame21});
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer16, 172); };
} catch {}
try {
buffer52.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 32, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(187).fill(229), /* required buffer size: 187 */
{offset: 187}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise29;
} catch {}
let autogeneratedBindGroupLayout9 = pipeline8.getBindGroupLayout(0);
try {
computePassEncoder125.setBindGroup(2, bindGroup73, new Uint32Array(1974), 110, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder103); computePassEncoder103.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder118.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup59);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer11, 'uint32', 4_312, 9_491);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(3, buffer92, 528, 33);
} catch {}
try {
  await shaderModule7.getCompilationInfo();
} catch {}
try {
buffer40.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 80, depthOrArrayLayers: 43}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 38, y: 49, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline30 = device0.createRenderPipeline({
  layout: pipelineLayout21,
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment7',
  constants: {},
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule8,
    constants: {},
    buffers: [{arrayStride: 492, attributes: [{format: 'uint16x4', offset: 244, shaderLocation: 13}]}],
  },
});
let commandEncoder159 = device0.createCommandEncoder({});
let texture148 = device0.createTexture({
  size: [256],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder41 = commandEncoder158.beginRenderPass({
  colorAttachments: [{
  view: textureView128,
  depthSlice: 14,
  clearValue: { r: -842.0, g: 448.6, b: -648.5, a: 336.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder124.setBindGroup(3, bindGroup28, new Uint32Array(2194), 956, 0);
} catch {}
try {
renderPassEncoder33.setBindGroup(1, bindGroup46);
} catch {}
try {
commandEncoder159.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1216 */
  offset: 1216,
  bytesPerRow: 4608,
  buffer: buffer69,
}, {
  texture: texture65,
  mipLevel: 0,
  origin: {x: 1, y: 17, z: 2},
  aspect: 'all',
}, {width: 10, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder30.insertDebugMarker('\u0b99');
} catch {}
let commandEncoder160 = device0.createCommandEncoder({});
let renderPassEncoder42 = commandEncoder160.beginRenderPass({
  colorAttachments: [{
  view: textureView107,
  depthSlice: 378,
  clearValue: { r: -185.8, g: -430.2, b: 100.5, a: -711.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder18.setVertexBuffer(0, buffer8, 304, 1_863);
} catch {}
try {
commandEncoder159.clearBuffer(buffer75);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 22, height: 10, depthOrArrayLayers: 9}
*/
{
  source: imageData17,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture136,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout11 = pipeline29.getBindGroupLayout(0);
let bindGroup92 = device0.createBindGroup({layout: veryExplicitBindGroupLayout23, entries: [{binding: 3, resource: externalTexture13}]});
let buffer111 = device0.createBuffer({
  size: 9873,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let computePassEncoder135 = commandEncoder159.beginComputePass({timestampWrites: {querySet: querySet9, endOfPassWriteIndex: 302}});
try {
{ clearResourceUsages(device0, computePassEncoder77); computePassEncoder77.dispatchWorkgroupsIndirect(buffer97, 4); };
} catch {}
try {
computePassEncoder77.end();
} catch {}
try {
computePassEncoder135.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup59, new Uint32Array(3356), 174, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(1, buffer44, 588, 50);
} catch {}
let bindGroup93 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 328, resource: textureView15}]});
let buffer112 = device0.createBuffer({
  size: 1736,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView173 = texture115.createView({aspect: 'all', baseArrayLayer: 0});
let computePassEncoder136 = commandEncoder92.beginComputePass();
try {
computePassEncoder56.setBindGroup(2, bindGroup29);
} catch {}
try {
computePassEncoder98.setBindGroup(0, bindGroup69, new Uint32Array(1934), 84, 0);
} catch {}
try {
computePassEncoder136.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder41.setBlendConstant({ r: -954.4, g: -561.3, b: 853.0, a: -676.9, });
} catch {}
let promise31 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 180, height: 1, depthOrArrayLayers: 50}
*/
{
  source: imageData4,
  origin: { x: 4, y: 9 },
  flipY: false,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 46, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup94 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 578, resource: {buffer: buffer26, offset: 256}}],
});
let commandEncoder161 = device0.createCommandEncoder({});
let computePassEncoder137 = commandEncoder161.beginComputePass({});
try {
computePassEncoder118.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder25.setBindGroup(2, bindGroup53, new Uint32Array(576), 1, 0);
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle27, renderBundle4, renderBundle6]);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer81, 'uint32', 840, 2_520);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline29);
} catch {}
try {
  await promise31;
} catch {}
let videoFrame26 = videoFrame4.clone();
let commandEncoder162 = device0.createCommandEncoder({label: '\u83ac\u{1ff39}\u0965\udc3a\u{1f819}\ubf23\u{1fc38}\ub420\u{1f6c7}\u7a10'});
try {
renderPassEncoder20.setBindGroup(1, bindGroup78, new Uint32Array(156), 9, 0);
} catch {}
try {
commandEncoder162.clearBuffer(buffer109, 2728, 256);
} catch {}
let texture149 = device0.createTexture({
  size: [22, 10, 11],
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder138 = commandEncoder162.beginComputePass();
try {
computePassEncoder4.setBindGroup(0, bindGroup6, new Uint32Array(657), 33, 0);
} catch {}
try {
computePassEncoder43.end();
} catch {}
try {
computePassEncoder49.setPipeline(pipeline22);
} catch {}
try {
computePassEncoder138.setPipeline(pipeline15);
} catch {}
try {
commandEncoder52.copyTextureToBuffer({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 94 */
  offset: 94,
  bytesPerRow: 10752,
  buffer: buffer75,
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup95 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout20,
  entries: [{binding: 16, resource: {buffer: buffer8, offset: 512, size: 1512}}],
});
let commandEncoder163 = device0.createCommandEncoder({});
let commandBuffer6 = commandEncoder52.finish();
let texture150 = device0.createTexture({
  size: [90, 1, 27],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder139 = commandEncoder163.beginComputePass({});
try {
computePassEncoder101.setBindGroup(2, bindGroup80);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder118); computePassEncoder118.dispatchWorkgroupsIndirect(buffer68, 9_868); };
} catch {}
try {
computePassEncoder139.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup54, new Uint32Array(3411), 189, 0);
} catch {}
try {
renderPassEncoder32.setPipeline(pipeline20);
} catch {}
try {
computePassEncoder75.insertDebugMarker('\u{1fd4c}');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 22, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture108,
  mipLevel: 2,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView174 = texture74.createView({});
let texture151 = device0.createTexture({
  size: [517, 30, 11],
  mipLevelCount: 4,
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder29.setIndexBuffer(buffer10, 'uint32', 9_948, 2_826);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(7, buffer27, 0, 811);
} catch {}
try {
device0.queue.submit([commandBuffer6]);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({
  entries: [
    {binding: 47, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 169,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 192,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 267, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 359,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let textureView175 = texture148.createView({});
let sampler90 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.82,
  compare: 'greater-equal',
  maxAnisotropy: 11,
});
try {
computePassEncoder137.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup44, new Uint32Array(8115), 102, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(2, undefined);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
document.body.append(img0);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let imageData23 = new ImageData(12, 16);
let texture152 = device0.createTexture({
  size: {width: 517, height: 30, depthOrArrayLayers: 11},
  mipLevelCount: 5,
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC,
});
let externalTexture21 = device0.importExternalTexture({source: videoFrame18, colorSpace: 'srgb'});
try {
computePassEncoder118.end();
} catch {}
try {
renderPassEncoder33.setBindGroup(0, bindGroup53, new Uint32Array(1911), 33, 0);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(5, buffer51, 96);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 10, y: 48, z: 10},
  aspect: 'all',
}, new Uint8Array(6_650).fill(151), /* required buffer size: 6_650 */
{offset: 286, bytesPerRow: 225, rowsPerImage: 26}, {width: 20, height: 12, depthOrArrayLayers: 2});
} catch {}
document.body.prepend(canvas2);
let bindGroup96 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout20,
  entries: [{binding: 16, resource: {buffer: buffer25, offset: 0, size: 2748}}],
});
let texture153 = device0.createTexture({
  size: [180, 1, 10],
  mipLevelCount: 2,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderPassEncoder43 = commandEncoder135.beginRenderPass({colorAttachments: [{view: textureView157, loadOp: 'load', storeOp: 'discard'}]});
try {
renderPassEncoder22.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder41.setVertexBuffer(5, buffer45, 4_048);
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, alphaMode: 'premultiplied'});
} catch {}
try {
  await promise28;
} catch {}
document.body.append(img0);
let bindGroup97 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 254, resource: {buffer: buffer74, offset: 0, size: 28}},
    {binding: 62, resource: textureView18},
    {binding: 578, resource: {buffer: buffer0, offset: 0, size: 4108}},
  ],
});
let buffer113 = device0.createBuffer({
  size: 5067,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder164 = device0.createCommandEncoder({});
let textureView176 = texture70.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 2});
let computePassEncoder140 = commandEncoder164.beginComputePass();
let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true});
let renderBundle30 = renderBundleEncoder30.finish({});
try {
computePassEncoder103.end();
} catch {}
try {
commandEncoder97.copyBufferToBuffer(buffer2, 1024, buffer72, 948, 8);
} catch {}
try {
commandEncoder97.copyTextureToTexture({
  texture: texture76,
  mipLevel: 0,
  origin: {x: 2, y: 4, z: 0},
  aspect: 'all',
},
{
  texture: texture27,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer24, 268, new Float32Array(823), 46, 40);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder165 = device0.createCommandEncoder({});
let sampler91 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 14,
});
try {
computePassEncoder140.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup77);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer65, 'uint32', 8, 7);
} catch {}
try {
commandEncoder165.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture122,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise32 = device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  multisample: {mask: 0x332099f7},
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment7',
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 340,
        stepMode: 'instance',
        attributes: [{format: 'sint8x2', offset: 24, shaderLocation: 14}, {format: 'uint8x4', offset: 0, shaderLocation: 1}],
      },
      {
        arrayStride: 312,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 40, shaderLocation: 10},
          {format: 'uint8x4', offset: 136, shaderLocation: 12},
        ],
      },
    ],
  },
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup68);
} catch {}
try {
renderPassEncoder0.drawIndexed(16, 245, 60, 434_712_509, 1_296_859_674);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer16, 44);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(7, buffer111, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let recycledExplicitBindGroupLayout12 = pipeline5.getBindGroupLayout(0);
let texture154 = device0.createTexture({size: {width: 45}, dimension: '1d', format: 'rgba8unorm-srgb', usage: GPUTextureUsage.TEXTURE_BINDING});
let renderPassEncoder44 = commandEncoder165.beginRenderPass({
  colorAttachments: [{
  view: textureView67,
  clearValue: { r: -330.8, g: -865.6, b: 826.8, a: -750.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 106347549,
});
let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']});
let sampler92 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 97.92});
try {
renderPassEncoder0.drawIndexedIndirect(buffer87, 92);
} catch {}
try {
renderBundleEncoder31.setIndexBuffer(buffer102, 'uint32', 3_680, 347);
} catch {}
try {
renderBundleEncoder31.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(3, buffer39, 0);
} catch {}
try {
buffer16.unmap();
} catch {}
try {
commandEncoder97.copyTextureToTexture({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture93,
  mipLevel: 0,
  origin: {x: 64, y: 0, z: 0},
  aspect: 'all',
},
{width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder166 = device0.createCommandEncoder({});
let texture155 = device0.createTexture({
  size: [1035, 60, 11],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler93 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat'});
try {
computePassEncoder9.setBindGroup(3, bindGroup64, new Uint32Array(2084), 539, 0);
} catch {}
try {
renderPassEncoder28.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder0.draw(30, 325, 2, 19_902_114);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer62, 516);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(2, buffer109);
} catch {}
try {
renderBundleEncoder31.setBindGroup(1, bindGroup58);
} catch {}
try {
renderBundleEncoder31.setPipeline(pipeline11);
} catch {}
let buffer114 = device0.createBuffer({size: 205, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let textureView177 = texture64.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 5});
try {
computePassEncoder137.setBindGroup(2, bindGroup59, new Uint32Array(3522), 1_448, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup51, new Uint32Array(3549), 289, 0);
} catch {}
try {
renderPassEncoder0.end();
} catch {}
try {
renderPassEncoder21.setScissorRect(10, 0, 1, 0);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer29, 'uint16', 1_854, 2_262);
} catch {}
try {
renderBundleEncoder31.setPipeline(pipeline5);
} catch {}
try {
commandEncoder97.copyBufferToTexture({
  /* bytesInLastRow: 216 widthInBlocks: 54 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1068 */
  offset: 1068,
  bytesPerRow: 3328,
  buffer: buffer108,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 15, y: 5, z: 0},
  aspect: 'all',
}, {width: 54, height: 54, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture2.label = '\ucd67\u9583\u{1f609}\ue4de\u{1fa42}\ub411\u0dce\ue0c5\udd57\ud715\u9b5b';
} catch {}
let texture156 = device0.createTexture({
  size: [360, 1, 690],
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder45 = commandEncoder17.beginRenderPass({
  colorAttachments: [{
  view: textureView67,
  clearValue: { r: 297.5, g: -964.6, b: -386.2, a: -238.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet2,
});
try {
computePassEncoder96.setBindGroup(2, bindGroup35);
} catch {}
try {
renderPassEncoder43.setBindGroup(3, bindGroup59, new Uint32Array(4326), 553, 0);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer35, 'uint16', 1_632, 882);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
videoFrame0.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame6.close();
videoFrame7.close();
videoFrame8.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
videoFrame18.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
}

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

  let workers = [

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