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

async function window0() {
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float16-renderable',
    'float32-renderable',
    'core-features-and-limits',
    'timestamp-query',
  ],
  requiredLimits: {maxStorageBufferBindingSize: 136894040, maxUniformBufferBindingSize: 116605391},
});
let buffer0 = device0.createBuffer({size: 12, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
await gc();
let buffer1 = device0.createBuffer({size: 112, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder0 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: [180, 48, 1],
  mipLevelCount: 2,
  format: 'astc-10x8-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView0 = texture0.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder0 = commandEncoder0.beginComputePass();
let buffer2 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
buffer2.unmap();
} catch {}
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 133,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let commandEncoder1 = device0.createCommandEncoder({});
let textureView1 = texture0.createView({mipLevelCount: 1});
let commandEncoder2 = device0.createCommandEncoder();
let texture1 = device0.createTexture({
  size: {width: 180},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder1 = commandEncoder1.beginComputePass();
let buffer3 = device0.createBuffer({
  size: 96,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let sampler0 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 92.29,
  compare: 'never',
});
let sampler1 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 80.78,
});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer0.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(255).fill(50), /* required buffer size: 255 */
{offset: 255, rowsPerImage: 30}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout1 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0],
});
let texture2 = device0.createTexture({
  size: [64, 64, 88],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture3 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
commandEncoder2.clearBuffer(buffer3);
} catch {}
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let commandEncoder3 = device0.createCommandEncoder({});
let texture4 = device0.createTexture({
  size: {width: 22},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView2 = texture3.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture5 = device0.createTexture({
  size: {width: 7},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture6 = device0.createTexture({
  size: {width: 7},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true});
let offscreenCanvas0 = new OffscreenCanvas(103, 112);
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  label: '\u39f9\u{1f827}',
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 591,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let commandEncoder4 = device0.createCommandEncoder({});
let texture7 = device0.createTexture({
  size: [1, 540, 93],
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture8 = device0.createTexture({size: [7], dimension: '1d', format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST});
let textureView3 = texture8.createView({});
let computePassEncoder2 = commandEncoder2.beginComputePass();
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
globalThis.someLabel = commandEncoder2.label;
} catch {}
let texture9 = device0.createTexture({
  size: [90],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let imageData0 = new ImageData(40, 172);
let texture10 = device0.createTexture({
  size: [1, 540, 32],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture11 = device0.createTexture({
  size: [1, 1080, 20],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let offscreenCanvas1 = new OffscreenCanvas(162, 31);
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 591,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let textureView4 = texture5.createView({arrayLayerCount: 1});
let textureView5 = texture10.createView({mipLevelCount: 1});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder1.setVertexBuffer(7, buffer3, 0, 4);
} catch {}
let promise0 = device0.queue.onSubmittedWorkDone();
let texture12 = device0.createTexture({
  size: [150, 1, 186],
  mipLevelCount: 3,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let promise1 = device0.queue.onSubmittedWorkDone();
let commandEncoder5 = device0.createCommandEncoder({});
let sampler2 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 53.44, compare: 'less-equal'});
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint16', 2, 3);
} catch {}
try {
renderBundleEncoder0.insertDebugMarker('\ua20f');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer4 = device0.createBuffer({size: 92, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder6 = device0.createCommandEncoder();
let texture13 = device0.createTexture({
  size: [15, 1, 29],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture14 = device0.createTexture({
  size: {width: 75, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder3 = commandEncoder3.beginComputePass();
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let buffer5 = device0.createBuffer({size: 52, usage: GPUBufferUsage.UNIFORM});
let textureView6 = texture12.createView({dimension: '2d', format: 'rgb10a2uint', mipLevelCount: 1, baseArrayLayer: 53});
try {
renderBundleEncoder1.setVertexBuffer(5, buffer4, 0, 11);
} catch {}
try {
commandEncoder5.copyTextureToTexture({
  texture: texture14,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let texture15 = device0.createTexture({
  size: [30, 1, 11],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 0, new Uint32Array(1324).map((_, i) => i * 8), 272, 4);
} catch {}
let textureView7 = texture15.createView({});
let computePassEncoder4 = commandEncoder6.beginComputePass();
try {
renderBundleEncoder2.setIndexBuffer(buffer0, 'uint16', 2, 3);
} catch {}
try {
commandEncoder4.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 96 */
  offset: 96,
  buffer: buffer1,
}, {
  texture: texture10,
  mipLevel: 2,
  origin: {x: 0, y: 2, z: 1},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder7 = device0.createCommandEncoder({});
let textureView8 = texture7.createView({});
let computePassEncoder5 = commandEncoder4.beginComputePass();
try {
buffer4.unmap();
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext0 = offscreenCanvas1.getContext('webgpu');
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 100,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 515,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 529,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let bindGroup0 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 591, resource: textureView6},
    {binding: 8, resource: textureView7},
    {binding: 56, resource: textureView1},
    {binding: 1, resource: textureView4},
  ],
});
let buffer6 = device0.createBuffer({size: 160, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
try {
renderBundleEncoder1.setVertexBuffer(0, buffer4, 4, 24);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(344).fill(43), /* required buffer size: 344 */
{offset: 344}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder8 = device0.createCommandEncoder({});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let texture16 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 52},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
offscreenCanvas0.getContext('bitmaprenderer');
} catch {}
let bindGroup1 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 1, resource: textureView4},
    {binding: 8, resource: textureView7},
    {binding: 591, resource: textureView6},
    {binding: 56, resource: textureView0},
  ],
});
let pipelineLayout3 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout0],
});
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 4, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(3, buffer4, 0, 41);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 12, new Float32Array(7943).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.8139)), 3534, 0);
} catch {}
let textureView9 = texture12.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 59});
let computePassEncoder6 = commandEncoder5.beginComputePass();
try {
commandEncoder9.copyTextureToTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 591, resource: textureView6},
    {binding: 56, resource: textureView0},
    {binding: 8, resource: textureView7},
    {binding: 1, resource: textureView4},
  ],
});
let commandEncoder10 = device0.createCommandEncoder({});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
let imageData1 = new ImageData(24, 8);
let commandEncoder11 = device0.createCommandEncoder({});
let computePassEncoder7 = commandEncoder11.beginComputePass();
try {
buffer3.unmap();
} catch {}
let videoFrame0 = new VideoFrame(offscreenCanvas1, {timestamp: 0});
let buffer7 = device0.createBuffer({size: 19852, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder12 = device0.createCommandEncoder({});
let sampler3 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 61.39,
  maxAnisotropy: 7,
});
try {
renderBundleEncoder1.setIndexBuffer(buffer6, 'uint16', 0, 68);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let commandEncoder13 = device0.createCommandEncoder({});
let texture17 = device0.createTexture({
  size: {width: 7, height: 1, depthOrArrayLayers: 71},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderBundleEncoder2.setBindGroup(1, bindGroup1, []);
} catch {}
try {
commandEncoder7.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1376 */
  offset: 1376,
  bytesPerRow: 6400,
  buffer: buffer7,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder0.insertDebugMarker('\u31d2');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 3_344, new Uint32Array(354).map((_, i) => i * 1), 31);
} catch {}
let buffer8 = device0.createBuffer({size: 28, usage: GPUBufferUsage.STORAGE});
let commandEncoder14 = device0.createCommandEncoder({});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(302_102).fill(157), /* required buffer size: 302_102 */
{offset: 214, bytesPerRow: 64, rowsPerImage: 53}, {width: 13, height: 0, depthOrArrayLayers: 90});
} catch {}
let commandEncoder15 = device0.createCommandEncoder({});
try {
device0.queue.writeBuffer(buffer3, 36, new Uint32Array(29413).map((_, i) => i * 3), 163, 0);
} catch {}
let videoFrame1 = new VideoFrame(offscreenCanvas0, {timestamp: 0});
let buffer9 = device0.createBuffer({size: 68, usage: GPUBufferUsage.INDIRECT});
let textureView10 = texture6.createView({baseMipLevel: 0});
try {
computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(355), 92, 0);
} catch {}
let bindGroup3 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 56, resource: textureView1},
    {binding: 591, resource: textureView9},
    {binding: 1, resource: textureView10},
    {binding: 8, resource: textureView7},
  ],
});
let commandEncoder16 = device0.createCommandEncoder({});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 11});
let texture18 = device0.createTexture({
  size: {width: 30},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm']});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(71).fill(233), /* required buffer size: 71 */
{offset: 71, bytesPerRow: 9}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup4 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 56, resource: textureView1},
    {binding: 8, resource: textureView7},
    {binding: 1, resource: textureView4},
    {binding: 591, resource: textureView6},
  ],
});
let commandEncoder17 = device0.createCommandEncoder({});
let textureView11 = texture0.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder2.setBindGroup(3, bindGroup4);
} catch {}
try {
commandEncoder16.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1420 */
  offset: 1420,
  bytesPerRow: 67072,
  buffer: buffer7,
}, {
  texture: texture14,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder8 = commandEncoder16.beginComputePass();
try {
computePassEncoder4.end();
} catch {}
try {
buffer8.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
let commandEncoder18 = device0.createCommandEncoder({});
let sampler4 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 36.78});
try {
renderBundleEncoder0.setBindGroup(2, bindGroup2);
} catch {}
try {
commandEncoder14.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 128 */
  offset: 128,
  bytesPerRow: 22272,
  rowsPerImage: 190,
  buffer: buffer7,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup4);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 28, new Uint32Array(3820).map((_, i) => i * 8), 364, 4);
} catch {}
try {
  await promise1;
} catch {}
let buffer10 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST});
let texture19 = device0.createTexture({
  size: [75, 1, 46],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder4.setIndexBuffer(buffer6, 'uint32', 8, 8);
} catch {}
try {
commandEncoder17.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1176 */
  offset: 1176,
  rowsPerImage: 433,
  buffer: buffer7,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer10, 12, new Uint32Array(17252).map((_, i) => i * 7), 240, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: videoFrame0,
  origin: { x: 6, y: 1 },
  flipY: false,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 591,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let commandEncoder19 = device0.createCommandEncoder({});
let textureView12 = texture8.createView({});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder5.setVertexBuffer(5, buffer4, 4, 0);
} catch {}
try {
commandEncoder12.copyBufferToBuffer(buffer7, 3920, buffer10, 16, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: offscreenCanvas0,
  origin: { x: 14, y: 11 },
  flipY: true,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder20 = device0.createCommandEncoder({});
let texture20 = device0.createTexture({
  size: {width: 37, height: 1, depthOrArrayLayers: 77},
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
commandEncoder7.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 784 */
  offset: 784,
  bytesPerRow: 16128,
  buffer: buffer7,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder21 = device0.createCommandEncoder({});
let texture21 = device0.createTexture({
  size: [1],
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView13 = texture0.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder7.setBindGroup(0, bindGroup2, new Uint32Array(317), 9, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup2);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
device0.label = '\u0e88\u06ee\u72c5\u0aa2\u{1ffb7}\u7ec9\u0304\u8ee1\u08d5\u70d3';
} catch {}
let buffer11 = device0.createBuffer({size: 68, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture22 = device0.createTexture({
  size: {width: 7, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView14 = texture6.createView({arrayLayerCount: 1});
try {
commandEncoder9.copyBufferToBuffer(buffer1, 24, buffer3, 4, 0);
} catch {}
let buffer12 = device0.createBuffer({size: 308, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let texture23 = device0.createTexture({
  size: [45, 12, 24],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder6.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup0, new Uint32Array(182), 24, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer11, 'uint32', 0, 8);
} catch {}
let texture24 = device0.createTexture({
  size: {width: 1},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder9 = commandEncoder19.beginComputePass();
try {
computePassEncoder5.setBindGroup(1, bindGroup1, new Uint32Array(2632), 7, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer11, 'uint16', 6, 5);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
commandEncoder7.resolveQuerySet(querySet0, 1, 0, buffer3, 0);
} catch {}
let commandEncoder22 = device0.createCommandEncoder({label: '\uba2f\u7231'});
let sampler5 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat'});
let buffer13 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let commandEncoder23 = device0.createCommandEncoder({});
try {
renderBundleEncoder5.setVertexBuffer(4, buffer4, 4, 48);
} catch {}
try {
commandEncoder12.copyTextureToTexture({
  texture: texture11,
  mipLevel: 1,
  origin: {x: 0, y: 9, z: 1},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 1,
  origin: {x: 0, y: 9, z: 0},
  aspect: 'all',
},
{width: 0, height: 52, depthOrArrayLayers: 0});
} catch {}
let bindGroup5 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 56, resource: textureView1},
    {binding: 1, resource: textureView4},
    {binding: 591, resource: textureView6},
    {binding: 8, resource: textureView7},
  ],
});
let commandBuffer0 = commandEncoder6.finish();
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm']});
let sampler6 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 62.54,
  maxAnisotropy: 7,
});
try {
computePassEncoder3.setBindGroup(2, bindGroup3, []);
} catch {}
let imageData2 = new ImageData(84, 24);
let commandEncoder24 = device0.createCommandEncoder({});
let textureView15 = texture5.createView({});
let computePassEncoder10 = commandEncoder14.beginComputePass();
let bindGroup6 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 591, resource: textureView9},
    {binding: 1, resource: textureView15},
    {binding: 56, resource: textureView0},
    {binding: 8, resource: textureView7},
  ],
});
let buffer14 = device0.createBuffer({size: 97, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let commandEncoder25 = device0.createCommandEncoder({});
try {
renderBundleEncoder3.setBindGroup(2, bindGroup5);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 8, new Uint16Array(12010).map((_, i) => i + 2), 4020, 0);
} catch {}
try {
  await promise2;
} catch {}
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 591, resource: textureView9},
    {binding: 8, resource: textureView7},
    {binding: 1, resource: textureView4},
    {binding: 56, resource: textureView0},
  ],
});
let commandEncoder26 = device0.createCommandEncoder({});
let textureView16 = texture9.createView({baseArrayLayer: 0});
let texture25 = device0.createTexture({
  size: [60, 1, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView17 = texture19.createView({format: 'bgra8unorm', baseArrayLayer: 3, arrayLayerCount: 3});
try {
renderBundleEncoder3.setBindGroup(0, bindGroup1);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer6, 'uint32', 16, 26);
} catch {}
let texture26 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder5.setBindGroup(2, bindGroup2, new Uint32Array(383), 20, 0);
} catch {}
let computePassEncoder11 = commandEncoder26.beginComputePass();
try {
computePassEncoder8.setBindGroup(2, bindGroup0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let texture27 = device0.createTexture({
  size: {width: 7},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder1.setBindGroup(2, bindGroup4);
} catch {}
try {
renderBundleEncoder6.setBindGroup(2, bindGroup3);
} catch {}
let bindGroup8 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 8, resource: textureView7},
    {binding: 1, resource: textureView14},
    {binding: 56, resource: textureView1},
    {binding: 591, resource: textureView9},
  ],
});
let textureView18 = texture2.createView({});
try {
buffer10.unmap();
} catch {}
try {
commandEncoder17.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 180 */
  offset: 180,
  bytesPerRow: 4096,
  rowsPerImage: 2218,
  buffer: buffer7,
}, {
  texture: texture25,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 7_396, new DataView(new Uint8Array(5286).map((_, i) => i).buffer), 2490);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture28 = device0.createTexture({
  size: {width: 22, height: 6, depthOrArrayLayers: 1},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true});
try {
renderBundleEncoder6.setIndexBuffer(buffer0, 'uint16', 10, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(7, buffer0, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 3104 */
  offset: 3104,
  bytesPerRow: 2816,
  buffer: buffer7,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 60, y: 0, z: 0},
  aspect: 'all',
}, {width: 30, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder2.pushDebugGroup('\u231d');
} catch {}
try {
adapter0.label = '\u0c61\u{1face}\u{1ffe7}\u166e\u133c';
} catch {}
let bindGroup9 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: textureView15},
    {binding: 591, resource: textureView9},
    {binding: 56, resource: textureView1},
    {binding: 8, resource: textureView7},
  ],
});
let querySet1 = device0.createQuerySet({type: 'timestamp', count: 1335});
let textureView19 = texture26.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm']});
try {
computePassEncoder5.setBindGroup(0, bindGroup1);
} catch {}
try {
commandEncoder15.resolveQuerySet(querySet1, 56, 7, buffer12, 0);
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

struct T2 {
  @align(32) @size(128) f0: atomic<u32>,
  f1: array<array<atomic<u32>, 1>>,
}

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

/* zero global variables used */
fn fn1(a0: ptr<storage, T5, read>, a1: vec2i) {
  {
  while bool(firstLeadingBit(vec4i(unconst_i32(34016788), unconst_i32(577069947), unconst_i32(244126001), unconst_i32(45569931))).r) {
  _ = fn0();
}
}
  _ = fn0();
  _ = fn0();
  let vf2: vec4f = (unconst_f32(0.1817) + vec4f( !vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false), unconst_bool(false))));
}

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

@group(0) @binding(133) var<storage, read> buffer15: array<T5>;

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

@group(1) @binding(133) var<storage, read> buffer16: array<T5>;

struct T4 {
  f0: array<vec4h>,
}

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

/* zero global variables used */
fn fn0() -> array<array<bool, 51>, 1> {
  var out: array<array<bool, 51>, 1>;
  let vf0: i32 = dot4I8Packed(unconst_u32(196447646), unconst_u32(445309581));
  let vf1: i32 = dot4I8Packed(unconst_u32(1050131485), unconst_u32(731961562));
  out[0][unconst_u32(87195638)] = any((vec2u(unconst_u32(912779347), unconst_u32(169099320)) <= vec2u(unconst_u32(1826154156), unconst_u32(612086114))));
  return out;
}

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

struct T1 {
  @size(284) f0: i32,
}

struct T6 {
  f0: array<u32>,
}

struct T3 {
  f0: array<u32>,
}

/* zero global variables used */
fn fn2() -> array<vec4i, 1> {
  var out: array<vec4i, 1>;
  let ptr0: ptr<function, vec4i> = &out[unconst_u32(657473555)];
  let ptr1: ptr<function, vec4i> = &(*ptr0);
  out[unconst_u32(77946428)] |= vec4i((*ptr0)[unconst_u32(479308261)]);
  let ptr2: ptr<function, vec4i> = &out[unconst_u32(649317648)];
  out[unconst_u32(886122905)] ^= out[unconst_u32(70805560)];
  for (var jj53=0u; jj53<3; jj53++) { out[jj53] = vec4i(out[unconst_u32(775208416)][unconst_u32(352445595)]); }
  return out;
}

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

/* zero global variables used */
fn fn4() -> f16 {
  var out: f16;
  var vf4: vec2u = (vec2u(unconst_u32(982949025), unconst_u32(208673024)) & vec2u(unconst_u32(83221403), unconst_u32(3390752)));
  out *= f16(any((vec4f(unconst_f32(0.00669), unconst_f32(0.02837), unconst_f32(0.08102e25), unconst_f32(0.3797e-37)) >= unpack4x8snorm(vf4[unconst_u32(59026669)]))));
  let vf5: f32 = step(unconst_f32(0.00466), f32(max(bitcast<i32>(abs(vec2u(pack4xI8Clamp(vec4i(unconst_i32(622246296), unconst_i32(12510308), unconst_i32(456551234), unconst_i32(-112237481)))))[0]), unconst_i32(1477324145))));
  out -= sqrt(vec4h(f16(vf5)))[1];
  out = f16(dot(vec3f(f32(pack2x16snorm(vec2f(unconst_f32(0.1570e2), unconst_f32(0.9080e-7))))), vec3f(unconst_f32(0.00574e35), unconst_f32(0.01726e12), unconst_f32(0.2957))));
  while bool(radians(unconst_f16(1952.1))) {
  out = out;
  loop {
  out = vec2h(log(vec2f(unconst_f32(0.06368), unconst_f32(0.2951e37))).yx.rr)[0];
  switch pack2x16snorm(vec2f(unconst_f32(-0.5844), unconst_f32(0.09343e-17))) { 
  default {
  out += vec4h(sinh(vec4f(unconst_f32(0.06915), unconst_f32(0.01259), unconst_f32(0.03417e8), unconst_f32(0.08707e-44)))).a;
  break;
}
  }
  var vf6: mat4x2f = transpose(mat2x4f(unconst_f32(0.1014), unconst_f32(0.4114), unconst_f32(0.1347), unconst_f32(0.1083e2), unconst_f32(0.01160), unconst_f32(0.07044e8), unconst_f32(-0.3831e0), unconst_f32(0.1414)));
  break;
}
  out = sin(vec4h(unconst_f16(2413.0), unconst_f16(6817.8), unconst_f16(8196.3), unconst_f16(4681.4))).x;
  var vf7: vec3u = countOneBits(vec3u(unconst_u32(6691913), unconst_u32(20850293), unconst_u32(216786730)));
  let ptr4: ptr<function, vec3u> = &vf7;
  return out;
}
  let vf8: vec3h = tan(vec3h(f16(vf4[unconst_u32(227400722)])));
  out = f16(sqrt(bitcast<vec3f>(abs(vec2u(unconst_u32(505423340), unconst_u32(404792524))).rgg))[1]);
  return out;
}

struct T5 {
  @size(896) f0: T1,
}

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

/* used global variables: buffer15, buffer16 */
fn fn3(a0: vec4u, a1: ptr<function, array<bool, 1>>) -> vec2<bool> {
  var out: vec2<bool>;
  let ptr3: ptr<storage, T1, read> = &(*&buffer16)[arrayLength(&(*&buffer16))].f0;
  (*a1)[u32((*&buffer16)[unconst_i32(152813087)].f0.f0)] = bool((*&buffer15)[arrayLength(&(*&buffer15))].f0.f0);
  for (var jj71=0u; jj71<3; jj71++) { (*a1)[jj71] = bool(radians(vec4h(unconst_f16(4424.5), unconst_f16(18489.9), unconst_f16(29977.8), unconst_f16(-403.3)))[0]); }
  out = vec2<bool>((unconst_f16(2527.6) < unconst_f16(27087.2)));
  fn0();
  _ = fn0();
  let vf3: u32 = arrayLength(&(*&buffer16));
  return out;
  _ = buffer15;
  _ = buffer16;
}

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

/* used global variables: buffer15, buffer16 */
@compute @workgroup_size(1, 2, 2)
fn compute0(a0: ComputeInput0, a1: ComputeInput1, a2: ComputeInput2) {
  loop {
  break;
}
  let ptr5: ptr<storage, T5, read> = &(*&buffer15)[unconst_i32(1174891375)];
  let vf9: u32 = a0.num_workgroups[unconst_u32(196450928)];
  fn0();
  fn1(&(*ptr5), vec2i(i32(arrayLength(&(*&buffer15)))));
  let ptr6: ptr<storage, T1, read> = &buffer16[unconst_u32(132048515)].f0;
  _ = buffer15;
  _ = buffer16;
}`,
});
let bindGroup10 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 56, resource: textureView1},
    {binding: 8, resource: textureView7},
    {binding: 1, resource: textureView10},
    {binding: 591, resource: textureView9},
  ],
});
let buffer17 = device0.createBuffer({size: 48, usage: GPUBufferUsage.VERTEX});
let commandEncoder27 = device0.createCommandEncoder({});
let texture29 = device0.createTexture({
  size: {width: 180, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder6.setBindGroup(3, bindGroup6, new Uint32Array(260), 89, 0);
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]});
let buffer18 = device0.createBuffer({size: 184, usage: GPUBufferUsage.INDEX});
try {
renderBundleEncoder2.setBindGroup(0, bindGroup7, new Uint32Array(257), 21, 0);
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 100,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 515,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 529,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer19 = device0.createBuffer({size: 253, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder28 = device0.createCommandEncoder({});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm']});
try {
commandEncoder8.resolveQuerySet(querySet0, 0, 1, buffer12, 0);
} catch {}
try {
commandEncoder24.pushDebugGroup('\uaece');
} catch {}
let commandEncoder29 = device0.createCommandEncoder({});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], sampleCount: 1, stencilReadOnly: true});
let sampler7 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 76.22,
});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder9.setBindGroup(2, bindGroup3);
} catch {}
let commandEncoder30 = device0.createCommandEncoder({});
try {
computePassEncoder2.setBindGroup(1, bindGroup4);
} catch {}
try {
computePassEncoder2.setBindGroup(1, bindGroup3, new Uint32Array(213), 12, 0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
commandEncoder8.copyBufferToBuffer(buffer7, 1216, buffer10, 32, 0);
} catch {}
try {
commandEncoder29.copyTextureToTexture({
  texture: texture18,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture30 = device0.createTexture({
  size: [75, 1, 97],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder12 = commandEncoder17.beginComputePass();
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true});
try {
buffer3.unmap();
} catch {}
try {
commandEncoder24.popDebugGroup();
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: videoFrame0,
  origin: { x: 25, y: 3 },
  flipY: true,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let textureView20 = texture26.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], stencilReadOnly: true});
try {
device0.queue.writeBuffer(buffer7, 492, new BigInt64Array(4229).map((_, i) => BigInt(i - 2)), 571, 60);
} catch {}
let buffer20 = device0.createBuffer({
  size: 12,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder31 = device0.createCommandEncoder();
let textureView21 = texture9.createView({dimension: '1d', arrayLayerCount: 1});
try {
buffer9.unmap();
} catch {}
try {
commandEncoder27.insertDebugMarker('\ub9ea');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 4_944, new Uint32Array(1177).map((_, i) => i * 6), 724, 96);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder32 = device0.createCommandEncoder({});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: videoFrame1,
  origin: { x: 28, y: 88 },
  flipY: true,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer21 = device0.createBuffer({size: 240, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder33 = device0.createCommandEncoder({});
let computePassEncoder13 = commandEncoder33.beginComputePass({timestampWrites: {querySet: querySet1}});
try {
computePassEncoder5.setBindGroup(3, bindGroup9, new Uint32Array(1609), 364, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(1, buffer0, 0);
} catch {}
try {
  await promise0;
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 591,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let buffer22 = device0.createBuffer({size: 636, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let computePassEncoder14 = commandEncoder12.beginComputePass();
try {
computePassEncoder10.setBindGroup(2, bindGroup2, new Uint32Array(1351), 627, 0);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer19, 'uint32', 20, 10);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(6, buffer4, 0, 61);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder9.insertDebugMarker('\u1a98');
} catch {}
offscreenCanvas1.height = 1879;
let commandEncoder34 = device0.createCommandEncoder({});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
buffer1.label = '\u4965\uc687\uee7a\ua269\uaf67\u34d0\udfdb';
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

/* zero global variables used */
fn fn0() -> array<f16, 1> {
  var out: array<f16, 1>;
  var vf10: vec2i =  ~vec2i(unconst_i32(197945534), unconst_i32(218678378));
  var vf11: bool = (unconst_bool(true) && bool(acos(vec4h(unconst_f16(15366.6), unconst_f16(-25035.2), unconst_f16(5093.8), unconst_f16(-7193.6))).a));
  var vf12: vec4i = countLeadingZeros(vec4i(override0));
  vf10 =  ~vec2i(unconst_i32(245053450), unconst_i32(156707465));
  var vf13: vec3u = insertBits(vec3u(unconst_u32(889426444), unconst_u32(314181678), unconst_u32(1025409309)), vec3u(unconst_u32(335749758), unconst_u32(687285569), unconst_u32(305598023)), unconst_u32(705565848), unconst_u32(50723863));
  out[unconst_u32(719021579)] -= f16(vf11);
  switch bitcast<u32>(log(vec2h(unconst_f16(2988.8), unconst_f16(5866.3)))) { 
  default: {
  var vf14: f16 = length(vec3h(normalize(vec3f(unconst_f32(0.00526e1), unconst_f32(0.02391), unconst_f32(0.06068))).xzy.zyz.ggg.grb));
  vf14 = out[0];
  loop {
  out[unconst_u32(647728562)] += f16( !unconst_bool(false));
  break;
}
  out[unconst_u32(653580881)] += f16(atan2(unconst_f32(0.1642e31), unconst_f32(0.03440)));
  var vf15: f32 = atan2(vec4f(unpack4xU8(unconst_u32(1803103119)).bgaa).r, unconst_f32(0.01752e13));
  vf14 = smoothstep(unconst_f16(5440.5), unconst_f16(7170.1), out[unconst_u32(210192196)]);
  break;
}
  }
  vf13 = vec3u(u32(vf11));
  return out;
  _ = override0;
}

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

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

struct VertexInput2 {
  @location(12) @interpolate(flat) location_12: u32,
}

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

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

struct VertexInput6 {
  @builtin(instance_index) instance_index: u32,
}

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

struct VertexInput0 {
  @location(10) location_10: vec4f,
  @location(5) location_5: i32,
}

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

struct VertexInput4 {
  @location(3) location_3: f16,
}

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

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

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

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

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

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

@id(28210) override override0: i32;

struct VertexInput1 {
  @location(7) location_7: vec4i,
  @location(6) location_6: vec4f,
  @location(14) @interpolate(flat, center) location_14: vec2u,
  @location(11) location_11: f16,
  @location(0) @interpolate(flat) location_0: vec4h,
  @location(8) @interpolate(linear) location_8: vec2f,
  @location(9) location_9: vec2h,
  @location(1) location_1: i32,
  @location(15) location_15: vec2i,
  @location(13) location_13: vec4h,
}

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

/* zero global variables used */
fn fn1(a0: array<array<i32, 26>, 1>) {
  var vf16 = fn0();
  var vf17 = fn0();
  var vf18 = fn0();
  loop {
  var vf19 = fn0();
  vf19[unconst_u32(632297094)] = f16(pack4x8unorm(vec4f(unconst_f32(-0.3162), unconst_f32(0.1430), unconst_f32(0.1114e31), unconst_f32(0.00271))));
  vf19[pack4xI8(vec4i(bitcast<i32>(pack4x8unorm(vec4f(unconst_f32(0.1078), unconst_f32(0.01208e0), unconst_f32(0.1182), unconst_f32(-0.6244))))))] = (vec3h(log(vec2f(unconst_f32(0.01384e29), unconst_f32(0.3434))).ggr) * mat2x3h(unconst_f16(1593.5), unconst_f16(19077.9), unconst_f16(8116.6), unconst_f16(33835.8), unconst_f16(16494.7), unconst_f16(14345.4))).x;
  break;
  _ = override0;
}
  var vf20 = fn0();
  vf17[0] += f16((unconst_bool(true) && unconst_bool(true)));
  vf17[unconst_u32(1204724426)] = vec3h((vec3i(unconst_i32(70952028), unconst_i32(1608299972), unconst_i32(34711808)) > vec3i(unconst_i32(391338829), unconst_i32(359643932), unconst_i32(10420660)))).r;
  vf18[unconst_u32(621180388)] *= vf17[0];
  let vf21: vec4i = unpack4xI8(unconst_u32(691008751));
  let vf22: i32 = a0[unconst_u32(78829425)][25];
  fn0();
  _ = override0;
}

struct VertexInput3 {
  @location(4) location_4: u32,
}

@group(0) @binding(133) var<storage, read> buffer23: array<array<array<array<ComputeInput3, 7>, 1>, 32>>;

@group(1) @binding(133) var<storage, read> buffer24: array<array<array<f16, 1>, 448>>;

/* zero global variables used */
@vertex
fn vertex0(a0: VertexInput0, @location(2) location_2: vec2h, a2: VertexInput1, a3: VertexInput2, a4: VertexInput3, a5: VertexInput4, a6: VertexInput5, a7: VertexInput6) -> VertexOutput0 {
  var out: VertexOutput0;
  var vf23: u32 = a6.vertex_index;
  return out;
}

/* used global variables: buffer23, buffer24 */
@compute @workgroup_size(1, 1, 1)
fn compute1(a0: ComputeInput3, @builtin(global_invocation_id) global_invocation_id: vec3u) {
  let ptr7: ptr<storage, u32, read> = &(*&buffer23)[unconst_u32(15226810)][unconst_u32(553570849)][unconst_u32(5093040)][6].local_invocation_index;
  while bool(buffer23[unconst_u32(1951713526)][31][0][6].local_invocation_index) {
  let ptr8: ptr<storage, f16, read> = &buffer24[unconst_u32(52347364)][447][unconst_u32(264694891)];
  _ = buffer24;
}
  _ = fn0();
  let ptr9: ptr<storage, u32, read> = &buffer23[(*&buffer23)[unconst_u32(335320735)][unconst_u32(1111373630)][0][6].local_invocation_index][31][unconst_u32(362605041)][6].local_invocation_index;
  if bool((*&buffer23)[arrayLength(&(*&buffer23))][31][0][unconst_u32(257232202)].local_invocation_index) {
  if bool(cosh(vec2h(unconst_f16(1504.5), unconst_f16(5100.3)))[1]) {
  _ = fn0();
  _ = override0;
}
  _ = override0;
}
  let ptr10: ptr<storage, f16, read> = &buffer24[unconst_u32(260969196)][447][(*&buffer23)[unconst_u32(177687776)][unconst_u32(1134269848)][unconst_u32(203032228)][6].local_invocation_index];
  _ = override0;
  _ = buffer24;
  _ = buffer23;
}

/* used global variables: buffer24 */
@compute @workgroup_size(1, 2, 1)
fn compute2(a0: ComputeInput4, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u, a4: ComputeInput5) {
  let ptr11: ptr<storage, array<f16, 1>, read> = &(*&buffer24)[u32((*&buffer24)[arrayLength(&(*&buffer24))][447][0])][unconst_u32(502479875)];
  let vf24: f16 = smoothstep(unconst_f16(22848.4), unconst_f16(105.0), unconst_f16(7881.6));
  let ptr12: ptr<storage, array<array<array<f16, 1>, 448>>, read> = &(*&buffer24);
  _ = buffer24;
}`,
});
let bindGroup11 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 1, resource: textureView4},
    {binding: 56, resource: textureView1},
    {binding: 8, resource: textureView7},
    {binding: 591, resource: textureView6},
  ],
});
let commandEncoder35 = device0.createCommandEncoder({});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 100,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 515,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 529,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer25 = device0.createBuffer({size: 260, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder36 = device0.createCommandEncoder({});
let texture31 = device0.createTexture({
  size: {width: 150, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder7.setBindGroup(1, bindGroup4, new Uint32Array(812), 238, 0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer11, 'uint16', 2, 2);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer3);
} catch {}
let texture32 = device0.createTexture({
  size: {width: 30},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder8.setBindGroup(2, bindGroup8, []);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(4, buffer12);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 16, new DataView(new Uint8Array(3242).map((_, i) => i).buffer), 1917, 0);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
let texture33 = device0.createTexture({size: [1], dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.COPY_SRC});
let textureView22 = texture5.createView({});
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 0, 3);
} catch {}
try {
commandEncoder13.pushDebugGroup('\u07ce');
} catch {}
try {
renderBundleEncoder13.insertDebugMarker('\ud92a');
} catch {}
let commandEncoder37 = device0.createCommandEncoder({});
try {
computePassEncoder2.setBindGroup(1, bindGroup3, new Uint32Array(4679), 24, 0);
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 8, resource: textureView18},
    {binding: 1, resource: textureView4},
    {binding: 591, resource: textureView6},
    {binding: 56, resource: textureView0},
  ],
});
let buffer26 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder6.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup0, new Uint32Array(452), 342, 0);
} catch {}
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], stencilReadOnly: true});
try {
computePassEncoder7.setBindGroup(0, bindGroup4, new Uint32Array(53), 0, 0);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup0, new Uint32Array(2615), 18, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer18, 'uint16', 20, 55);
} catch {}
await gc();
let texture34 = device0.createTexture({
  size: {width: 90},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
commandEncoder30.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 4448 */
  offset: 4448,
  bytesPerRow: 3328,
  buffer: buffer7,
}, {
  texture: texture25,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder9.resolveQuerySet(querySet1, 1218, 3, buffer22, 256);
} catch {}
try {
  await promise3;
} catch {}
let texture35 = device0.createTexture({
  size: [1],
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder8.setIndexBuffer(buffer19, 'uint32', 216, 2);
} catch {}
try {
renderBundleEncoder2.popDebugGroup();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
let commandEncoder38 = device0.createCommandEncoder();
let textureView23 = texture0.createView({format: 'astc-10x8-unorm', mipLevelCount: 1});
try {
renderBundleEncoder6.setVertexBuffer(3, buffer7, 3_684, 580);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer13, 8, new Uint32Array(10848).map((_, i) => i * 5), 1312, 0);
} catch {}
let bindGroup13 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 1, resource: textureView15},
    {binding: 8, resource: textureView7},
    {binding: 56, resource: textureView23},
    {binding: 591, resource: textureView6},
  ],
});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let buffer27 = device0.createBuffer({size: 252, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let sampler8 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 12,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer0, 'uint16', 4, 0);
} catch {}
let pipeline0 = device0.createComputePipeline({
  layout: pipelineLayout1,
  compute: {module: shaderModule1, entryPoint: 'compute1', constants: {28_210: 1}},
});
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 133,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder39 = device0.createCommandEncoder();
try {
computePassEncoder2.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 8, resource: textureView7},
    {binding: 1, resource: textureView16},
    {binding: 591, resource: textureView9},
    {binding: 56, resource: textureView23},
  ],
});
let buffer28 = device0.createBuffer({size: 199, usage: GPUBufferUsage.STORAGE});
let commandEncoder40 = device0.createCommandEncoder();
try {
renderBundleEncoder14.setVertexBuffer(6, buffer20);
} catch {}
let commandEncoder41 = device0.createCommandEncoder({});
let textureView24 = texture18.createView({});
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
let buffer29 = device0.createBuffer({
  size: 136,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder42 = device0.createCommandEncoder();
let textureView25 = texture12.createView({mipLevelCount: 1, baseArrayLayer: 24, arrayLayerCount: 8});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: videoFrame1,
  origin: { x: 20, y: 2 },
  flipY: false,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let textureView26 = texture12.createView({format: 'rgb10a2uint', mipLevelCount: 1, baseArrayLayer: 22, arrayLayerCount: 2});
try {
commandEncoder13.popDebugGroup();
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer20, 'uint16', 2, 3);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(2, buffer0, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(8_578).fill(1), /* required buffer size: 8_578 */
{offset: 82, bytesPerRow: 72, rowsPerImage: 59}, {width: 2, height: 0, depthOrArrayLayers: 3});
} catch {}
let promise5 = device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule0, entryPoint: 'compute0'}});
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
computePassEncoder6.setBindGroup(3, bindGroup12, []);
} catch {}
try {
computePassEncoder3.setBindGroup(0, bindGroup9, new Uint32Array(1401), 25, 0);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer6, 'uint16', 86, 1);
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 264 */
  offset: 264,
  rowsPerImage: 236,
  buffer: buffer7,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte170m', transfer: 'iec61966-2-1'} });
let buffer30 = device0.createBuffer({size: 36, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let commandEncoder43 = device0.createCommandEncoder();
let textureView27 = texture32.createView({});
let texture36 = device0.createTexture({
  size: [7, 1, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 8, new Float32Array(878).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.1452)), 87, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 150, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 1, y: 24 },
  flipY: false,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture37 = device0.createTexture({
  size: {width: 1},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView28 = texture14.createView({format: 'bgra8unorm', mipLevelCount: 1});
try {
computePassEncoder11.setBindGroup(2, bindGroup6, new Uint32Array(498), 36, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 4, new Uint32Array(3358).map((_, i) => i * 8), 103, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer20, 0, 0);
} catch {}
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 133,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let buffer31 = device0.createBuffer({
  label: '\u0398\u{1fd49}\u0692\u5a01\u9535\u00c3\u5d15\u0a79\u19b3',
  size: 48,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder44 = device0.createCommandEncoder({});
let texture38 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(1, buffer27, 4, 7);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup14);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 8, new Float64Array(15316).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/15312)), 1493, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture39 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 264},
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup12, new Uint32Array(293), 62, 0);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer0, 'uint16', 0, 1);
} catch {}
let textureView29 = texture1.createView({format: 'rgba16sint'});
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 524 */
  offset: 524,
  bytesPerRow: 2304,
  buffer: buffer7,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 32, z: 0},
  aspect: 'all',
}, {width: 0, height: 73, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder10.clearBuffer(buffer29, 20);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 4, new Uint32Array(14273).map((_, i) => i * 4), 1897, 0);
} catch {}
let bindGroup15 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 8, resource: textureView7},
    {binding: 591, resource: textureView6},
    {binding: 56, resource: textureView1},
    {binding: 1, resource: textureView22},
  ],
});
let buffer32 = device0.createBuffer({size: 8812, usage: GPUBufferUsage.UNIFORM});
let commandEncoder45 = device0.createCommandEncoder({});
let texture40 = device0.createTexture({
  size: {width: 45, height: 12, depthOrArrayLayers: 115},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder5.setBindGroup(2, bindGroup5);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(0, buffer27, 0, 7);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new DataView(new Uint8Array(1488).map((_, i) => i).buffer), 695, 24);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(1);
let commandEncoder46 = device0.createCommandEncoder({});
let texture41 = device0.createTexture({
  size: {width: 90, height: 24, depthOrArrayLayers: 1},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView30 = texture29.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder11.setBindGroup(2, bindGroup6);
} catch {}
try {
computePassEncoder7.setBindGroup(3, bindGroup11, new Uint32Array(1366), 439, 0);
} catch {}
let buffer33 = device0.createBuffer({size: 12436, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let textureView31 = texture16.createView({dimension: '2d', baseArrayLayer: 22});
try {
computePassEncoder9.setBindGroup(2, bindGroup1, new Uint32Array(166), 61, 0);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer19, 'uint32', 36, 3);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(21).fill(6), /* required buffer size: 21 */
{offset: 21}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer34 = device0.createBuffer({size: 6, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let renderPassEncoder0 = commandEncoder23.beginRenderPass({
  colorAttachments: [{
  view: textureView31,
  clearValue: { r: -407.9, g: 630.9, b: -758.3, a: -189.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true});
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
let commandEncoder47 = device0.createCommandEncoder();
let textureView32 = texture34.createView({});
let computePassEncoder15 = commandEncoder10.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 535}});
try {
renderPassEncoder0.setVertexBuffer(4, buffer4);
} catch {}
try {
renderBundleEncoder11.setBindGroup(3, bindGroup4);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer6, 'uint32', 4, 8);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(3, buffer12, 0);
} catch {}
try {
commandEncoder36.clearBuffer(buffer29);
} catch {}
try {
commandEncoder36.resolveQuerySet(querySet0, 1, 0, buffer26, 0);
} catch {}
try {
computePassEncoder12.insertDebugMarker('\u3c94');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 6_256, new Uint32Array(535).map((_, i) => i * 5));
} catch {}
try {
  await promise4;
} catch {}
let commandEncoder48 = device0.createCommandEncoder({});
let textureView33 = texture14.createView({dimension: '2d', mipLevelCount: 2});
let computePassEncoder16 = commandEncoder32.beginComputePass();
let renderPassEncoder1 = commandEncoder45.beginRenderPass({
  label: '\u00de\u5185\u9a37\u059b\uaa61\u41ac\u6b47\u{1f701}',
  colorAttachments: [{
  view: textureView31,
  clearValue: { r: -438.2, g: -306.1, b: 937.9, a: 0.4017, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder11.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer20, 'uint16', 6, 1);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(3, buffer31, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 16, new Uint32Array(17147).map((_, i) => i * 8), 684, 0);
} catch {}
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 591,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let texture42 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 1},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView34 = texture22.createView({});
let renderPassEncoder2 = commandEncoder41.beginRenderPass({
  colorAttachments: [{
  view: textureView31,
  clearValue: { r: -121.5, g: 372.1, b: 295.3, a: -494.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(4, buffer17, 12, 0);
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer27, 32, buffer29, 36, 4);
} catch {}
let querySet2 = device0.createQuerySet({type: 'timestamp', count: 9});
let textureView35 = texture3.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], stencilReadOnly: true});
try {
computePassEncoder15.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
let textureView36 = texture37.createView({});
let computePassEncoder17 = commandEncoder15.beginComputePass();
try {
computePassEncoder14.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(4);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 344, new Uint32Array(5216).map((_, i) => i * 8), 28, 116);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise6;
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

requires pointer_composite_access;

diagnostic(info, xyz);

struct FragmentOutput0 {
  @location(0) location_0: vec4f,
}

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

@group(0) @binding(133) var<storage, read> buffer35: array<array<array<array<array<array<array<array<array<array<f16, 7>, 1>, 1>, 1>, 1>, 1>, 1>, 8>, 8>, 1>;

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

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

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

alias vec3b = vec3<bool>;

struct VertexInput8 {
  @builtin(instance_index) instance_index: u32,
  @location(7) @interpolate(flat, either) location_7: vec4i,
  @location(6) location_6: vec4h,
  @location(3) location_3: u32,
}

struct VertexInput10 {
  @location(4) location_4: vec4u,
  @location(15) location_15: vec2i,
}

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

var<private> vp2: vec2h = vec2h(23005.3, 10147.6);

struct VertexInput9 {
  @location(5) @interpolate(linear) location_5: vec2f,
  @location(10) @interpolate(flat) location_10: vec4i,
  @location(2) @interpolate(flat, centroid) location_2: vec2i,
  @location(8) location_8: f16,
  @location(12) location_12: vec2h,
}

var<private> vp1: vec2h = vec2h(3790.6, 4454.0);

struct VertexInput7 {
  @location(9) location_9: f16,
}

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

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

var<private> vp0: vec4i = vec4i(324850404, 485562310, 299332112, 197942101);

/* zero global variables used */
@vertex
fn vertex1(a0: VertexInput7, a1: VertexInput8, @location(13) @interpolate(flat) location_13: vec2i, @location(0) @interpolate(linear, centroid) location_0: vec4f, @builtin(vertex_index) vertex_index: u32, @location(1) location_1: vec4i, a6: VertexInput9, a7: VertexInput10, @location(14) @interpolate(flat) location_14: i32, @location(11) @interpolate(linear) location_11: vec2f) -> @builtin(position) vec4f {
  var out: vec4f;
  let vf25: vec2h = atan2(vec2h(acos(vec2f(unconst_f32(0.04371e-16), unconst_f32(0.3559e-28))).rr), vec2h(unconst_f16(186.8), unconst_f16(11086.5)));
  let vf26: u32 = a1.instance_index;
  return out;
}

/* zero global variables used */
@fragment
fn fragment0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  out.location_0 = vec4f(f32(acosh(vec4h(out.location_0)[3])));
  var vf27: f16 = distance(vec4h(unconst_f16(7475.3), unconst_f16(8576.6), unconst_f16(634.9), unconst_f16(4424.9)), vec4h(unconst_f16(1070.8), unconst_f16(13862.8), unconst_f16(15012.3), unconst_f16(1045.1)));
  vp2 = vp2;
  let ptr13: ptr<function, vec4f> = &out.location_0;
  let ptr14: ptr<private, vec2h> = &vp2;
  vp2 = vec2h(unpack2x16snorm(unconst_u32(258247841)).gg);
  for (var it0=bitcast<u32>(vp2); it0<(bitcast<u32>(vp2) & 0xfff); it0++) {
  vp2 = bitcast<vec2h>(out.location_0[unconst_u32(298303456)]);
  let vf28: vec4f = exp2(vec4f(unconst_f32(0.01907e13), unconst_f32(0.04860e-37), unconst_f32(0.01911e-32), unconst_f32(0.2089)));
  out.location_0 = out.location_0;
  vp1 = vec2h(atan2(vec2f(bitcast<f32>(pack4xI8Clamp(vec4i(unconst_i32(257865268), unconst_i32(1683384060), unconst_i32(714942401), unconst_i32(32869110))))), vec2f(unconst_f32(0.1284), unconst_f32(0.03059))).rr.xx);
  var vf29: vec4f = unpack4x8unorm(unconst_u32(605038190));
  var vf30: vec3h = faceForward(vec3h(unconst_f16(659.1), unconst_f16(18279.6), unconst_f16(1004.3)), vec3h(unconst_f16(7360.2), unconst_f16(14629.7), unconst_f16(5540.6)), vec3h(unconst_f16(5520.9), unconst_f16(3938.6), unconst_f16(15336.3)));
  break;
}
  let vf31: vec4u = firstLeadingBit(vec4u(unconst_u32(767179241), unconst_u32(419060594), unconst_u32(67355233), unconst_u32(135271756)));
  out.location_0 = vec4f((*ptr14).rgrg.yzzw);
  var vf32: f32 = (*ptr13)[unconst_u32(1466188852)];
  let ptr15: ptr<function, vec4f> = &out.location_0;
  return out;
}

/* used global variables: buffer35 */
@compute @workgroup_size(1, 1, 1)
fn compute3(@builtin(local_invocation_index) local_invocation_index: u32, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, a3: ComputeInput6) {
  let ptr16: ptr<storage, array<f16, 7>, read> = &buffer35[unconst_u32(497496418)][7][unconst_u32(171769503)][unconst_u32(87668145)][0][0][0][0][unconst_u32(10870526)];
  {
  let ptr17: ptr<storage, array<f16, 7>, read> = &buffer35[0][unconst_u32(1166887837)][unconst_u32(449614251)][unconst_u32(55567734)][0][unconst_u32(857336879)][0][unconst_u32(3412691033)][unconst_u32(1568902094)];
  vp2 -= vec2h((*&buffer35)[unconst_u32(387434464)][unconst_u32(1472575072)][7][0][0][unconst_u32(392002950)][0][0][unconst_u32(1099443403)][6]);
  vp0 = vec4i(i32(buffer35[0][unconst_u32(347740954)][7][0][0][0][0][0][0][6]));
  let ptr18: ptr<storage, array<array<f16, 7>, 1>, read> = &(*&buffer35)[0][unconst_u32(33945254)][7][u32((*&buffer35)[unconst_u32(251690893)][unconst_u32(339410633)][u32(buffer35[0][unconst_u32(498136484)][7][0][0][0][unconst_u32(86346387)][unconst_u32(998090404)][0][6])][0][unconst_u32(31435573)][unconst_u32(167953447)][0][0][unconst_u32(472076646)][6])][unconst_u32(366887575)][0][unconst_u32(2323409824)][0];
  let ptr19: ptr<storage, f16, read> = &buffer35[unconst_u32(517931254)][unconst_u32(608256165)][7][0][unconst_u32(1981561216)][0][0][0][unconst_u32(122038429)][unconst_u32(242576783)];
  _ = buffer35;
}
  vp1 -= vec2h(buffer35[0][7][unconst_u32(474566509)][unconst_u32(986217831)][0][0][unconst_u32(384547960)][0][0][6]);
  vp2 = vec2h((*&buffer35)[0][unconst_u32(3229397270)][unconst_u32(590966221)][unconst_u32(751164631)][0][unconst_u32(269300408)][0][0][0][unconst_u32(1094906398)]);
  let ptr20: ptr<storage, f16, read> = &(*&buffer35)[0][7][7][0][unconst_u32(346879912)][0][u32((*&buffer35)[unconst_u32(559572215)][7][7][unconst_u32(1263783462)][unconst_u32(1634030328)][0][unconst_u32(244663667)][0][0][unconst_u32(1674948670)])][unconst_u32(442923764)][unconst_u32(249553873)][6];
  vp1 = vec2h(buffer35[0][unconst_u32(51088266)][7][0][0][unconst_u32(595296415)][unconst_u32(465864781)][unconst_u32(216947453)][0][6]);
  vp2 = vec2h((*&buffer35)[0][7][7][0][0][0][0][0][unconst_u32(191895082)][6]);
  let ptr21: ptr<storage, f16, read> = &buffer35[0][7][unconst_u32(63081291)][0][unconst_u32(101961729)][unconst_u32(3067073052)][unconst_u32(375945412)][0][0][6];
  while bool((*&buffer35)[0][7][7][unconst_u32(1088412286)][0][0][unconst_u32(4439883)][unconst_u32(8980173)][0][unconst_u32(169721321)]) {
  let ptr22: ptr<storage, f16, read> = &buffer35[unconst_u32(1559096204)][u32((*&buffer35)[0][unconst_u32(1243319364)][7][unconst_u32(354062868)][0][unconst_u32(341013872)][0][0][0][6])][unconst_u32(776104999)][0][unconst_u32(1792522550)][0][0][0][unconst_u32(257936338)][6];
  vp2 += vec2h((*&buffer35)[0][unconst_u32(98055382)][7][unconst_u32(163251106)][0][0][unconst_u32(272916932)][unconst_u32(272472255)][unconst_u32(1417823705)][6]);
  vp0 -= vec4i(i32((*&buffer35)[unconst_u32(1322184210)][7][unconst_u32(613281498)][unconst_u32(842712440)][unconst_u32(4294967295)][0][unconst_u32(492277992)][0][0][6]));
  _ = buffer35;
}
  {
  for (var it2=u32((*&buffer35)[0][7][7][0][unconst_u32(245368811)][0][0][0][0][6]); it2<(u32((*&buffer35)[unconst_u32(537803147)][7][unconst_u32(1969167180)][u32(buffer35[0][unconst_u32(1680253692)][unconst_u32(701556766)][unconst_u32(66527226)][0][0][0][unconst_u32(813991418)][0][6])][0][unconst_u32(377098306)][unconst_u32(272686315)][unconst_u32(728064097)][unconst_u32(462442781)][6]) & 0xfff); it2++) {
  vp2 = vec2h(buffer35[unconst_u32(1091991758)][u32((*&buffer35)[0][7][7][unconst_u32(83850387)][0][unconst_u32(469653672)][unconst_u32(418083503)][0][0][6])][7][u32(buffer35[0][unconst_u32(273390651)][7][0][0][0][0][unconst_u32(241659015)][0][6])][0][0][unconst_u32(289349550)][unconst_u32(1004281362)][0][6]);
  let ptr23: ptr<storage, array<f16, 7>, read> = &(*&buffer35)[0][7][7][0][0][unconst_u32(601699171)][unconst_u32(952505949)][0][0];
  let ptr24: ptr<storage, array<f16, 7>, read> = &(*&buffer35)[unconst_u32(927026979)][7][u32(buffer35[unconst_u32(73555442)][7][7][0][0][unconst_u32(204681698)][0][0][unconst_u32(409632717)][6])][unconst_u32(152035572)][unconst_u32(1003822309)][0][0][0][0];
  for (var it1=u32(buffer35[unconst_u32(27724480)][7][unconst_u32(637906294)][0][0][0][0][0][unconst_u32(847240823)][6]); it1<(u32(buffer35[0][7][7][0][0][unconst_u32(1817833896)][unconst_u32(539730426)][0][unconst_u32(335074166)][unconst_u32(2115518487)]) & 0xfff); it1++) {
  vp1 += vec2h(buffer35[unconst_u32(945462512)][unconst_u32(982035767)][7][0][0][0][unconst_u32(1285119451)][0][0][6]);
  _ = buffer35;
}
  break;
  _ = buffer35;
}
  let ptr25: ptr<storage, array<f16, 7>, read> = &buffer35[unconst_u32(547918519)][unconst_u32(589351260)][7][unconst_u32(405537912)][0][0][0][0][unconst_u32(1389091091)];
  let ptr26: ptr<storage, f16, read> = &(*&buffer35)[0][unconst_u32(51880206)][7][unconst_u32(37885357)][unconst_u32(34088442)][0][unconst_u32(334246473)][unconst_u32(393969395)][unconst_u32(104385365)][6];
  let ptr27: ptr<storage, f16, read> = &(*&buffer35)[0][7][7][unconst_u32(541782948)][u32((*&buffer35)[0][7][unconst_u32(1385228555)][u32((*&buffer35)[unconst_u32(11857772)][7][7][0][unconst_u32(289214957)][0][0][0][0][6])][0][unconst_u32(1481486969)][unconst_u32(607432105)][0][0][6])][unconst_u32(298076701)][unconst_u32(338191903)][0][0][unconst_u32(250472584)];
  vp1 = vec2h(buffer35[unconst_u32(475063846)][7][u32(buffer35[unconst_u32(1252684284)][unconst_u32(72712898)][7][unconst_u32(1079375255)][0][0][unconst_u32(140903536)][unconst_u32(461868151)][0][u32((*&buffer35)[0][unconst_u32(509225164)][7][unconst_u32(404696400)][unconst_u32(1155989030)][unconst_u32(718335232)][unconst_u32(257862008)][0][0][6])])][0][0][unconst_u32(211549684)][0][unconst_u32(248970432)][unconst_u32(1388116789)][6]);
  _ = buffer35;
}
  _ = buffer35;
}`,
});
let buffer37 = device0.createBuffer({size: 12444, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let textureView37 = texture42.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder13.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer20, 'uint32', 4, 2);
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1040 */
  offset: 1040,
  buffer: buffer37,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
buffer29.unmap();
} catch {}
let buffer38 = device0.createBuffer({size: 28, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder13.insertDebugMarker('\u43cb');
} catch {}
let commandEncoder49 = device0.createCommandEncoder();
let computePassEncoder18 = commandEncoder20.beginComputePass();
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup15, new Uint32Array(746), 237, 0);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(0, buffer0, 0, 0);
} catch {}
let commandEncoder50 = device0.createCommandEncoder();
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer12);
} catch {}
let textureView38 = texture12.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 6});
try {
computePassEncoder15.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer20, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder10.setBindGroup(2, bindGroup15, new Uint32Array(1425), 22, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(6, buffer7, 832, 7_852);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let buffer39 = device0.createBuffer({
  size: 97,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView39 = texture9.createView({aspect: 'all', format: 'rgba16sint'});
let renderPassEncoder3 = commandEncoder27.beginRenderPass({
  colorAttachments: [{
  view: textureView31,
  clearValue: { r: 138.3, g: -341.0, b: -9.012, a: 139.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder12.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup6, new Uint32Array(210), 8, 0);
} catch {}
try {
commandEncoder7.copyBufferToBuffer(buffer29, 24, buffer39, 0, 24);
} catch {}
try {
renderPassEncoder3.insertDebugMarker('\u5209');
} catch {}
await gc();
let buffer40 = device0.createBuffer({size: 240, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder51 = device0.createCommandEncoder();
try {
renderPassEncoder3.setBindGroup(2, bindGroup5, []);
} catch {}
try {
renderPassEncoder1.setStencilReference(1917);
} catch {}
try {
commandEncoder21.resolveQuerySet(querySet1, 62, 0, buffer0, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 32, new DataView(new Uint8Array(7542).map((_, i) => i).buffer), 4935, 12);
} catch {}
let canvas0 = document.createElement('canvas');
try {
globalThis.someLabel = device0.queue.label;
} catch {}
let texture43 = device0.createTexture({
  size: [30, 1, 79],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView40 = texture4.createView({format: 'rgba16sint'});
let renderPassEncoder4 = commandEncoder50.beginRenderPass({
  colorAttachments: [{view: textureView31, loadOp: 'clear', storeOp: 'store'}],
  maxDrawCount: 627752794,
});
try {
computePassEncoder16.setBindGroup(3, bindGroup6, []);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
document.body.append(canvas0);
await gc();
let computePassEncoder19 = commandEncoder37.beginComputePass();
try {
computePassEncoder11.setBindGroup(0, bindGroup2);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup3);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
computePassEncoder1.setBindGroup(1, bindGroup4);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(5);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer38, 'uint16', 4, 1);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer39, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 28, new Uint32Array(8419).map((_, i) => i * 10), 2709, 0);
} catch {}
await gc();
let recycledExplicitBindGroupLayout1 = pipeline0.getBindGroupLayout(2);
let commandEncoder52 = device0.createCommandEncoder();
try {
computePassEncoder19.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 12, new Uint32Array(8504).map((_, i) => i * 3), 3267, 0);
} catch {}
document.body.prepend(canvas0);
let textureView41 = texture25.createView({dimension: '2d-array'});
try {
renderPassEncoder1.setVertexBuffer(6, buffer39, 0, 6);
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3948 */
  offset: 3948,
  buffer: buffer7,
}, {
  texture: texture29,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 150, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 5, y: 14 },
  flipY: false,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder53 = device0.createCommandEncoder({});
let textureView42 = texture17.createView({dimension: '2d', baseArrayLayer: 4});
try {
computePassEncoder8.setBindGroup(2, bindGroup2, new Uint32Array(1007), 4, 0);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer11, 'uint32', 0, 4);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer12, 136, 21);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup2);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer34, 'uint16', 0, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 150, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
offscreenCanvas0.height = 416;
let buffer41 = device0.createBuffer({size: 216, usage: GPUBufferUsage.COPY_DST});
let texture44 = device0.createTexture({
  size: {width: 15, height: 1, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView43 = texture43.createView({mipLevelCount: 1});
try {
renderPassEncoder4.setVertexBuffer(6, buffer27, 0, 18);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer6, 'uint32', 0, 16);
} catch {}
let pipeline1 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'src-alpha', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-constant'},
  },
}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 16,
        attributes: [
          {format: 'sint8x4', offset: 0, shaderLocation: 13},
          {format: 'sint32', offset: 0, shaderLocation: 10},
          {format: 'sint8x2', offset: 2, shaderLocation: 1},
          {format: 'uint32', offset: 4, shaderLocation: 4},
          {format: 'float32x4', offset: 0, shaderLocation: 9},
          {format: 'sint8x4', offset: 0, shaderLocation: 15},
          {format: 'sint8x2', offset: 0, shaderLocation: 14},
          {format: 'float16x2', offset: 0, shaderLocation: 8},
          {format: 'sint8x4', offset: 4, shaderLocation: 2},
          {format: 'sint16x2', offset: 0, shaderLocation: 7},
          {format: 'uint8x2', offset: 2, shaderLocation: 3},
          {format: 'float16x2', offset: 0, shaderLocation: 6},
          {format: 'snorm8x4', offset: 0, shaderLocation: 0},
          {format: 'float16x4', offset: 0, shaderLocation: 11},
          {format: 'snorm8x2', offset: 2, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'front'},
});
let imageData3 = new ImageData(4, 44);
try {
canvas0.getContext('webgl');
} catch {}
let buffer42 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_DST});
try {
renderBundleEncoder5.setVertexBuffer(2, buffer31, 32, 5);
} catch {}
let texture45 = device0.createTexture({
  size: {width: 1, height: 540, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let bindGroup16 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 56, resource: textureView1},
    {binding: 8, resource: textureView18},
    {binding: 591, resource: textureView38},
    {binding: 1, resource: textureView39},
  ],
});
let renderPassEncoder5 = commandEncoder9.beginRenderPass({
  colorAttachments: [{
  view: textureView42,
  clearValue: { r: 418.1, g: 283.9, b: -809.9, a: 465.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
device0.queue.writeBuffer(buffer7, 7_324, new Uint32Array(3915).map((_, i) => i * 8), 577, 128);
} catch {}
let buffer43 = device0.createBuffer({size: 115, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let textureView44 = texture37.createView({});
let externalTexture1 = device0.importExternalTexture({source: videoFrame2});
try {
renderPassEncoder4.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup1);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup2, new Uint32Array(7), 2, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer38, 'uint16', 12, 3);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let pipeline2 = await device0.createComputePipelineAsync({
  layout: pipelineLayout1,
  compute: {module: shaderModule1, entryPoint: 'compute1', constants: {28_210: 1}},
});
document.body.append(canvas0);
let recycledExplicitBindGroupLayout2 = pipeline2.getBindGroupLayout(1);
let commandEncoder54 = device0.createCommandEncoder();
try {
computePassEncoder18.setBindGroup(2, bindGroup7, new Uint32Array(5784), 988, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer38, 'uint16', 6, 1);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
buffer37.unmap();
} catch {}
try {
commandEncoder54.resolveQuerySet(querySet2, 0, 0, buffer3, 0);
} catch {}
try {
  await promise7;
} catch {}
let buffer44 = device0.createBuffer({size: 272, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let textureView45 = texture28.createView({});
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let commandEncoder55 = device0.createCommandEncoder({});
let textureView46 = texture10.createView({mipLevelCount: 1});
try {
computePassEncoder19.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer7);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(1, buffer31);
} catch {}
let renderPassEncoder6 = commandEncoder13.beginRenderPass({
  colorAttachments: [{
  view: textureView43,
  depthSlice: 48,
  clearValue: { r: 363.0, g: 950.2, b: 259.5, a: 414.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 46246867,
});
let externalTexture2 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
computePassEncoder2.setBindGroup(2, bindGroup15);
} catch {}
try {
computePassEncoder0.setBindGroup(2, bindGroup7, new Uint32Array(2354), 43, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: videoFrame1,
  origin: { x: 1, y: 21 },
  flipY: false,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer20, 'uint16', 2, 2);
} catch {}
let pipeline3 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  fragment: {module: shaderModule2, targets: [{format: 'bgra8unorm'}]},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 0, shaderLocation: 11},
          {format: 'sint32x2', offset: 0, shaderLocation: 1},
          {format: 'unorm8x2', offset: 2, shaderLocation: 6},
          {format: 'unorm16x4', offset: 0, shaderLocation: 0},
          {format: 'float32x2', offset: 0, shaderLocation: 8},
          {format: 'uint16x2', offset: 0, shaderLocation: 3},
          {format: 'unorm8x4', offset: 4, shaderLocation: 12},
          {format: 'sint32x4', offset: 0, shaderLocation: 15},
          {format: 'uint32x4', offset: 0, shaderLocation: 4},
          {format: 'sint32x3', offset: 0, shaderLocation: 2},
          {format: 'float32x2', offset: 0, shaderLocation: 9},
          {format: 'sint16x4', offset: 0, shaderLocation: 7},
          {format: 'float32x4', offset: 0, shaderLocation: 5},
          {format: 'sint16x4', offset: 0, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 32,
        attributes: [{format: 'sint32', offset: 0, shaderLocation: 10}, {format: 'sint8x2', offset: 2, shaderLocation: 13}],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let texture46 = device0.createTexture({
  size: {width: 1, height: 1080, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder20 = commandEncoder31.beginComputePass();
try {
renderPassEncoder3.setBindGroup(1, bindGroup6);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer42, 8, new Float32Array(13142).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.256)), 1325, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise8;
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte240m', transfer: 'hlg'} });
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer31);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline1);
} catch {}
try {
commandEncoder48.copyBufferToBuffer(buffer29, 84, buffer13, 20, 0);
} catch {}
let buffer45 = device0.createBuffer({size: 44, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder56 = device0.createCommandEncoder({});
let sampler9 = device0.createSampler({addressModeV: 'mirror-repeat', mipmapFilter: 'linear', lodMaxClamp: 44.64});
try {
computePassEncoder7.setBindGroup(3, bindGroup13, new Uint32Array(146), 38, 0);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer34, 'uint16', 0, 1);
} catch {}
try {
commandEncoder35.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture29,
  mipLevel: 0,
  origin: {x: 23, y: 12, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup17 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 591, resource: textureView6},
    {binding: 56, resource: textureView0},
    {binding: 1, resource: textureView39},
    {binding: 8, resource: textureView18},
  ],
});
let computePassEncoder21 = commandEncoder30.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 588, endOfPassWriteIndex: 101}});
try {
computePassEncoder21.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(4, buffer7, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.queue.writeBuffer(buffer41, 8, new Float32Array(14748).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4810)), 10077, 8);
} catch {}
let pipeline4 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule2,
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one-minus-src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}],
},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 8,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 0, shaderLocation: 15},
          {format: 'uint32', offset: 0, shaderLocation: 3},
          {format: 'sint16x2', offset: 0, shaderLocation: 1},
          {format: 'snorm16x4', offset: 0, shaderLocation: 0},
          {format: 'sint16x4', offset: 0, shaderLocation: 2},
          {format: 'sint16x2', offset: 0, shaderLocation: 14},
          {format: 'unorm16x2', offset: 0, shaderLocation: 11},
          {format: 'sint16x2', offset: 0, shaderLocation: 7},
          {format: 'sint32x2', offset: 0, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12},
          {format: 'float16x2', offset: 0, shaderLocation: 8},
          {format: 'uint8x4', offset: 0, shaderLocation: 4},
          {format: 'sint32x2', offset: 0, shaderLocation: 10},
          {format: 'snorm8x2', offset: 0, shaderLocation: 9},
          {format: 'unorm16x2', offset: 0, shaderLocation: 6},
        ],
      },
      {arrayStride: 4, stepMode: 'vertex', attributes: [{format: 'float32', offset: 0, shaderLocation: 5}]},
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw'},
});
try {
globalThis.someLabel = externalTexture1.label;
} catch {}
let bindGroup18 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 1, resource: textureView21},
    {binding: 56, resource: textureView0},
    {binding: 8, resource: textureView7},
    {binding: 591, resource: textureView6},
  ],
});
let buffer46 = device0.createBuffer({
  size: 40,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT,
  mappedAtCreation: true,
});
let commandEncoder57 = device0.createCommandEncoder();
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(1, bindGroup14, new Uint32Array(2284), 381, 0);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(0, buffer4, 8, 11);
} catch {}
let commandEncoder58 = device0.createCommandEncoder({});
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder10.setBindGroup(3, bindGroup11);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup8, new Uint32Array(384), 221, 0);
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 1_244, new Float32Array(6550).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.484)), 232, 1072);
} catch {}
let texture47 = device0.createTexture({
  size: [30],
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderBundleEncoder5.setBindGroup(1, bindGroup4, new Uint32Array(2525), 828, 0);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(2, buffer20, 0, 0);
} catch {}
try {
commandEncoder54.copyTextureToBuffer({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2296 */
  offset: 2296,
  bytesPerRow: 6144,
  buffer: buffer7,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder18.insertDebugMarker('\u{1f77f}');
} catch {}
let commandEncoder59 = device0.createCommandEncoder({});
try {
renderPassEncoder5.setBindGroup(0, bindGroup7, new Uint32Array(955), 426, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 20, new Uint32Array(1464).map((_, i) => i * 2), 12, 4);
} catch {}
let buffer47 = device0.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
try {
computePassEncoder6.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
let promise9 = shaderModule1.getCompilationInfo();
let arrayBuffer0 = buffer46.getMappedRange();
try {
commandEncoder58.insertDebugMarker('\u9f2a');
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 0, y: 8 },
  flipY: false,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 133,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder60 = device0.createCommandEncoder();
try {
renderPassEncoder2.setBindGroup(2, bindGroup13);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 48, new DataView(new Uint8Array(474).map((_, i) => i).buffer), 211, 0);
} catch {}
let commandEncoder61 = device0.createCommandEncoder({});
let textureView47 = texture9.createView({mipLevelCount: 1});
let renderPassEncoder7 = commandEncoder61.beginRenderPass({
  colorAttachments: [{
  view: textureView43,
  depthSlice: 77,
  clearValue: { r: -21.74, g: -277.4, b: 621.7, a: 895.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderBundleEncoder0.setBindGroup(1, bindGroup11);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer19, 'uint32', 0, 8);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(4, buffer39, 4, 4);
} catch {}
try {
commandEncoder39.label = '\ud00a\u9376\uafea\uf391\u7fa4\u0bf2\u059b';
} catch {}
let texture48 = device0.createTexture({
  size: {width: 90, height: 24, depthOrArrayLayers: 231},
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView48 = texture3.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder11.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(6);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.submit([]);
} catch {}
let sampler10 = device0.createSampler({lodMinClamp: 48.26, lodMaxClamp: 53.42});
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(3, buffer20);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 75, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture31,
  mipLevel: 1,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder62 = device0.createCommandEncoder();
let texture49 = device0.createTexture({
  size: {width: 18, height: 1, depthOrArrayLayers: 69},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setBindGroup(2, bindGroup15);
} catch {}
let pipeline5 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule2}});
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(149); };
} catch {}
let commandEncoder63 = device0.createCommandEncoder({});
let texture50 = device0.createTexture({
  size: [75, 1, 1],
  mipLevelCount: 4,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture51 = device0.createTexture({
  size: {width: 1},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder5.setBindGroup(0, bindGroup10, new Uint32Array(2583), 465, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
document.body.prepend(canvas0);
let buffer48 = device0.createBuffer({
  size: 196,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture52 = device0.createTexture({
  size: [1, 135, 1],
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture53 = device0.createTexture({
  size: {width: 37, height: 1, depthOrArrayLayers: 45},
  mipLevelCount: 2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder22 = commandEncoder28.beginComputePass();
try {
computePassEncoder5.setBindGroup(1, bindGroup13);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(5, buffer17, 4, 19);
} catch {}
document.body.append(canvas0);
try {
adapter0.label = '\u032a\u60ef\u{1fca5}\u9eb3\u0a40\u{1fe4f}\u{1f7a4}\u0727\u0d14';
} catch {}
let commandEncoder64 = device0.createCommandEncoder({});
let texture54 = device0.createTexture({
  size: {width: 75, height: 1, depthOrArrayLayers: 32},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder22.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup7, new Uint32Array(2684), 1_004, 0);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup7, new Uint32Array(1320), 654, 0);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(5, buffer7, 2_488, 1_661);
} catch {}
let commandEncoder65 = device0.createCommandEncoder();
let texture55 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt470bg', transfer: 'bt2020_10bit'} });
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 100,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 515,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 529,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder66 = device0.createCommandEncoder({});
let texture56 = device0.createTexture({
  size: {width: 45, height: 12, depthOrArrayLayers: 1},
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder6.setVertexBuffer(2, buffer7, 2_016, 1_112);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup10);
} catch {}
let pipeline6 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute2', constants: {}}});
let texture57 = device0.createTexture({
  size: [64, 64, 18],
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(2917), 469, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer20, 'uint32', 0, 0);
} catch {}
try {
globalThis.someLabel = buffer18.label;
} catch {}
let textureView49 = texture57.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 6});
let textureView50 = texture20.createView({});
try {
renderPassEncoder7.setBindGroup(0, bindGroup9, new Uint32Array(66), 0, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer11, 'uint32', 8, 2);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup6);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let recycledExplicitBindGroupLayout3 = pipeline0.getBindGroupLayout(2);
let commandEncoder67 = device0.createCommandEncoder({});
let texture58 = device0.createTexture({
  size: [90, 24, 5],
  mipLevelCount: 4,
  sampleCount: 1,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView51 = texture24.createView({});
try {
renderPassEncoder3.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer27);
} catch {}
try {
  await promise10;
} catch {}
let commandEncoder68 = device0.createCommandEncoder({});
let textureView52 = texture57.createView({dimension: 'cube-array', baseArrayLayer: 2, arrayLayerCount: 6});
let texture59 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder15.setPipeline(pipeline5);
} catch {}
try {
commandEncoder62.copyBufferToTexture({
  /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 2024 */
  offset: 2024,
  rowsPerImage: 349,
  buffer: buffer33,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 0, y: 33, z: 0},
  aspect: 'stencil-only',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer44, 0, new Float32Array(12996).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.430)), 702, 24);
} catch {}
let buffer49 = device0.createBuffer({size: 9416, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder69 = device0.createCommandEncoder({});
try {
computePassEncoder2.setBindGroup(1, bindGroup14);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(59), 13, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer48, 'uint16', 12, 8);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(3, buffer27, 0, 2);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup9);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(0, buffer7, 1_072, 5_562);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture60 = device0.createTexture({
  size: [75, 1, 1],
  mipLevelCount: 1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView53 = texture54.createView({dimension: '2d', baseArrayLayer: 3});
try {
buffer29.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer44, 16, new Uint32Array(37128).map((_, i) => i * 3), 2366, 0);
} catch {}
try {
  await promise9;
} catch {}
document.body.append(canvas0);
let textureView54 = texture57.createView({format: 'depth24plus-stencil8', baseArrayLayer: 1, arrayLayerCount: 7});
let texture61 = device0.createTexture({
  size: [37, 1, 32],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder20.setBindGroup(1, bindGroup15);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup19 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout2, entries: [{binding: 133, resource: {buffer: buffer49}}]});
try {
computePassEncoder18.setBindGroup(2, bindGroup19);
} catch {}
try {
computePassEncoder8.setBindGroup(2, bindGroup19, new Uint32Array(2334), 13, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer19, 'uint16', 34, 77);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup5, new Uint32Array(853), 111, 0);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING, alphaMode: 'opaque'});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(206).fill(128), /* required buffer size: 206 */
{offset: 206, rowsPerImage: 32}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 4, resource: {buffer: buffer49}},
    {binding: 529, resource: textureView5},
    {binding: 1, resource: {buffer: buffer49}},
    {binding: 515, resource: sampler0},
    {binding: 100, resource: {buffer: buffer19, size: 135}},
  ],
});
let commandEncoder70 = device0.createCommandEncoder({});
let querySet3 = device0.createQuerySet({type: 'timestamp', count: 494});
let renderPassEncoder8 = commandEncoder46.beginRenderPass({
  colorAttachments: [{
  view: textureView43,
  depthSlice: 8,
  clearValue: { r: -598.1, g: 606.4, b: 255.5, a: -757.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
  timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 8},
});
try {
computePassEncoder17.setBindGroup(0, bindGroup19, new Uint32Array(2413), 104, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup16);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(0, buffer3, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 9},
  aspect: 'all',
}, new Uint8Array(14_252).fill(210), /* required buffer size: 14_252 */
{offset: 77, bytesPerRow: 75, rowsPerImage: 21}, {width: 17, height: 0, depthOrArrayLayers: 10});
} catch {}
let imageData4 = new ImageData(60, 4);
let textureView55 = texture52.createView({dimension: '2d-array', aspect: 'stencil-only', mipLevelCount: 1});
try {
buffer19.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let pipeline7 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'dst-alpha', dstFactor: 'src-alpha'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 4,
        attributes: [
          {format: 'sint8x4', offset: 0, shaderLocation: 1},
          {format: 'sint8x2', offset: 0, shaderLocation: 5},
          {format: 'uint8x4', offset: 0, shaderLocation: 12},
          {format: 'sint8x4', offset: 0, shaderLocation: 7},
          {format: 'float32', offset: 0, shaderLocation: 13},
          {format: 'uint8x2', offset: 0, shaderLocation: 14},
          {format: 'unorm16x2', offset: 0, shaderLocation: 2},
          {format: 'uint8x4', offset: 0, shaderLocation: 4},
          {format: 'snorm8x2', offset: 0, shaderLocation: 9},
          {format: 'unorm16x2', offset: 0, shaderLocation: 0},
          {format: 'float16x2', offset: 0, shaderLocation: 6},
          {format: 'unorm8x2', offset: 0, shaderLocation: 3},
          {format: 'snorm16x2', offset: 0, shaderLocation: 8},
          {format: 'unorm8x4', offset: 0, shaderLocation: 11},
          {format: 'unorm8x4', offset: 0, shaderLocation: 10},
          {format: 'sint32', offset: 0, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'back'},
});
let texture62 = device0.createTexture({
  size: [45, 12, 115],
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView56 = texture17.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2});
try {
renderBundleEncoder8.setPipeline(pipeline3);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
let pipeline8 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule2,
  targets: [{
  format: 'bgra8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 180,
        stepMode: 'vertex',
        attributes: [
          {format: 'unorm8x2', offset: 58, shaderLocation: 8},
          {format: 'float16x4', offset: 24, shaderLocation: 11},
          {format: 'sint16x4', offset: 68, shaderLocation: 5},
          {format: 'uint32x4', offset: 140, shaderLocation: 14},
          {format: 'snorm8x4', offset: 8, shaderLocation: 6},
          {format: 'float32x3', offset: 20, shaderLocation: 13},
          {format: 'float16x4', offset: 4, shaderLocation: 2},
          {format: 'uint32x2', offset: 44, shaderLocation: 4},
          {format: 'sint32x4', offset: 16, shaderLocation: 15},
          {format: 'sint8x2', offset: 0, shaderLocation: 1},
          {format: 'snorm8x4', offset: 28, shaderLocation: 9},
          {format: 'unorm8x4', offset: 12, shaderLocation: 3},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'float32x4', offset: 852, shaderLocation: 0},
          {format: 'uint16x2', offset: 712, shaderLocation: 12},
          {format: 'unorm8x4', offset: 144, shaderLocation: 10},
          {format: 'sint16x4', offset: 28, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true},
});
let bindGroup21 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let commandEncoder71 = device0.createCommandEncoder({});
let texture63 = device0.createTexture({
  size: [22, 6, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '2d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder17.setBindGroup(1, bindGroup19);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup21, new Uint32Array(1634), 128, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let canvas1 = document.createElement('canvas');
let commandEncoder72 = device0.createCommandEncoder({});
let texture64 = device0.createTexture({
  size: [18],
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setVertexBuffer(1, buffer4, 0, 54);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup16);
} catch {}
try {
device0.queue.writeBuffer(buffer39, 8, new DataView(new ArrayBuffer(38644)), 624, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise11;
} catch {}
let texture65 = device0.createTexture({
  size: [18, 1, 251],
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rgba8unorm-srgb'],
});
let computePassEncoder23 = commandEncoder69.beginComputePass();
try {
renderPassEncoder1.setBindGroup(2, bindGroup19, new Uint32Array(808), 87, 0);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(2, buffer12, 64, 92);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup4);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer48, 'uint16', 26, 0);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline7);
} catch {}
let recycledExplicitBindGroupLayout4 = pipeline5.getBindGroupLayout(0);
let buffer50 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_SRC});
let texture66 = device0.createTexture({
  size: {width: 1, height: 135, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture67 = device0.createTexture({
  size: {width: 30},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView57 = texture63.createView({aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder11.setBindGroup(1, bindGroup21, new Uint32Array(3158), 551, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let buffer51 = device0.createBuffer({size: 376, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture68 = device0.createTexture({
  size: {width: 1},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder6.setBindGroup(0, bindGroup19);
} catch {}
try {
computePassEncoder15.setBindGroup(0, bindGroup21, new Uint32Array(1069), 129, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup14, new Uint32Array(372), 4, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer38, 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer44, 4, new Uint16Array(3542).map((_, i) => i + 4), 283, 56);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let imageData5 = new ImageData(36, 56);
let querySet4 = device0.createQuerySet({type: 'timestamp', count: 376});
let renderPassEncoder9 = commandEncoder62.beginRenderPass({
  colorAttachments: [{
  view: textureView42,
  clearValue: { r: 943.6, g: -376.9, b: -188.4, a: -172.7, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 714},
});
try {
computePassEncoder9.setBindGroup(0, bindGroup21, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer9, 0); };
} catch {}
try {
computePassEncoder15.end();
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup21, new Uint32Array(5610), 520, 0);
} catch {}
try {
renderPassEncoder3.draw(2, 10, 5, 1_309_932_707);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer48, 28);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer48, 16);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline7);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let shaderModule3 = device0.createShaderModule({
  code: `
requires packed_4x8_integer_dot_product;

enable f16;

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

@group(3) @binding(8) var st1: texture_storage_3d<rg32float, read>;

struct VertexInput16 {
  @builtin(instance_index) instance_index: u32,
}

struct VertexInput11 {
  @location(14) location_14: vec4u,
  @location(12) location_12: f16,
  @location(3) location_3: vec2f,
  @location(5) location_5: vec4u,
  @location(8) location_8: f32,
}

struct VertexInput13 {
  @location(15) location_15: vec2u,
  @location(11) @interpolate(linear) location_11: f32,
}

@group(0) @binding(7) var<storage, read> buffer52: array<array<array<array<array<f16, 9>, 1>, 1>, 20>>;

@group(1) @binding(4) var<storage, read_write> buffer55: array<array<array<array<array<VertexInput14, 13>, 1>, 1>, 16>>;

override override1 = -62607995;

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

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

@id(10362) override override2: u32;

struct VertexInput12 {
  @location(7) @interpolate(flat) location_7: u32,
  @location(1) @interpolate(flat) location_1: vec4i,
}

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

@id(22737) override override3: i32;

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

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

struct VertexOutput1 {
  @location(1) location_1: vec4i,
  @location(15) location_15: vec4h,
  @location(6) location_6: u32,
  @location(9) location_9: vec2h,
  @location(3) location_3: i32,
  @location(14) @interpolate(flat, first) location_14: u32,
  @location(10) @interpolate(flat, first) location_10: vec2f,
  @location(0) location_0: vec2u,
  @location(7) location_7: i32,
  @location(13) location_13: vec2i,
  @location(2) location_2: vec4f,
  @location(8) @interpolate(linear, center) location_8: vec4f,
  @location(4) location_4: vec4f,
  @invariant @builtin(position) position: vec4f,
  @location(5) @interpolate(flat, centroid) location_5: f32,
}

struct T2 {
  @align(64) @size(128) f0: vec4u,
  @size(192) f1: array<T0, 1>,
  @size(640) f2: T0,
  f3: array<u32>,
}

var<workgroup> vw0: f16;

struct T0 {
  @align(8) @size(8) f0: bool,
  @size(80) f1: vec2f,
}

struct VertexInput14 {
  @location(13) location_13: f16,
}

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

struct VertexInput15 {
  @location(9) location_9: vec2u,
}

@group(0) @binding(191) var<uniform> buffer53: array<array<vec4i, 4>, 79>;

override override4: u32 = (519340439 % 103) + 1;

@group(2) @binding(133) var<storage, read> buffer57: array<VertexInput14, 448>;

/* used global variables: buffer53, tex0 */
@must_use 
fn fn0() -> bool {
  var out: bool;
  while bool(insertBits(unconst_i32(1206713723), unconst_i32(2147483647), unconst_u32(224360159), unconst_u32(2328993))) {
  if bool(((*&buffer53)[78][unconst_u32(562222850)].bgg << vec3u(unconst_u32(1569138412), unconst_u32(929563496), unconst_u32(990296466)))[1]) {
  out = bool(asinh(f16(unpack2x16unorm(unconst_u32(928664303)).y)));
  let ptr28: ptr<uniform, vec4i> = &(*&buffer53)[78][3];
  let vf33: ptr<uniform, array<array<vec4i, 4>, 79>> = &buffer53;
  _ = buffer53;
}
  let vf34: vec4i = insertBits(vec4i(unconst_i32(190916479), unconst_i32(342555468), unconst_i32(73880445), unconst_i32(292869886)), vec4i(unconst_i32(247583678), unconst_i32(451670365), unconst_i32(341507247), unconst_i32(134717840)), u32(all((vec2i(unconst_i32(838955976), unconst_i32(6890456)) > vec2i(i32(override4))))), unconst_u32(7183268));
  out = bool(max(vec2i(unconst_i32(196596291), unconst_i32(676187781)), buffer53[78][unconst_u32(327387850)].zw)[0]);
  let vf35: u32 = pack4xU8(vec4u(unconst_u32(793733882), unconst_u32(538419953), unconst_u32(224642975), unconst_u32(792795794)));
  _ = override4;
  _ = buffer53;
}
  out = bool((*&buffer53)[78][3].w);
  let vf36: vec2u = textureDimensions(tex0, unconst_i32(617106958));
  for (var it3=vec3u(atan(vec3h((*&buffer53)[unconst_u32(100255755)][3].abb)).gbb)[0]; it3<(bitcast<u32>((*&buffer53)[78][unconst_u32(572774688)][unconst_u32(403761971)]) & 0xfff); it3++) {
  out = bool((*&buffer53)[78][3][2]);
  var vf37: bool = (unconst_f32(-0.07426e5) != unconst_f32(0.2097e4));
  break;
  _ = buffer53;
}
  out = bool(acosh(vec2h(unconst_f16(4170.7), unconst_f16(-7363.9)))[1]);
  switch bitcast<u32>(acosh(vec2h(unconst_f16(65500.0), unconst_f16(3987.1)))) { 
  default: {
  let ptr29: ptr<uniform, vec4i> = &(*&buffer53)[unconst_u32(556675653)][3];
  _ = buffer53;
}
  }
  var vf38: i32 = (*&buffer53)[unconst_u32(274364274)][3][unconst_u32(236625052)];
  return out;
  _ = override4;
  _ = buffer53;
  _ = tex0;
}

@group(0) @binding(2) var tex0: texture_cube_array<u32>;

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

/* used global variables: buffer52 */
@vertex
fn vertex2(@location(0) location_0: vec4u, a1: VertexInput11, a2: VertexInput12, @location(4) @interpolate(perspective, center) location_4: vec4f, @location(10) @interpolate(flat, center) location_10: vec2i, a5: VertexInput13, @location(2) @interpolate(linear, center) location_2: f16, a7: VertexInput14, a8: VertexInput15, @location(6) location_6: u32, a10: VertexInput16, @builtin(vertex_index) vertex_index: u32) -> VertexOutput1 {
  var out: VertexOutput1;
  out.location_0 &= vec2u(u32(buffer52[arrayLength(&buffer52)][unconst_u32(158513522)][unconst_u32(579247217)][0][8]));
  return out;
  _ = buffer52;
}

/* used global variables: buffer53, buffer55, buffer57, tex0 */
@compute @workgroup_size(1, 1, 1)
fn compute4(a0: ComputeInput7, a1: ComputeInput8) {
  buffer55[unconst_u32(863559412)][unconst_u32(151716210)][unconst_u32(414145517)][unconst_u32(2122418529)][unconst_u32(94221268)] = (*&buffer57)[447];
  _ = fn0();
  var vf39 = fn0();
  let ptr30: ptr<storage, VertexInput14, read_write> = &(*&buffer55)[arrayLength(&(*&buffer55))][u32(buffer57[447].location_13)][unconst_u32(591060340)][0][12];
  {
  var vf40 = fn0();
  buffer55[unconst_u32(528770773)][unconst_u32(216005851)][pack4xU8(vec4u((*&buffer53)[78][3].yywy))][unconst_u32(4152712884)][unconst_u32(1516962126)] = VertexInput14(buffer55[unconst_u32(165254121)][unconst_u32(289083953)][unconst_u32(1047032798)][u32((*&buffer55)[arrayLength(&(*&buffer55)) - 1][15][0][0][12].location_13)][unconst_u32(3111189169)].location_13);
  _ = fn0();
  _ = override4;
  _ = tex0;
  _ = buffer53;
  _ = buffer55;
}
  let ptr31: ptr<uniform, array<vec4i, 4>> = &(*&buffer53)[unconst_u32(94275097)];
  let ptr32: ptr<storage, f16, read_write> = &buffer55[unconst_u32(545084270)][unconst_u32(6911426)][0][0][12].location_13;
  {
  buffer55[unconst_u32(142956083)][unconst_u32(194455014)][0][u32((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(107751832)][0][0][12].location_13)][unconst_u32(169406544)] = (*&buffer55)[unconst_u32(392206179)][15][unconst_u32(553302732)][0][12];
  vw0 = (*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(800633095)][unconst_u32(90327584)][0][12].location_13;
  vw0 = (*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(481024504)][unconst_u32(272356806)][0][12].location_13;
  _ = buffer55;
}
  buffer55[unconst_u32(109837762)][unconst_u32(24459874)][unconst_u32(1615197572)][unconst_u32(1386200310)][unconst_u32(839205252)].location_13 = buffer55[arrayLength(&buffer55)][pack4xI8Clamp(buffer53[78][u32(buffer55[unconst_u32(189816334)][unconst_u32(531075710)][unconst_u32(921932832)][bitcast<u32>(distance(vec4f(unconst_f32(0.3822e6), unconst_f32(0.7552e-37), unconst_f32(0.09118), unconst_f32(0.1975e-12)), vec4f(unconst_f32(0.3206e-3), unconst_f32(0.2150), unconst_f32(-0.08594), unconst_f32(0.03301e6))))][12].location_13)])][unconst_u32(212422806)][0][unconst_u32(488107469)].location_13;
  var vf41 = fn0();
  _ = override4;
  _ = tex0;
  _ = buffer57;
  _ = buffer55;
  _ = buffer53;
}

/* used global variables: buffer53, buffer55, buffer57, st1, tex0 */
@compute @workgroup_size(1, 1, 1)
fn compute5() {
  let ptr33: ptr<storage, VertexInput14, read_write> = &buffer55[u32((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(98824504)][0][0][unconst_u32(1475765311)].location_13)][unconst_u32(691061498)][0][unconst_u32(530155561)][12];
  loop {
  vw0 = buffer55[unconst_u32(2015096823)][15][unconst_u32(929733838)][unconst_u32(242675618)][12].location_13;
  buffer55[unconst_u32(1572598292)][15][unconst_u32(381470439)][unconst_u32(603091388)][unconst_u32(1602520740)] = (*&buffer55)[arrayLength(&(*&buffer55))][15][unconst_u32(71423651)][0][12];
  let ptr34: ptr<storage, VertexInput14, read_write> = &(*&buffer55)[unconst_u32(400388205)][15][unconst_u32(1868003516)][0][unconst_u32(260447495)];
  break;
  _ = buffer55;
}
  _ = fn0();
  _ = fn0();
  var vf42 = fn0();
  for (var jj53=0u; jj53<3; jj53++) { buffer55[unconst_u32(343925879)][unconst_u32(405189601)][unconst_u32(2431418292)][jj53][unconst_u32(47224494)].location_13 = f16(buffer53[78][unconst_u32(1447232423)][unconst_u32(953821080)]); }
  if bool((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(718952994)][unconst_u32(1106970167)][0][u32((*&buffer55)[unconst_u32(1779562586)][15][0][0][12].location_13)].location_13) {
  _ = fn0();
  vw0 = f16(textureDimensions(st1)[0]);
  vw0 = (*&buffer55)[unconst_u32(485409213)][unconst_u32(292233538)][0][unconst_u32(814683715)][unconst_u32(131293631)].location_13;
  vw0 = (*&buffer55)[unconst_u32(928240422)][15][unconst_u32(1473443188)][unconst_u32(268272538)][unconst_u32(114441322)].location_13;
  return;
  _ = override4;
  _ = buffer55;
  _ = buffer53;
  _ = tex0;
  _ = st1;
}
  vf42 = bool(buffer55[arrayLength(&buffer55)][u32((*&buffer55)[unconst_u32(156715298)][15][0][0][12].location_13)][0][0][unconst_u32(363408306)].location_13);
  vf42 = bool((*&buffer55)[unconst_u32(338604410)][15][unconst_u32(78335694)][0][12].location_13);
  buffer55[unconst_u32(1014133642)][unconst_u32(572905143)][unconst_u32(247945546)][unconst_u32(986406566)][unconst_u32(255190930)].location_13 = f16(textureDimensions(tex0, unconst_i32(1175188535))[0]);
  for (var jj99=0u; jj99<3; jj99++) { buffer55[unconst_u32(1104354407)][unconst_u32(1034826593)][jj99][u32(buffer55[unconst_u32(58913035)][unconst_u32(877072180)][unconst_u32(782188642)][unconst_u32(2145524731)][unconst_u32(564597186)].location_13)][unconst_u32(235587711)].location_13 = (*&buffer55)[arrayLength(&(*&buffer55))][15][unconst_u32(149605685)][unconst_u32(74494132)][12].location_13; }
  buffer55[unconst_u32(556401692)][u32((*&buffer55)[unconst_u32(3894152)][15][0][0][12].location_13)][u32((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(711024683)][0][unconst_u32(92093255)][unconst_u32(12981774)].location_13)][unconst_u32(1045536112)][unconst_u32(344485900)].location_13 -= buffer57[447].location_13;
  _ = override4;
  _ = buffer55;
  _ = tex0;
  _ = st1;
  _ = buffer57;
  _ = buffer53;
}`,
});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder23.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder3.draw(2, 1, 0, 226_823_628);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 223, 0, 830_835_700, 75_388_281);
} catch {}
let commandEncoder73 = device0.createCommandEncoder({});
try {
renderPassEncoder3.draw(4, 337, 0, 93_549_395);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer49, 536);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer20, 0);
} catch {}
let commandEncoder74 = device0.createCommandEncoder();
let textureView58 = texture64.createView({baseMipLevel: 0});
try {
renderPassEncoder3.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder3.draw(1, 55, 1, 474_751_921);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 66, 0, 149_451_718, 62_647_185);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer46, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup5);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup15, new Uint32Array(445), 23, 0);
} catch {}
try {
buffer25.unmap();
} catch {}
try {
commandEncoder8.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2288 */
  offset: 2288,
  buffer: buffer33,
}, {
  texture: texture50,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder2.pushDebugGroup('\u0af1');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 18, height: 1, depthOrArrayLayers: 45}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture53,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 7},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext1 = canvas1.getContext('webgpu');
let bindGroup22 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 529, resource: textureView46},
    {binding: 515, resource: sampler0},
    {binding: 1, resource: {buffer: buffer49}},
    {binding: 4, resource: {buffer: buffer49}},
    {binding: 100, resource: {buffer: buffer22, size: 151}},
  ],
});
let texture69 = device0.createTexture({
  size: {width: 75},
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView59 = texture55.createView({dimension: '2d-array', mipLevelCount: 1});
let sampler11 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 81.94});
try {
computePassEncoder11.setBindGroup(1, bindGroup19, new Uint32Array(5082), 329, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(6, buffer48, 12, 3);
} catch {}
try {
buffer22.unmap();
} catch {}
let commandEncoder75 = device0.createCommandEncoder();
let texture70 = device0.createTexture({
  size: [90],
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView60 = texture37.createView({arrayLayerCount: 1});
try {
computePassEncoder7.setBindGroup(0, bindGroup19, new Uint32Array(1939), 194, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer49, 1_540); };
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 191, 0, 1_010_478_020, 1_840_296_082);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer48, 28);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer49, 'uint32', 24, 914);
} catch {}
let imageData6 = new ImageData(88, 64);
let autogeneratedBindGroupLayout0 = pipeline6.getBindGroupLayout(0);
let texture71 = device0.createTexture({
  size: [18, 1, 820],
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder13.setBindGroup(2, bindGroup21);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer9, 4); };
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup22);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup19, new Uint32Array(508), 108, 0);
} catch {}
try {
renderPassEncoder3.draw(1, 212, 1, 351_762_765);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer6, 0);
} catch {}
let pipeline9 = await promise5;
try {
  await promise12;
} catch {}
try {
globalThis.someLabel = computePassEncoder4.label;
} catch {}
let bindGroup23 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 56, resource: textureView0},
    {binding: 591, resource: textureView38},
    {binding: 1, resource: textureView16},
    {binding: 8, resource: textureView7},
  ],
});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: false, stencilReadOnly: true});
try {
renderPassEncoder3.drawIndexedIndirect(buffer46, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder76 = device0.createCommandEncoder();
let commandBuffer1 = commandEncoder10.finish();
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup7, []);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 146, 0, -1_909_407_116, 119_068_996);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer6, 0);
} catch {}
let pipeline10 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x1e13b585},
  fragment: {
  module: shaderModule2,
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE,
}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 44,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 0, shaderLocation: 15},
          {format: 'snorm16x2', offset: 4, shaderLocation: 3},
          {format: 'float32x3', offset: 12, shaderLocation: 13},
          {format: 'uint32x4', offset: 0, shaderLocation: 14},
          {format: 'uint8x4', offset: 8, shaderLocation: 5},
          {format: 'float32', offset: 4, shaderLocation: 2},
          {format: 'snorm16x2', offset: 0, shaderLocation: 12},
          {format: 'sint16x2', offset: 0, shaderLocation: 10},
          {format: 'float32x3', offset: 4, shaderLocation: 11},
          {format: 'unorm16x4', offset: 0, shaderLocation: 8},
          {format: 'uint32x4', offset: 4, shaderLocation: 7},
          {format: 'uint32x3', offset: 4, shaderLocation: 0},
          {format: 'uint8x4', offset: 0, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 24,
        stepMode: 'vertex',
        attributes: [
          {format: 'unorm16x4', offset: 0, shaderLocation: 4},
          {format: 'uint8x2', offset: 10, shaderLocation: 9},
          {format: 'sint32x2', offset: 0, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'ccw', cullMode: 'front'},
});
let shaderModule4 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires readonly_and_readwrite_storage_textures;

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

@group(0) @binding(133) var<storage, read> buffer58: array<array<array<VertexInput17, 1>, 14>>;

/* zero global variables used */
fn fn0(a0: ptr<workgroup, array<vec4f, 1>>, a1: vec2<bool>) {
  {
  for (var jj23=0u; jj23<3; jj23++) { (*a0)[jj23] = vec4f(mix(vec3h(unconst_f16(21065.5), unconst_f16(10790.5), unconst_f16(1637.0)), vec3h(f16(length(vec3f(unconst_f32(0.2198e-10), unconst_f32(0.03439e10), unconst_f32(0.2668e-2))))), vec3h(unconst_f16(14189.5), unconst_f16(17674.8), unconst_f16(19205.8))).rbbb.zwyw.ywxz); }
  vp3[39] = modf(f16(all(vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false)))));
}
  if bool(sinh(unconst_f32(0.3993e-37))) {
  vp3[unconst_u32(1007660963)].whole = (mat4x4h() + mat4x4h(unconst_f16(24899.0), unconst_f16(13406.0), unconst_f16(1409.8), unconst_f16(1350.4), unconst_f16(37715.9), unconst_f16(11133.1), unconst_f16(8029.8), unconst_f16(14930.0), unconst_f16(14475.6), unconst_f16(5998.7), unconst_f16(6539.5), unconst_f16(9354.1), unconst_f16(1274.9), unconst_f16(5452.4), unconst_f16(23228.0), unconst_f16(25702.6)))[unconst_i32(2)][3];
  switch i32((*a0)[0].x) { 
  default: {
  let ptr35 = &vp3[bitcast<u32>((*a0)[unconst_u32(406302727)][unconst_u32(841381000)])];
  let ptr36 = &vp3[39];
}
  }
  let vf43: vec2f = saturate(vec2f(unconst_f32(0.3306e38), unconst_f32(0.2192e-8)));
  vp3[unconst_u32(1483786031)] = modf(vec2h(unpack2x16snorm(unconst_u32(444259961)).xx)[0]);
  var vf44: vec4f = atanh(vec4f(unconst_f32(-0.1492e25), unconst_f32(0.1585), unconst_f32(0.1675), unconst_f32(0.04152e-14)));
  var vf45: vec2h = cosh(vec2h(unconst_f16(25555.5), unconst_f16(-27018.8)));
}
  (*a0)[pack2x16snorm(vec2f(unconst_f32(0.5009), unconst_f32(0.01990)))] += vec4f(f32(vp3[unconst_u32(1667287508)].whole));
  for (var jj8=0u; jj8<3; jj8++) { (*a0)[jj8] *= vec4f(f32(vp3[vec4u((*a0)[0].araa.wywz).x].fract)); }
  switch u32(round(unconst_f16(17389.1))) { 
  default {
  (*a0)[unconst_u32(247517421)] += (*a0)[0];
  (*a0)[unconst_u32(507105840)] += bitcast<vec4f>( ~vec2i(unconst_i32(259282134), unconst_i32(344313092)).ggrg);
  var vf46: bool = (unconst_bool(true) && unconst_bool(false));
  vp3[unconst_u32(2010501317)] = modf(distance(vec2h(unconst_f16(19114.6), unconst_f16(8944.1)), abs(vec4h(unconst_f16(2794.1), unconst_f16(6186.0), unconst_f16(18542.0), unconst_f16(12501.0))).ab));
  vp3[39].fract -= abs(vec4h(vp3[pack4x8unorm(vec4f(unconst_f32(-0.06925e21), unconst_f32(0.02477e-6), unconst_f32(0.07742), unconst_f32(0.04119e11)))].whole)).y;
  break;
}
  }
  (*a0)[unconst_u32(3096414791)] = unpack4x8unorm(pack4xI8Clamp(vec4i(unconst_i32(164398061), unconst_i32(440389351), unconst_i32(147144341), unconst_i32(46108240))));
  var vf47: vec2f = atanh(vec2f(unconst_f32(0.06299e-42), unconst_f32(0.4720e15)));
  let ptr37: ptr<workgroup, vec4f> = &(*a0)[0];
  vp3[unconst_u32(437749099)] = modf(vec3h(fract(vec3f(unconst_f32(0.1277), unconst_f32(0.00037e-24), unconst_f32(-0.1460e17))))[2]);
  let vf48: vec3h = exp2(vec3h(unconst_f16(2480.9), unconst_f16(3645.9), unconst_f16(16222.2)));
  var vf49: u32 = pack4xI8Clamp(vec4i(unconst_i32(34714678), unconst_i32(339929443), unconst_i32(52130143), unconst_i32(252859062)));
}

struct T1 {
  @size(6) f0: f32,
}

var<workgroup> vw4: bool;

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

var<workgroup> vw2: atomic<u32>;

struct VertexInput17 {
  @location(10) location_10: vec2i,
  @location(14) location_14: f32,
  @location(3) location_3: vec4u,
  @location(2) location_2: vec2f,
  @location(11) location_11: vec2f,
  @location(1) location_1: i32,
  @location(6) @interpolate(flat, center) location_6: i32,
}

var<workgroup> vw3: vec2<bool>;

struct VertexInput20 {
  @location(7) location_7: f16,
}

struct VertexOutput2 {
  @location(0) location_0: vec4i,
  @builtin(position) position: vec4f,
  @location(14) location_14: vec2f,
  @location(9) location_9: vec2u,
  @location(7) @interpolate(flat, sample) location_7: vec2u,
  @location(6) location_6: vec4u,
  @location(11) location_11: vec2i,
  @location(10) location_10: vec2u,
  @location(8) location_8: vec4f,
  @location(4) @interpolate(flat, sample) location_4: vec4i,
}

struct VertexInput18 {
  @location(4) location_4: vec4i,
  @location(0) location_0: vec4i,
}

@id(9920) override override5: f16 = 5642.7;

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

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

/* zero global variables used */
fn fn1(a0: ptr<function, array<array<i32, 1>, 1>>) -> array<array<array<array<array<vec2h, 1>, 1>, 1>, 1>, 1> {
  var out: array<array<array<array<array<vec2h, 1>, 1>, 1>, 1>, 1>;
  let ptr38: ptr<function, array<vec2h, 1>> = &out[0][0][0][unconst_u32(963823566)];
  let ptr39: ptr<function, vec2h> = &out[unconst_u32(2212433687)][bitcast<u32>(out[unconst_u32(193483903)][unconst_u32(290451753)][unconst_u32(19569194)][unconst_u32(357563239)][0])][unconst_u32(1528230471)][0][unconst_u32(582167644)];
  {
  let ptr40: ptr<function, array<array<vec2h, 1>, 1>> = &out[0][unconst_u32(133507546)][unconst_u32(167612150)];
  switch bitcast<i32>(out[0][0][unconst_u32(453005240)][0][unconst_u32(399153749)]) { 
  case 188442971, 864555992, 533393780 {
  vp3[unconst_u32(248224565)] = modf(out[0][0][0][unconst_u32(2247297067)][0].x);
  switch vec4u(atanh(vec4h(f16((*a0)[unconst_u32(507047169)][0]))))[2] { 
  default: {
  out[unconst_u32(714569845)][unconst_u32(240843740)][0][unconst_u32(413900325)][unconst_u32(117456703)] += vec2h(reverseBits(vec4u(unconst_u32(219799953), unconst_u32(318641511), unconst_u32(21565193), unconst_u32(354758547))).wy);
}
  }
  if bool(out[unconst_u32(409022634)][0][unconst_u32(499142526)][0][unconst_u32(1148782275)][0]) {
  out[unconst_u32(1208046470)][u32(vp3[unconst_u32(433878161)].whole)][0][unconst_u32(185974455)][unconst_u32(606328826)] += out[unconst_u32(1244634252)][unconst_u32(206493255)][unconst_u32(2467977609)][unconst_u32(489703073)][0];
  let ptr41: ptr<function, array<vec2h, 1>> = &out[0][unconst_u32(259293534)][0][unconst_u32(3211969451)];
}
  let ptr42: ptr<function, i32> = &(*a0)[unconst_u32(1884653700)][0];
}
case default, 59661496: {
  let ptr43: ptr<function, vec2h> = &out[0][u32(out[0][0][unconst_u32(415655018)][unconst_u32(249267795)][0][unconst_u32(489430113)])][unconst_u32(945401367)][0][0];
  out[unconst_u32(2064017116)][unconst_u32(288808960)][0][unconst_u32(963803156)][unconst_u32(150006367)] *= out[unconst_u32(746281413)][unconst_u32(1525972656)][unconst_u32(358026186)][0][unconst_u32(333413089)];
  let ptr44: ptr<function, vec2h> = &out[0][0][unconst_u32(1042260663)][0][0];
}
  }
  vp3[unconst_u32(429661742)] = modf(override5);
  (*a0)[unconst_u32(292368658)][unconst_u32(986400642)] = bitcast<i32>(out[unconst_u32(726700955)][0][0][unconst_u32(3258076546)][unconst_u32(12016541)]);
  let vf50: f16 = out[unconst_u32(125541186)][unconst_u32(772676128)][unconst_u32(166819774)][unconst_u32(1271965786)][unconst_u32(1129966514)][unconst_u32(343208834)];
  return out;
  _ = override5;
}
  let ptr45: ptr<function, vec2h> = &out[unconst_u32(90112630)][unconst_u32(159763800)][0][0][0];
  for (var it4=u32(vp3[unconst_u32(265831154)].fract); it4<(bitcast<u32>(out[0][unconst_u32(976448130)][0][u32(out[0][0][0][unconst_u32(297404207)][unconst_u32(213958712)][unconst_u32(1010015974)])][0]) & 0xfff); it4++) {
  (*a0)[bitcast<u32>(out[unconst_u32(1041110006)][unconst_u32(2762110160)][unconst_u32(1243493084)][unconst_u32(1026792857)][0])][unconst_u32(1021612283)] = bitcast<i32>(out[0][unconst_u32(1248247627)][bitcast<u32>(out[0][0][0][0][0])][0][0]);
}
  let vf51: f16 = out[0][0][0][0][unconst_u32(1048714197)][unconst_u32(142890328)];
  for (var jj85=0u; jj85<3; jj85++) { out[jj85][unconst_u32(655036209)][unconst_u32(1238030552)][unconst_u32(1003899706)][0] -= out[bitcast<u32>(out[unconst_u32(255815025)][0][unconst_u32(410949761)][unconst_u32(158792838)][unconst_u32(2525380841)])][0][unconst_u32(346375427)][unconst_u32(803651416)][unconst_u32(63913341)]; }
  vp3[unconst_u32(1638062624)].whole = out[0][unconst_u32(1090354576)][unconst_u32(74790258)][unconst_u32(64297424)][0][unconst_u32(96870534)];
  return out;
  _ = override5;
}

alias vec3b = vec3<bool>;

var<private> vp3 = array(modf(f16(6105.1)), modf(f16(6758.0)), modf(f16(20163.6)), modf(f16(10918.1)), modf(f16(6720.4)), modf(f16(20571.7)), modf(f16(17902.7)), modf(f16(26681.6)), modf(f16(4289.0)), modf(f16(14638.2)), modf(f16(3189.5)), modf(f16(33772.2)), modf(f16(22874.2)), modf(f16(12699.8)), modf(f16(18991.0)), modf(f16(-3604.2)), modf(f16(4479.6)), modf(f16(13248.8)), modf(f16(7692.5)), modf(f16(5248.8)), modf(f16(12584.2)), modf(f16(-11748.9)), modf(f16(17541.3)), modf(f16(35894.9)), modf(f16(59.91)), modf(f16(14781.7)), modf(f16(407.3)), modf(f16(16816.6)), modf(f16(16881.8)), modf(f16(30584.9)), modf(f16(1056.4)), modf(f16(4142.6)), modf(f16(19975.1)), modf(f16(6245.0)), modf(f16(567.1)), modf(f16(21905.9)), modf(f16(13005.7)), modf(f16(22975.7)), modf(f16(955.5)), modf(f16(4761.8)));

struct VertexInput19 {
  @location(5) location_5: u32,
}

/* zero global variables used */
fn fn2(a0: ptr<workgroup, atomic<u32>>) {
  let vf52: u32 = atomicLoad(&(*a0));
  atomicAdd(&(*a0), unconst_u32(543861733));
}

struct T0 {
  f0: array<u32>,
}

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

var<workgroup> vw1: array<array<vec4f, 1>, 14>;

/* zero global variables used */
@vertex
fn vertex3(a0: VertexInput17, a1: VertexInput18, a2: VertexInput19, a3: VertexInput20) -> VertexOutput2 {
  var out: VertexOutput2;
  let ptr46: ptr<private, f16> = &vp3[39].whole;
  let vf53: i32 = insertBits(unconst_i32(856657941), unconst_i32(211455111), unconst_u32(198380872), unconst_u32(324704569));
  out.location_9 = vec2u(tan(vec2h(unconst_f16(18.72), unconst_f16(20304.4))).gr.rg);
  var vf54: VertexInput17 = a0;
  let vf55: i32 = a0.location_6;
  var vf56: i32 = a0.location_1;
  out.location_11 |= vec2i(i32(vp3[bitcast<u32>(acos(vec2h(unconst_f16(25072.3), unconst_f16(16791.8))))].fract));
  var vf57: vec2f = log2(vec2f(unconst_f32(0.2525e-2), unconst_f32(-0.02233)));
  return out;
}

/* used global variables: buffer58 */
@compute @workgroup_size(1, 1, 1)
fn compute6() {
  vw1[unconst_u32(40807751)][unconst_u32(473710180)] *= vec4f(bitcast<f32>((*&buffer58)[arrayLength(&(*&buffer58))][13][unconst_u32(567799417)].location_6));
  let ptr47: ptr<storage, VertexInput17, read> = &(*&buffer58)[unconst_u32(544368719)][unconst_u32(590715266)][unconst_u32(328569523)];
  let ptr48: ptr<storage, vec2f, read> = &buffer58[unconst_u32(75522489)][unconst_u32(1907174087)][unconst_u32(521252854)].location_11;
  let ptr49: ptr<storage, vec2i, read> = &(*ptr47).location_10;
  _ = buffer58;
}`,
});
let texture72 = device0.createTexture({
  size: [1, 270, 227],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder10.setBindGroup(1, bindGroup19);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer9, 4);
} catch {}
try {
renderPassEncoder2.popDebugGroup();
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
let textureView61 = texture14.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder14.setBindGroup(1, bindGroup21);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder3.draw(3, 23, 5, 3_013_257_289);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 22, 0, 9_382_838, 1_375_235_163);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup21);
} catch {}
try {
renderBundleEncoder5.drawIndirect(buffer46, 4);
} catch {}
let bindGroup24 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let buffer59 = device0.createBuffer({
  label: '\ud855\u32ef\u02b3\u{1fd60}',
  size: 403,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
  mappedAtCreation: false,
});
let commandEncoder77 = device0.createCommandEncoder({});
let textureView62 = texture3.createView({mipLevelCount: 1});
let renderPassEncoder10 = commandEncoder56.beginRenderPass({
  colorAttachments: [{
  view: textureView43,
  depthSlice: 63,
  clearValue: { r: 218.6, g: 110.9, b: -922.5, a: -72.84, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], stencilReadOnly: true});
try {
renderPassEncoder3.draw(4, 107, 1, 1_289_760_414);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 87, 0, 451_725_518, 242_608_490);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer38, 'uint16', 0, 2);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer18, 'uint16', 10, 13);
} catch {}
try {
buffer42.unmap();
} catch {}
let sampler12 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  lodMaxClamp: 52.97,
  maxAnisotropy: 1,
});
try {
computePassEncoder14.setBindGroup(1, bindGroup19, new Uint32Array(3379), 679, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder3.draw(1, 381, 0, 331_559_724);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer6, 8);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer20, 0);
} catch {}
try {
renderBundleEncoder5.draw(0, 180, 0, 763_669_723);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer59.unmap();
} catch {}
try {
computePassEncoder0.insertDebugMarker('\u27cd');
} catch {}
let commandEncoder78 = device0.createCommandEncoder({});
let renderBundle0 = renderBundleEncoder5.finish({});
try {
computePassEncoder1.setBindGroup(0, bindGroup21);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer59, 32); };
} catch {}
try {
renderPassEncoder3.draw(5, 136, 4, 1_228_995_611);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer7, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
document.body.append(canvas1);
let shaderModule5 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

enable f16;

diagnostic(info, xyz);

struct VertexOutput3 {
  @location(8) @interpolate(perspective, either) location_8: vec2f,
  @builtin(position) position: vec4f,
  @location(2) @interpolate(perspective, either) location_2: vec4h,
  @location(4) location_4: i32,
  @location(9) location_9: vec2h,
  @location(6) @interpolate(flat, either) location_6: vec4u,
  @location(10) @interpolate(flat, first) location_10: vec4i,
}

@id(21556) override override6 = 0.03631e-36;

@group(1) @binding(529) var tex4: texture_3d<i32>;

/* used global variables: buffer64, tex4 */
fn fn0(a0: ptr<storage, array<array<u32, 1>, 90>, read>) {
  _ = tex4;
  vp4 = vec4u(vec4u(unconst_u32(2559613405), unconst_u32(115450726), unconst_u32(117186187), unconst_u32(719637325)));
  let ptr50: ptr<storage, u32, read> = &(*a0)[unconst_u32(1628174268)][0];
  if bool((vec2u(dot4U8Packed(unconst_u32(125696283), unconst_u32(451361125))) & vec2u(unconst_u32(692094500), unconst_u32(736379347)))[0]) {
  vp4 |= vec4u(unpack4x8snorm(unconst_u32(482392887)).wyxw.zyzy);
}
  var vf58: vec3u = textureDimensions(tex4);
  let ptr51: ptr<uniform, vec4i> = &buffer64.location_1;
  vp5.fract += vec2h( !vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true), unconst_bool(true)).bg);
  _ = tex4;
  _ = buffer64;
}

struct FragmentInput3 {
  @location(3) location_3: i32,
  @location(8) @interpolate(linear) location_8: vec4f,
}

@group(1) @binding(4) var<storage, read_write> buffer63: array<array<vec2i, 52>>;

var<private> vp5 = frexp(vec2h(3468.6, 11843.2));

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

@group(3) @binding(56) var tex5: texture_2d<f32>;

var<private> vp4: vec4u = vec4u(1107374701, 599571520, 273594583, 326661003);

@group(0) @binding(191) var<uniform> buffer61: array<array<array<array<vec4i, 1>, 2>, 2>, 79>;

@id(37605) override override8: bool;

@id(43506) override override9: f32;

@group(2) @binding(133) var<storage, read> buffer65: array<array<FragmentInput6, 7>, 32>;

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

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

struct FragmentOutput1 {
  @builtin(sample_mask) sample_mask: u32,
  @location(3) @interpolate(flat, sample) location_3: vec2i,
  @location(4) @interpolate(flat, sample) location_4: u32,
  @location(0) location_0: vec2i,
}

struct FragmentInput0 {
  @location(5) @interpolate(flat, centroid) location_5: f32,
  @location(4) location_4: vec4f,
  @location(7) location_7: i32,
}

/* used global variables: buffer61, buffer63, buffer65 */
fn fn2(a0: array<array<array<vec2f, 1>, 1>, 2>, a1: array<array<array<vec4h, 5>, 1>, 1>) {
  buffer63[unconst_u32(2532803136)][unconst_u32(968770617)] *= (*&buffer61)[78][1][1][0].wz;
  let ptr57: ptr<uniform, vec4i> = &(*&buffer61)[unconst_u32(767359380)][1][pack4xI8(buffer61[unconst_u32(268979811)][1][vec2u(a0[pack4xI8(buffer61[78][unconst_u32(206078655)][unconst_u32(110450383)][unconst_u32(732387434)])][unconst_u32(536753104)][0].xy).r][0])][vec2u((*&buffer63)[arrayLength(&(*&buffer63))][51]).y];
  vp4 |= vec4u((*&buffer65)[31][unconst_u32(848598440)].location_9.grrr.grbb.zyzx);
  {
  let vf61: vec4h = a1[0][0][unconst_u32(1070506619)];
  vp4 -= unpack4xU8(bitcast<u32>(buffer61[78][1][1][unconst_u32(854756331)][unconst_u32(580475704)]));
  buffer63[unconst_u32(750204394)][unconst_u32(277933091)] += buffer61[unconst_u32(117683923)][unconst_u32(646644001)][unconst_u32(177573860)][0].zz;
  return;
  _ = buffer63;
  _ = buffer61;
}
  _ = buffer61;
  _ = buffer65;
  _ = buffer63;
}

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

struct VertexInput22 {
  @location(1) location_1: vec4u,
  @location(13) location_13: u32,
  @location(7) location_7: vec4h,
  @location(0) location_0: vec4h,
}

/* used global variables: buffer63, buffer64, tex5 */
@must_use 
fn fn3(a0: ptr<uniform, vec4i>, a1: ptr<uniform, vec4i>) -> array<array<array<vec2u, 7>, 1>, 1> {
  var out: array<array<array<vec2u, 7>, 1>, 1>;
  let vf62: f32 = abs(unconst_f32(0.3170e-23));
  let vf63: vec2u = textureDimensions(tex5);
  out[unconst_u32(360917782)][unconst_u32(313004923)][unconst_u32(3229311256)] <<= vec2u(u32((*a1)[unconst_u32(19897267)]));
  out[unconst_u32(349632611)][unconst_u32(2667696041)][unconst_u32(71602495)] |= bitcast<vec2u>(buffer64.location_1.ba.rg.gg);
  buffer63[unconst_u32(184515449)][vp4[unconst_u32(481146495)]] = buffer63[unconst_u32(662883260)][unconst_u32(594431077)];
  for (var jj49=0u; jj49<54; jj49++) { buffer63[unconst_u32(76983422)][jj49] ^= vec2i(i32(arrayLength(&(*&buffer63)))); }
  let ptr58: ptr<storage, array<vec2i, 52>, read_write> = &(*&buffer63)[unconst_u32(1853509256)];
  out[unconst_u32(1846031946)][unconst_u32(638116529)][out[0][0][6][1]] >>= vec2u((*&buffer63)[arrayLength(&(*&buffer63))][51].gr);
  return out;
  _ = tex5;
  _ = buffer63;
  _ = buffer64;
}

override override7: f16 = -647.7;

/* used global variables: buffer61, buffer63 */
fn fn1(a0: vec4i) {
  let ptr52: ptr<uniform, array<vec4i, 1>> = &(*&buffer61)[unconst_u32(657092590)][unconst_u32(88402615)][1];
  vp5 = frexp(vec2h((*&buffer63)[arrayLength(&(*&buffer63))][51].yx.rg.gg.rr.rr));
  var vf59: i32 = (*ptr52)[0][unconst_u32(391170869)];
  buffer63[vec4u(buffer61[unconst_u32(2279344335)][unconst_u32(451049334)][1][unconst_u32(162141373)].rraa).z][bitcast<u32>((*&buffer61)[78][unconst_u32(56932688)][1][0][3])] = vec2i(buffer61[unconst_u32(579978466)][1][unconst_u32(371365881)][0][unconst_u32(1067009348)]);
  let ptr53: ptr<uniform, array<vec4i, 1>> = &buffer61[pack4xU8(vec4u(buffer61[78][unconst_u32(281353829)][1][unconst_u32(327876091)]))][u32(buffer61[78][1][unconst_u32(597756175)][unconst_u32(35483338)][unconst_u32(111376219)])][unconst_u32(374891497)];
  let ptr54: ptr<storage, array<array<vec2i, 52>>, read_write> = &(*&buffer63);
  var vf60: i32 = buffer63[arrayLength(&buffer63)][unconst_u32(8643174)][unconst_u32(194468302)];
  let ptr55: ptr<uniform, vec4i> = &buffer61[78][1][unconst_u32(530550444)][0];
  let ptr56: ptr<storage, array<vec2i, 52>, read_write> = &(*&buffer63)[unconst_u32(319102948)];
  return;
  _ = buffer61;
  _ = buffer63;
}

struct FragmentInput5 {
  @location(15) location_15: vec4h,
}

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

@group(1) @binding(100) var<uniform> buffer64: FragmentInput1;

@group(0) @binding(7) var<storage, read> buffer60: array<array<array<u32, 1>, 90>>;

alias vec3b = vec3<bool>;

struct FragmentInput4 {
  @location(6) location_6: u32,
}

struct T0 {
  @size(8) f0: bool,
  f1: array<vec4u, 1>,
  @size(64) f2: array<array<array<vec4i, 2>, 1>, 1>,
}

@group(1) @binding(1) var<storage, read_write> buffer62: array<array<array<array<array<array<f16, 1>, 1>, 64>, 1>, 4>>;

struct T1 {
  f0: array<u32>,
}

struct FragmentInput2 {
  @location(14) @interpolate(flat, first) location_14: u32,
  @location(2) location_2: vec4f,
}

struct FragmentInput1 {
  @location(1) location_1: vec4i,
}

struct FragmentInput6 {
  @location(9) location_9: vec2h,
}

struct VertexInput21 {
  @builtin(instance_index) instance_index: u32,
}

/* used global variables: buffer60, buffer61, buffer64, tex4 */
@vertex
fn vertex4(a0: VertexInput21, a1: VertexInput22) -> VertexOutput3 {
  var out: VertexOutput3;
  out.location_4 = (*&buffer61)[unconst_u32(585748554)][unconst_u32(351694581)][1][unconst_u32(1842043605)].b;
  out = VertexOutput3(vec2f(bitcast<f32>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0])), vec4f(bitcast<f32>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0])), vec4h(f16(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0])), bitcast<i32>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0]), bitcast<vec2h>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0]), unpack4xU8(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0]), vec4i(bitcast<i32>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0])));
  out.location_8 = vec2f(buffer61[unconst_u32(21720692)][unconst_u32(1216766385)][1][0].ww);
  out.location_10 += (*&buffer61)[unconst_u32(71424114)][unconst_u32(271860007)][unconst_u32(744411416)][0];
  fn0(&buffer60[arrayLength(&buffer60) - 1]);
  out.location_2 = vec4h(buffer61[buffer60[arrayLength(&buffer60)][89][unconst_u32(208455537)]][1][unconst_u32(2086612483)][unconst_u32(401482150)]);
  let vf64: mat3x4h = transpose(mat4x3h(unconst_f16(10122.3), unconst_f16(19236.1), unconst_f16(37673.1), unconst_f16(3413.0), unconst_f16(18937.4), unconst_f16(12792.5), unconst_f16(323.8), unconst_f16(31733.2), unconst_f16(5117.2), unconst_f16(5505.8), unconst_f16(21953.8), unconst_f16(14413.4)));
  {
  let ptr59: ptr<uniform, array<vec4i, 1>> = &(*&buffer61)[78][1][1];
  fn0(&(*&buffer60)[buffer61[unconst_u32(779649112)][unconst_u32(719879489)][1][0][0]]);
  let ptr60: ptr<uniform, vec4i> = &(*&buffer61)[78][unconst_u32(23535237)][unconst_u32(493990147)][0];
  out.location_9 *= vec2h(buffer61[unconst_u32(575022502)][1][unconst_u32(32409783)][0].ar.rr.gg);
  out.location_10 = bitcast<vec4i>(out.location_6.xwzz.yzzw.wwyx);
  fn0(&(*&buffer60)[unconst_u32(115513722)]);
  _ = buffer64;
  _ = tex4;
  _ = buffer60;
  _ = buffer61;
}
  return out;
  _ = tex4;
  _ = buffer61;
  _ = buffer60;
  _ = buffer64;
}

/* used global variables: buffer62, buffer63, buffer64, tex5 */
@fragment
fn fragment1(a0: FragmentInput0, @location(0) @interpolate(flat, first) location_0: vec2u, a2: FragmentInput1, a3: FragmentInput2, @builtin(sample_mask) sample_mask: u32, a5: FragmentInput3, a6: FragmentInput4, a7: FragmentInput5, a8: FragmentInput6) -> FragmentOutput1 {
  var out: FragmentOutput1;
  if bool(buffer62[arrayLength(&buffer62)][3][0][63][0][0]) {
  out = FragmentOutput1(u32((*&buffer62)[arrayLength(&(*&buffer62))][3][unconst_u32(509513955)][63][0][0]), vec2i(i32((*&buffer62)[arrayLength(&(*&buffer62))][3][unconst_u32(509513955)][63][0][0])), u32((*&buffer62)[arrayLength(&(*&buffer62))][3][unconst_u32(509513955)][63][0][0]), vec2i(i32((*&buffer62)[arrayLength(&(*&buffer62))][3][unconst_u32(509513955)][63][0][0])));
  _ = fn3(&buffer64.location_1, &buffer64.location_1);
  if bool((*&buffer62)[unconst_u32(817402231)][unconst_u32(186143889)][unconst_u32(2348032439)][unconst_u32(461064918)][unconst_u32(513819711)][0]) {
  buffer63[unconst_u32(1107044345)][unconst_u32(486273355)] -= vec2i(i32(buffer62[arrayLength(&buffer62)][location_0[unconst_u32(569181908)]][u32((*&buffer62)[unconst_u32(1772766578)][3][0][63][0][0])][unconst_u32(534467110)][unconst_u32(53559296)][unconst_u32(24067885)]));
  _ = buffer62;
  _ = buffer63;
}
  _ = buffer62;
  _ = buffer64;
  _ = tex5;
  _ = buffer63;
}
  _ = fn3(&buffer64.location_1, &buffer64.location_1);
  out.location_0 = vec2i(i32((*&buffer62)[arrayLength(&(*&buffer62))][unconst_u32(2125720084)][unconst_u32(1328261186)][63][unconst_u32(364727558)][0]));
  let ptr61: ptr<storage, f16, read_write> = &buffer62[unconst_u32(1937642675)][3][0][63][0][0];
  var vf65 = fn3(&(*&buffer64).location_1, &(*&buffer64).location_1);
  let ptr62: ptr<storage, f16, read_write> = &buffer62[unconst_u32(389617986)][unconst_u32(168975154)][0][unconst_u32(608704435)][unconst_u32(714712308)][0];
  let vf66: f32 = a0.location_5;
  let ptr63: ptr<storage, f16, read_write> = &(*&buffer62)[unconst_u32(1695047200)][3][0][63][unconst_u32(1716267731)][unconst_u32(931439346)];
  vp5 = frexp(vec2h(buffer62[unconst_u32(540404659)][3][0][unconst_u32(443041094)][unconst_u32(1050836798)][0]));
  return out;
  _ = buffer64;
  _ = buffer62;
  _ = tex5;
  _ = buffer63;
}`,
});
try {
renderPassEncoder3.draw(1, 327, 1, 77_785_674);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 65, 0, 485_282_689, 1_460_077_025);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer6, 'uint16', 8, 20);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer38, 'uint32', 0, 1);
} catch {}
let commandEncoder79 = device0.createCommandEncoder();
let textureView63 = texture9.createView({dimension: '1d'});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder10.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer48, 16);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer46, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(7, buffer12, 148);
} catch {}
try {
commandEncoder53.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2496 */
  offset: 2496,
  buffer: buffer7,
}, {
  texture: texture14,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData7 = new ImageData(8, 8);
let bindGroup25 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 4, resource: {buffer: buffer49}},
    {binding: 515, resource: sampler2},
    {binding: 100, resource: {buffer: buffer14, size: 88}},
    {binding: 1, resource: {buffer: buffer49, offset: 1024, size: 604}},
    {binding: 529, resource: textureView43},
  ],
});
let buffer66 = device0.createBuffer({
  size: 124,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
let commandEncoder80 = device0.createCommandEncoder();
let texture73 = device0.createTexture({
  size: {width: 75},
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView64 = texture37.createView({});
try {
computePassEncoder22.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 4, 0, -1_890_034_363, 188_406_115);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer39, 0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup14, new Uint32Array(3212), 631, 0);
} catch {}
let pipelineLayout5 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout1, recycledExplicitBindGroupLayout3, veryExplicitBindGroupLayout4],
});
let commandEncoder81 = device0.createCommandEncoder({});
try {
computePassEncoder8.setBindGroup(1, bindGroup24, new Uint32Array(607), 36, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup15, new Uint32Array(80), 2, 0);
} catch {}
try {
renderPassEncoder1.draw(2, 257, 0, 146_666_590);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer59, 212);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(7, buffer20, 4, 0);
} catch {}
try {
commandEncoder71.copyTextureToTexture({
  texture: texture70,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture65,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 23},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer67 = device0.createBuffer({size: 464, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let texture74 = device0.createTexture({
  size: {width: 1},
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder1.drawIndexed(1, 338, 0, -1_878_480_840, 59_592_201);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer6, 28);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 4, new Uint32Array(9793).map((_, i) => i * 7), 1687, 0);
} catch {}
try {
globalThis.someLabel = commandEncoder2.label;
} catch {}
let buffer68 = device0.createBuffer({size: 280, usage: GPUBufferUsage.INDIRECT});
let texture75 = device0.createTexture({size: [75, 1, 51], mipLevelCount: 2, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING});
try {
computePassEncoder22.setBindGroup(1, bindGroup21);
} catch {}
try {
computePassEncoder9.end();
} catch {}
try {
renderPassEncoder1.draw(2, 250, 0, 802_742_838);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer6, 24);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer20);
} catch {}
let buffer69 = device0.createBuffer({size: 308, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder82 = device0.createCommandEncoder();
try {
computePassEncoder10.setBindGroup(1, bindGroup24, []);
} catch {}
try {
computePassEncoder18.setBindGroup(1, bindGroup21, new Uint32Array(3718), 137, 0);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer48, 4);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer18, 'uint32', 20, 1);
} catch {}
try {
buffer10.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Float32Array(8907).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.5702)), 5240, 0);
} catch {}
let bindGroup26 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let commandEncoder83 = device0.createCommandEncoder({});
let texture76 = device0.createTexture({
  size: [1, 540, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView65 = texture11.createView({mipLevelCount: 1});
try {
computePassEncoder8.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup26);
} catch {}
try {
renderPassEncoder1.drawIndexed(1, 206, 0, 1_052_041_101, 471_414_136);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer17, 32);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(0, buffer27, 28, 16);
} catch {}
try {
buffer27.unmap();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(13); };
} catch {}
await gc();
let bindGroup27 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 8, resource: textureView7},
    {binding: 1, resource: textureView16},
    {binding: 56, resource: textureView1},
    {binding: 591, resource: textureView38},
  ],
});
try {
computePassEncoder19.setBindGroup(0, bindGroup26);
} catch {}
try {
computePassEncoder0.setBindGroup(2, bindGroup24, new Uint32Array(1596), 151, 0);
} catch {}
try {
renderPassEncoder1.draw(2, 122, 0, 415_560_624);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup26);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\ub375');
} catch {}
let bindGroup28 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: []});
let buffer70 = device0.createBuffer({size: 200, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let textureView66 = texture12.createView({mipLevelCount: 1, baseArrayLayer: 13, arrayLayerCount: 4});
try {
renderPassEncoder1.draw(2, 202, 0, 1_771_435_196);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer49, 1_096);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer59, 236);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline10);
} catch {}
try {
commandEncoder8.copyBufferToBuffer(buffer50, 4, buffer13, 0, 12);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas0);
let buffer71 = device0.createBuffer({
  size: 136,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder84 = device0.createCommandEncoder({});
let externalTexture3 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
computePassEncoder23.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup19, new Uint32Array(286), 8, 0);
} catch {}
try {
renderPassEncoder1.draw(2, 298, 0, 348_078_519);
} catch {}
try {
renderPassEncoder1.drawIndexed(1, 69, 0, 955_674_122, 799_428_228);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer48, 20);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer4, 0, 2);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 20, new Float16Array(7956).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.8646)), 2038, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: offscreenCanvas1,
  origin: { x: 44, y: 1023 },
  flipY: false,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(28); };
} catch {}
await gc();
let textureView67 = texture43.createView({baseArrayLayer: 0});
let sampler13 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', lodMaxClamp: 93.91});
try {
computePassEncoder6.setBindGroup(2, bindGroup21, new Uint32Array(6489), 225, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup24, new Uint32Array(2606), 1_024, 0);
} catch {}
try {
renderPassEncoder1.draw(2, 109, 0, 153_638_795);
} catch {}
try {
renderPassEncoder1.drawIndexed(1, 24, 0, 251_621_015, 1_357_785_106);
} catch {}
try {
renderBundleEncoder11.setBindGroup(2, bindGroup21, new Uint32Array(1757), 138, 0);
} catch {}
let buffer72 = device0.createBuffer({size: 257, usage: GPUBufferUsage.COPY_DST});
let commandBuffer2 = commandEncoder27.finish();
let texture77 = device0.createTexture({
  size: [37, 1, 1],
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture4 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
computePassEncoder5.setBindGroup(2, bindGroup19, new Uint32Array(1236), 935, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup2, new Uint32Array(980), 299, 0);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer71, 4);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup0, []);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(1, buffer48, 0, 75);
} catch {}
try {
commandEncoder39.resolveQuerySet(querySet0, 2, 0, buffer12, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup29 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let texture78 = device0.createTexture({
  size: [90, 24, 231],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup24, new Uint32Array(274), 1, 0);
} catch {}
try {
renderPassEncoder1.drawIndexed(1, 471, 0, 67_954_548, 1_940_742_059);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer46, 4);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer48, 68);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup2);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(2, buffer3, 28);
} catch {}
let commandBuffer3 = commandEncoder19.finish();
let textureView68 = texture66.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder1.drawIndexedIndirect(buffer71, 16);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer19, 'uint16', 42, 6);
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture43,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 6},
  aspect: 'all',
},
{
  texture: texture45,
  mipLevel: 1,
  origin: {x: 0, y: 14, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder12.pushDebugGroup('\u0d87');
} catch {}
try {
commandEncoder54.insertDebugMarker('\u0f9c');
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
let commandEncoder85 = device0.createCommandEncoder({});
let textureView69 = texture77.createView({aspect: 'all'});
let renderPassEncoder11 = commandEncoder84.beginRenderPass({
  colorAttachments: [{view: textureView43, depthSlice: 31, loadOp: 'clear', storeOp: 'discard'}],
  timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 8},
});
try {
renderPassEncoder0.setBindGroup(2, bindGroup24);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup14, new Uint32Array(356), 73, 0);
} catch {}
try {
renderPassEncoder1.draw(2, 40, 0, 131_691_143);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer49, 1_592);
} catch {}
try {
commandEncoder59.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 5264 */
  offset: 5264,
  bytesPerRow: 16640,
  buffer: buffer37,
}, {
  texture: texture66,
  mipLevel: 0,
  origin: {x: 0, y: 19, z: 0},
  aspect: 'all',
}, {width: 0, height: 8, depthOrArrayLayers: 0});
} catch {}
let videoFrame5 = new VideoFrame(canvas0, {timestamp: 0});
let bindGroup30 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let commandEncoder86 = device0.createCommandEncoder({});
let texture79 = device0.createTexture({
  size: [37, 1, 6],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView70 = texture37.createView({baseMipLevel: 0});
try {
renderPassEncoder1.end();
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup3, []);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup15, new Uint32Array(1005), 52, 0);
} catch {}
try {
renderBundleEncoder0.draw(312, 137, 70, 405_401_975);
} catch {}
try {
commandEncoder77.copyBufferToBuffer(buffer33, 1876, buffer7, 152, 672);
} catch {}
let pipeline11 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4, constants: {}}});
let texture80 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView71 = texture74.createView({mipLevelCount: 1, baseArrayLayer: 0});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], stencilReadOnly: true});
try {
computePassEncoder8.setBindGroup(0, bindGroup28);
} catch {}
try {
computePassEncoder14.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer20, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup21);
} catch {}
try {
buffer25.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer43, 8, new Float32Array(26320).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.4924)), 1796, 4);
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
let pipeline12 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule2, constants: {}}});
try {
adapter0.label = '\u9cc6\ubd5d\ub4d6\u07dc\u09a9';
} catch {}
let commandEncoder87 = device0.createCommandEncoder({});
let textureView72 = texture80.createView({});
let textureView73 = texture48.createView({dimension: '3d'});
try {
computePassEncoder1.setBindGroup(2, bindGroup21, new Uint32Array(109), 13, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer19, 'uint32', 0, 6);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(3, buffer27, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer6, 'uint32', 8, 16);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(6, buffer39, 0, 17);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Float32Array(9596).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.530)), 2581, 0);
} catch {}
let canvas2 = document.createElement('canvas');
let bindGroup31 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let textureView74 = texture78.createView({dimension: '3d'});
let textureView75 = texture71.createView({dimension: '3d', mipLevelCount: 1});
try {
computePassEncoder17.setBindGroup(2, bindGroup26, new Uint32Array(2003), 230, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer70, 'uint16', 4, 44);
} catch {}
try {
renderBundleEncoder0.drawIndexedIndirect(buffer39, 12);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer18, 'uint32', 4, 2);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(1, buffer7, 0);
} catch {}
try {
commandEncoder60.copyBufferToTexture({
  /* bytesInLastRow: 76 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1084 */
  offset: 1084,
  bytesPerRow: 7168,
  buffer: buffer7,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext2 = canvas2.getContext('webgpu');
let texture81 = device0.createTexture({
  size: [1, 540, 1],
  sampleCount: 4,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle1 = renderBundleEncoder0.finish({});
try {
renderPassEncoder8.setVertexBuffer(4, buffer31, 28, 1);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(5, buffer17);
} catch {}
let textureView76 = texture81.createView({});
let textureView77 = texture5.createView({aspect: 'all', format: 'rgba16sint', arrayLayerCount: 1});
let computePassEncoder24 = commandEncoder21.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder24.setPipeline(pipeline12);
} catch {}
let imageData8 = new ImageData(36, 148);
let bindGroup32 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 2, resource: {buffer: buffer49}}]});
let textureView78 = texture52.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder21.setBindGroup(0, bindGroup26);
} catch {}
try {
computePassEncoder17.end();
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer20);
} catch {}
let pipeline13 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x1582de47},
  fragment: {
  module: shaderModule2,
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'constant'},
    alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'zero'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  vertex: {
    module: shaderModule5,
    buffers: [
      {
        arrayStride: 80,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 8, shaderLocation: 7},
          {format: 'uint16x4', offset: 0, shaderLocation: 13},
          {format: 'uint16x2', offset: 0, shaderLocation: 1},
          {format: 'unorm10-10-10-2', offset: 16, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'back'},
});
let imageData9 = new ImageData(52, 24);
let bindGroup33 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [{binding: 133, resource: {buffer: buffer49, offset: 0}}],
});
let commandEncoder88 = device0.createCommandEncoder({});
let texture82 = device0.createTexture({
  size: {width: 7, height: 1, depthOrArrayLayers: 1},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView79 = texture49.createView({format: 'rg32uint', baseArrayLayer: 15, arrayLayerCount: 2});
try {
renderPassEncoder5.drawIndexed(8, 67, 35, -1_934_032_568, 87_408_877);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer34, 'uint16', 0, 0);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(12); };
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'film', transfer: 'gamma22curve'} });
try {
renderPassEncoder2.setIndexBuffer(buffer48, 'uint32', 8, 46);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup30, new Uint32Array(3793), 820, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Float16Array(2743).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.090)), 126, 0);
} catch {}
document.body.prepend(canvas0);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let recycledExplicitBindGroupLayout5 = pipeline2.getBindGroupLayout(2);
try {
renderPassEncoder5.draw(0, 330, 0, 563_221_930);
} catch {}
try {
renderPassEncoder5.drawIndexed(27, 72, 13, 443_611_004, 105_274_577);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer18, 'uint16', 18, 0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup31);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup6, new Uint32Array(2983), 126, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
let bindGroup34 = device0.createBindGroup({
  label: '\u{1f7d4}\ub040\ufc7c\uc20f\u0723\uec7c\u1404\u{1fd10}\ubbd3',
  layout: veryExplicitBindGroupLayout13,
  entries: [{binding: 2, resource: {buffer: buffer49, size: 3420}}],
});
let commandEncoder89 = device0.createCommandEncoder({});
let textureView80 = texture26.createView({label: '\u{1f748}\u70fe\u93d1\u084f\u6cd3\ud784\u0e89\u30fb', mipLevelCount: 1});
try {
computePassEncoder6.setBindGroup(1, bindGroup33, []);
} catch {}
try {
renderPassEncoder5.draw(0, 2, 0, 381_591_728);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer3);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(0, buffer12, 20);
} catch {}
try {
commandEncoder83.pushDebugGroup('\u015b');
} catch {}
let imageData10 = new ImageData(48, 12);
let bindGroup35 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: []});
let texture83 = device0.createTexture({size: [150, 1, 1], mipLevelCount: 4, sampleCount: 1, format: 'rg8sint', usage: GPUTextureUsage.COPY_SRC});
let textureView81 = texture61.createView({});
try {
computePassEncoder18.setBindGroup(0, bindGroup33);
} catch {}
try {
computePassEncoder12.setBindGroup(2, bindGroup19, new Uint32Array(1033), 4, 0);
} catch {}
try {
renderPassEncoder5.draw(0, 10, 0, 1_854_216_094);
} catch {}
try {
renderPassEncoder5.drawIndexed(65, 27, 2, 494_638_579, 107_809_935);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer71, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer49, 'uint16', 260, 2_777);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline3);
} catch {}
try {
buffer32.unmap();
} catch {}
try {
renderBundleEncoder18.insertDebugMarker('\u{1ff55}');
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(66); };
} catch {}
let texture84 = device0.createTexture({
  size: {width: 60},
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup21, new Uint32Array(2586), 107, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer6, 32);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer67, 'uint32', 36, 38);
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let autogeneratedBindGroupLayout1 = pipeline11.getBindGroupLayout(0);
let bindGroup36 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let commandEncoder90 = device0.createCommandEncoder({});
try {
renderPassEncoder5.draw(0, 67, 0, 708_912_919);
} catch {}
try {
renderPassEncoder5.drawIndexed(112, 38, 77, 1_521_623_631, 197_954_148);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer6, 12);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup18, new Uint32Array(784), 84, 0);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer0, 0, 0);
} catch {}
try {
commandEncoder64.copyBufferToBuffer(buffer2, 0, buffer43, 0, 12);
} catch {}
try {
commandEncoder54.clearBuffer(buffer46, 0, 20);
} catch {}
try {
  await promise14;
} catch {}
let textureView82 = texture11.createView({mipLevelCount: 1});
let renderPassEncoder12 = commandEncoder39.beginRenderPass({
  colorAttachments: [{
  view: textureView56,
  clearValue: { r: -452.4, g: -726.3, b: -718.8, a: -959.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder24.setBindGroup(0, bindGroup33);
} catch {}
try {
computePassEncoder10.setBindGroup(2, bindGroup29, new Uint32Array(1907), 90, 0);
} catch {}
try {
computePassEncoder24.dispatchWorkgroupsIndirect(buffer9, 0);
} catch {}
try {
renderPassEncoder5.draw(0, 13, 0, 1_512_392_146);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup31, new Uint32Array(658), 14, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer70, 'uint16', 26, 46);
} catch {}
try {
commandEncoder65.resolveQuerySet(querySet1, 19, 1, buffer26, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture44,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise13;
} catch {}
let textureView83 = texture81.createView({baseMipLevel: 0});
let texture85 = device0.createTexture({
  size: {width: 1, height: 540, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder5.setBindGroup(1, bindGroup33);
} catch {}
try {
renderBundleEncoder12.popDebugGroup();
} catch {}
let commandEncoder91 = device0.createCommandEncoder({});
let texture86 = device0.createTexture({size: [90, 24, 1], sampleCount: 1, format: 'r8unorm', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
let textureView84 = texture1.createView({});
let renderPassEncoder13 = commandEncoder48.beginRenderPass({
  label: '\u88cb\u{1fe12}\u4194\u097e\u{1f82c}\u054c\uf627',
  colorAttachments: [{
  view: textureView57,
  clearValue: { r: 817.2, g: 764.6, b: -513.8, a: 538.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder20.setBindGroup(2, bindGroup19);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder5.drawIndexed(179, 120, 246, 801_866_339, 932_873_608);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer48, 12);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup19, new Uint32Array(1068), 33, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 380, new Uint16Array(5041).map((_, i) => i + 4), 2237);
} catch {}
let computePassEncoder25 = commandEncoder51.beginComputePass();
let promise15 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: imageData4,
  origin: { x: 21, y: 0 },
  flipY: true,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline14 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout4,
  fragment: {module: shaderModule2, targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.GREEN}]},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 80,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 12, shaderLocation: 11},
          {format: 'float32x2', offset: 16, shaderLocation: 7},
          {format: 'sint8x2', offset: 6, shaderLocation: 4},
          {format: 'sint32x4', offset: 48, shaderLocation: 10},
          {format: 'snorm8x2', offset: 0, shaderLocation: 2},
          {format: 'float16x4', offset: 16, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 4,
        attributes: [
          {format: 'sint8x4', offset: 0, shaderLocation: 6},
          {format: 'uint32', offset: 0, shaderLocation: 3},
          {format: 'sint8x4', offset: 0, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 64,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x4', offset: 20, shaderLocation: 0},
          {format: 'uint8x4', offset: 24, shaderLocation: 5},
        ],
      },
    ],
  },
});
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1, 2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer68, 32); };
} catch {}
try {
computePassEncoder25.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup19, new Uint32Array(1225), 142, 0);
} catch {}
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer67, 'uint16', 28, 21);
} catch {}
try {
buffer71.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let textureView85 = texture71.createView({mipLevelCount: 1});
try {
computePassEncoder11.setBindGroup(1, bindGroup29, new Uint32Array(3009), 110, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer71, 0, 23);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer49, 'uint32', 1_452, 1_251);
} catch {}
try {
buffer50.unmap();
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let commandEncoder92 = device0.createCommandEncoder({});
let texture87 = device0.createTexture({
  size: [1, 1080, 237],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture88 = device0.createTexture({
  size: [180, 48, 462],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView86 = texture62.createView({mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup12, new Uint32Array(314), 5, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup10);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
} catch {}
let commandEncoder93 = device0.createCommandEncoder({});
let renderPassEncoder14 = commandEncoder70.beginRenderPass({
  colorAttachments: [{
  view: textureView31,
  clearValue: { r: 75.70, g: -932.5, b: 794.8, a: -832.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 4},
});
let sampler14 = device0.createSampler({addressModeV: 'mirror-repeat', compare: 'greater-equal'});
try {
renderPassEncoder2.setPipeline(pipeline14);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder94 = device0.createCommandEncoder({});
let texture89 = device0.createTexture({
  size: [7, 1, 1],
  sampleCount: 4,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer39, 0); };
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(4, buffer20, 0, 2);
} catch {}
try {
renderPassEncoder13.insertDebugMarker('\u1473');
} catch {}
let pipeline15 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0}});
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'bt2020_10bit'} });
let bindGroup37 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout4,
  entries: [{binding: 133, resource: {buffer: buffer49, offset: 1280}}],
});
let texture90 = device0.createTexture({
  size: [1, 135, 1],
  sampleCount: 4,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder15 = commandEncoder52.beginRenderPass({
  colorAttachments: [{
  view: textureView56,
  clearValue: { r: -715.6, g: -55.17, b: 352.1, a: 559.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder14.setBindGroup(2, bindGroup24);
} catch {}
try {
computePassEncoder11.setBindGroup(1, bindGroup33, new Uint32Array(10000), 3_365, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(0);
} catch {}
try {
device0.queue.writeBuffer(buffer71, 16, new DataView(new ArrayBuffer(65676)), 1134, 4);
} catch {}
let autogeneratedBindGroupLayout2 = pipeline11.getBindGroupLayout(0);
let textureView87 = texture90.createView({label: '\u3d45\u2320\u78b9\u5d9f\uf18e\u0764\u6ba7\u23ff'});
let texture91 = device0.createTexture({
  size: [64, 64, 188],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r8unorm'],
});
let textureView88 = texture69.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer49, 1_076); };
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer31);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(0, buffer4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: imageData1,
  origin: { x: 2, y: 1 },
  flipY: false,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView89 = texture78.createView({dimension: '3d', arrayLayerCount: 1});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], depthReadOnly: true});
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline13);
} catch {}
try {
commandEncoder73.copyBufferToTexture({
  /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 48 */
  offset: 48,
  buffer: buffer40,
}, {
  texture: texture77,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData11 = new ImageData(12, 4);
try {
computePassEncoder23.setBindGroup(0, bindGroup24);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroups(1); };
} catch {}
try {
buffer6.unmap();
} catch {}
let imageData12 = new ImageData(24, 56);
let bindGroup38 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 8, resource: textureView18},
    {binding: 1, resource: textureView21},
    {binding: 591, resource: textureView9},
    {binding: 56, resource: textureView23},
  ],
});
try {
renderBundleEncoder11.setPipeline(pipeline8);
} catch {}
try {
buffer25.unmap();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(201); };
} catch {}
let bindGroup39 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 133, resource: {buffer: buffer49, size: 2080}}],
});
let commandBuffer4 = commandEncoder45.finish();
let texture92 = device0.createTexture({
  size: {width: 45, height: 12, depthOrArrayLayers: 14},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder21.setBindGroup(1, bindGroup21, new Uint32Array(5345), 867, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(9);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup9, new Uint32Array(1530), 344, 0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer49, 'uint32', 472, 1_940);
} catch {}
try {
buffer47.unmap();
} catch {}
try {
commandEncoder77.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 460 */
  offset: 460,
  bytesPerRow: 9472,
  buffer: buffer33,
}, {
  texture: texture44,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'logSqrt'} });
let texture93 = device0.createTexture({
  size: [1, 135, 1],
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setBindGroup(0, bindGroup26);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder4.setBindGroup(2, bindGroup30, new Uint32Array(134), 8, 0);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline10);
} catch {}
try {
device0.queue.writeBuffer(buffer41, 84, new Float32Array(6255).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.819)), 612, 8);
} catch {}
let imageData13 = new ImageData(16, 32);
try {
globalThis.someLabel = externalTexture1.label;
} catch {}
let bindGroup40 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [{binding: 133, resource: {buffer: buffer49, size: 1232}}],
});
let texture94 = device0.createTexture({
  size: [1],
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture95 = gpuCanvasContext1.getCurrentTexture();
try {
computePassEncoder6.setBindGroup(2, bindGroup29);
} catch {}
try {
computePassEncoder25.setBindGroup(1, bindGroup29, new Uint32Array(769), 13, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder4.setBindGroup(2, bindGroup24);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup12, new Uint32Array(2197), 487, 0);
} catch {}
try {
renderBundleEncoder4.drawIndexedIndirect(buffer59, 8);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer6, 'uint32', 12, 10);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline7);
} catch {}
let textureView90 = texture66.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder4.setBlendConstant({ r: 463.7, g: 995.7, b: -186.4, a: 383.7, });
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder4.drawIndirect(buffer39, 4);
} catch {}
try {
renderPassEncoder10.insertDebugMarker('\u88dd');
} catch {}
try {
device0.queue.writeBuffer(buffer29, 16, new Uint32Array(7644).map((_, i) => i * 6), 1939, 4);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(33); };
} catch {}
try {
renderPassEncoder10.label = '\u59fd\u0d08\u00cc\u300a\u0ad2\u0dbc\u{1fd4f}\u21c0\u{1f842}\u0f22';
} catch {}
let recycledExplicitBindGroupLayout6 = pipeline15.getBindGroupLayout(1);
let commandEncoder95 = device0.createCommandEncoder({});
let textureView91 = texture51.createView({});
try {
computePassEncoder3.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer20, 'uint32', 0, 2);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer12, 8);
} catch {}
try {
renderBundleEncoder18.setBindGroup(1, bindGroup36, new Uint32Array(1431), 216, 0);
} catch {}
try {
renderBundleEncoder4.drawIndirect(buffer6, 0);
} catch {}
let textureView92 = texture48.createView({});
let renderBundle2 = renderBundleEncoder4.finish({});
let sampler15 = device0.createSampler({addressModeU: 'repeat', minFilter: 'nearest'});
try {
renderPassEncoder15.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer12, 0, 31);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(768), 5, 0);
} catch {}
let recycledExplicitBindGroupLayout7 = pipeline1.getBindGroupLayout(0);
let textureView93 = texture82.createView({});
try {
computePassEncoder12.setBindGroup(0, bindGroup24, new Uint32Array(265), 88, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer71, 8); };
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup12, new Uint32Array(4858), 1_563, 0);
} catch {}
try {
commandEncoder91.copyTextureToTexture({
  texture: texture54,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 4},
  aspect: 'all',
},
{
  texture: texture49,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u857c\u044a\ub088\u2256\ubb9f\ufc88\u755c\u74b5\u{1fff6}\ubd36\u843a';
} catch {}
let buffer73 = device0.createBuffer({size: 264, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
try {
computePassEncoder25.setBindGroup(1, bindGroup26);
} catch {}
try {
computePassEncoder7.setBindGroup(1, bindGroup29, new Uint32Array(1374), 461, 0);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline8);
} catch {}
try {
commandEncoder91.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 3014 */
  offset: 3014,
  bytesPerRow: 16896,
  buffer: buffer33,
}, {
  texture: texture85,
  mipLevel: 1,
  origin: {x: 0, y: 6, z: 0},
  aspect: 'all',
}, {width: 0, height: 26, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer44, 24, new Float16Array(1804).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.9136)), 36, 0);
} catch {}
try {
computePassEncoder7.setBindGroup(2, bindGroup24, new Uint32Array(3136), 444, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(3, 1); };
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer4, 0, 29);
} catch {}
try {
device0.queue.writeBuffer(buffer44, 8, new Uint32Array(8264).map((_, i) => i * 2), 3374, 0);
} catch {}
let imageData14 = new ImageData(12, 20);
let buffer74 = device0.createBuffer({size: 56, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let commandEncoder96 = device0.createCommandEncoder({});
let texture96 = device0.createTexture({size: {width: 15}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
let textureView94 = texture85.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer59, 56); };
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer6, 'uint16', 34, 48);
} catch {}
let bindGroup41 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout6, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let commandEncoder97 = device0.createCommandEncoder({});
try {
computePassEncoder1.setBindGroup(2, bindGroup26, new Uint32Array(2808), 248, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup35);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(0, buffer31, 0, 15);
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte432', transfer: 'unspecified'} });
let externalTexture5 = device0.importExternalTexture({source: videoFrame7});
try {
renderPassEncoder8.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer70, 'uint16', 12, 13);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(1, buffer12, 132, 43);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true});
try {
computePassEncoder22.setBindGroup(2, bindGroup41);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(3, buffer39, 0, 7);
} catch {}
let imageData15 = new ImageData(56, 72);
let textureView95 = texture77.createView({});
let textureView96 = texture33.createView({format: 'r8unorm', baseMipLevel: 0});
try {
renderPassEncoder11.setIndexBuffer(buffer71, 'uint32', 56, 3);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer20, 'uint16', 0, 0);
} catch {}
try {
commandEncoder54.copyBufferToBuffer(buffer40, 100, buffer44, 8, 24);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
let texture97 = device0.createTexture({
  size: [75, 1, 1],
  mipLevelCount: 2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler16 = device0.createSampler({
  label: '\ua044\ua800\u{1fd07}\u0425\u013b\ud10b\u0d08\uf2ad',
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 63.04,
});
try {
renderBundleEncoder2.setIndexBuffer(buffer20, 'uint16', 0, 2);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer75 = device0.createBuffer({size: 76, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let texture98 = device0.createTexture({
  size: {width: 1, height: 135, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder16 = commandEncoder36.beginRenderPass({
  colorAttachments: [{view: textureView43, depthSlice: 12, loadOp: 'load', storeOp: 'discard'}],
  timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 4294967295},
});
try {
computePassEncoder8.setBindGroup(0, bindGroup35, new Uint32Array(110), 38, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(5, buffer38, 0, 7);
} catch {}
try {
computePassEncoder7.insertDebugMarker('\u{1faff}');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 8_956, new Uint32Array(37132).map((_, i) => i * 8), 271, 700);
} catch {}
let promise18 = device0.queue.onSubmittedWorkDone();
try {
  await promise15;
} catch {}
let bindGroup42 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 100, resource: {buffer: buffer32, offset: 4608}},
    {binding: 515, resource: sampler2},
    {binding: 529, resource: textureView67},
    {binding: 1, resource: {buffer: buffer49}},
    {binding: 4, resource: {buffer: buffer49, offset: 3072}},
  ],
});
let buffer76 = device0.createBuffer({
  size: 132,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture99 = device0.createTexture({
  size: {width: 37, height: 1, depthOrArrayLayers: 15},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer71, 20); };
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires unrestricted_pointer_parameters;

enable f16;

enable f16;

@group(1) @binding(1) var<storage, read_write> buffer78: array<array<f16, 256>>;

struct FragmentInput8 {
  @location(9) location_9: vec2h,
}

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

struct FragmentInput10 {
  @location(8) @interpolate(linear) location_8: vec4f,
  @location(2) location_2: vec4f,
}

struct T0 {
  f0: vec2u,
  @size(80) f1: array<vec4i, 1>,
}

struct VertexInput25 {
  @location(13) @interpolate(perspective, sample) location_13: f32,
}

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

@id(16895) override override11: f16;

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

@group(0) @binding(191) var<uniform> buffer77: array<array<vec4f, 316>, 1>;

var<workgroup> vw6: vec4u;

struct FragmentInput7 {
  @location(6) location_6: u32,
  @location(4) location_4: vec4f,
  @location(1) location_1: vec4i,
  @location(14) @interpolate(flat, first) location_14: u32,
  @location(5) @interpolate(flat, centroid) location_5: f32,
}

@id(42604) override override10: i32;

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

var<private> vp8: array<array<vec2<bool>, 12>, 1> = array(array(vec2<bool>(true, false), vec2<bool>(true, true), vec2<bool>(false, false), vec2<bool>(false, false), vec2<bool>(false, false), vec2<bool>(false, true), vec2<bool>(false, false), vec2<bool>(false, false), vec2<bool>(true, true), vec2<bool>(true, false), vec2<bool>(false, false), vec2<bool>(true, true)));

var<private> vp7 = frexp(vec2h(15539.4, 41930.1));

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

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

@group(3) @binding(1) var st4: texture_storage_1d<rgba16sint, read>;

struct VertexInput24 {
  @location(15) @interpolate(flat, sample) location_15: i32,
}

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

@group(1) @binding(100) var<uniform> buffer80: array<array<vec4f, 1>, 5>;

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

struct FragmentInput9 {
  @location(7) location_7: i32,
  @location(13) location_13: vec2i,
}

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

@group(1) @binding(4) var<storage, read_write> buffer79: array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 52>, 1>, 4>>;

@id(36733) override override12: u32 = (1936358811 % 103) + 1;

struct VertexInput26 {
  @location(5) @interpolate(linear, centroid) location_5: vec2f,
  @location(8) location_8: vec2u,
}

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

alias vec3b = vec3<bool>;

struct VertexInput23 {
  @location(7) @interpolate(linear, either) location_7: vec2f,
}

/* used global variables: buffer77, buffer80, st4 */
@vertex
fn vertex5(@location(3) location_3: f16, @location(0) @interpolate(flat) location_0: vec2u, a2: VertexInput23, @location(11) location_11: f16, @location(12) @interpolate(flat, first) location_12: vec2f, a5: VertexInput24, a6: VertexInput25, @location(2) @interpolate(flat, centroid) location_2: vec4u, a8: VertexInput26) -> @builtin(position) vec4f {
  var out: vec4f;
  out -= (*&buffer77)[0][315];
  let vf67: vec2h = fract(vec2h(unconst_f16(35360.1), unconst_f16(9527.3)));
  if bool(buffer80[4][unconst_u32(3529135059)].b) {
  var vf68: vec4u = location_2;
  return out;
}
  _ = st4;
  let ptr64: ptr<uniform, vec4f> = &buffer77[0][315];
  let ptr65: ptr<uniform, array<vec4f, 1>> = &(*&buffer80)[4];
  out += vec4f(f32((unconst_f32(0.3829e26) > unconst_f32(0.00007))));
  return out;
  _ = st4;
  _ = buffer77;
  _ = buffer80;
}

/* used global variables: buffer78, buffer79, buffer80 */
@fragment
fn fragment2(a0: FragmentInput7, @location(10) location_10: vec2f, @location(3) @interpolate(flat, sample) location_3: i32, a3: FragmentInput8, @location(0) @interpolate(flat, either) location_0: vec2u, a5: FragmentInput9, @location(15) location_15: vec4h, a7: FragmentInput10, @builtin(sample_mask) sample_mask: u32, @invariant @builtin(position) position: vec4f, a10: FragmentInput11, @builtin(sample_index) sample_index: u32) -> @location(200) vec4f {
  var out: vec4f;
  let ptr66: ptr<storage, array<f16, 1>, read_write> = &buffer79[unconst_u32(1401607488)][3][0][u32((*&buffer79)[arrayLength(&(*&buffer79))][unconst_u32(477573248)][0][51][0][unconst_u32(158709707)][0])][0][unconst_u32(1081690533)];
  buffer78[unconst_u32(401278747)][unconst_u32(2424642930)] -= (*&buffer79)[unconst_u32(3235549058)][3][unconst_u32(36741050)][51][0][0][0];
  for (var it5=u32((*&buffer79)[unconst_u32(597840063)][unconst_u32(1190417353)][0][unconst_u32(579946176)][0][0][unconst_u32(1527435863)]); it5<(u32(buffer79[unconst_u32(1770302205)][arrayLength(&(*&buffer78))][0][unconst_u32(1180196227)][0][unconst_u32(151934503)][0]) & 0xfff); it5++) {
  var vf69: f32 = (*&buffer80)[4][0][unconst_u32(513138840)];
  let ptr67: ptr<storage, f16, read_write> = &(*&buffer79)[u32(buffer79[arrayLength(&buffer79)][3][unconst_u32(307532853)][51][unconst_u32(54954164)][0][0])][3][0][unconst_u32(214659045)][unconst_u32(768553593)][unconst_u32(180688569)][0];
  let vf70: vec2f = atanh(vec2f(unconst_f32(0.02011e1), unconst_f32(-0.2779)));
  return out;
  _ = buffer80;
  _ = buffer79;
}
  vp6 = bool(buffer79[arrayLength(&buffer79)][unconst_u32(3191164305)][u32(buffer79[arrayLength(&buffer79)][unconst_u32(37247804)][unconst_u32(70928389)][unconst_u32(203418474)][unconst_u32(1638219036)][unconst_u32(27342978)][0])][unconst_u32(868289371)][0][0][unconst_u32(322929919)]);
  let ptr68: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer79[unconst_u32(722821544)][3][u32((*&buffer79)[arrayLength(&(*&buffer79))][unconst_u32(169062246)][unconst_u32(901168755)][unconst_u32(159537011)][unconst_u32(949281660)][0][0])][unconst_u32(1922709601)][unconst_u32(297084137)];
  let ptr69: ptr<storage, f16, read_write> = &(*&buffer79)[unconst_u32(1115083801)][3][u32((*&buffer79)[unconst_u32(219072351)][unconst_u32(42210577)][unconst_u32(545876243)][unconst_u32(611274038)][0][0][0])][51][0][0][unconst_u32(746776033)];
  out = vec4f(f32(buffer79[arrayLength(&buffer79)][3][unconst_u32(777735808)][51][unconst_u32(2472865801)][0][unconst_u32(287907532)]));
  vp6 = bool(buffer79[unconst_u32(540150500)][3][0][51][0][unconst_u32(937281134)][unconst_u32(1169680890)]);
  vp6 = bool(buffer79[arrayLength(&buffer79)][unconst_u32(227087345)][unconst_u32(189092231)][51][unconst_u32(570676615)][unconst_u32(316074599)][unconst_u32(565063237)]);
  return out;
  _ = buffer78;
  _ = buffer79;
  _ = buffer80;
}`,
});
let buffer82 = device0.createBuffer({size: 188, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let texture100 = device0.createTexture({
  size: {width: 7, height: 1, depthOrArrayLayers: 5},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture101 = device0.createTexture({
  size: {width: 45, height: 12, depthOrArrayLayers: 47},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView97 = texture3.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder4.setBindGroup(0, bindGroup23, new Uint32Array(399), 3, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder98 = device0.createCommandEncoder({});
let textureView98 = texture100.createView({});
try {
computePassEncoder5.setBindGroup(0, bindGroup21);
} catch {}
try {
computePassEncoder1.setBindGroup(1, bindGroup41, new Uint32Array(1662), 11, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroupsIndirect(buffer82, 8); };
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(4, buffer39);
} catch {}
try {
commandEncoder83.popDebugGroup();
} catch {}
let pipeline16 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}});
let imageBitmap0 = await createImageBitmap(imageData2);
let imageData16 = new ImageData(20, 36);
let recycledExplicitBindGroupLayout8 = pipeline14.getBindGroupLayout(0);
let buffer83 = device0.createBuffer({size: 10714, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let commandEncoder99 = device0.createCommandEncoder({});
let texture102 = device0.createTexture({size: [64, 64, 20], dimension: '3d', format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer9, 0); };
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup3);
} catch {}
try {
renderBundleEncoder7.draw(5, 4, 13, 261_948_441);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeBuffer(buffer71, 20, new DataView(new ArrayBuffer(33700)), 3592, 12);
} catch {}
let commandEncoder100 = device0.createCommandEncoder({});
try {
renderPassEncoder15.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer70, 'uint32', 36, 3);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer48, 0, 27);
} catch {}
try {
renderBundleEncoder7.draw(8, 47, 19, 337_274_437);
} catch {}
try {
renderBundleEncoder7.drawIndexed(6, 252, 8, 315_833_208, 578_204_996);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline8);
} catch {}
try {
buffer25.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer14, 32, new DataView(new Uint8Array(2504).map((_, i) => i).buffer), 526, 8);
} catch {}
let pipeline17 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x3f8474c4},
  fragment: {module: shaderModule2, constants: {}, targets: [{format: 'bgra8unorm'}]},
  vertex: {
    module: shaderModule1,
    constants: {},
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 0, shaderLocation: 2},
          {format: 'sint8x2', offset: 0, shaderLocation: 5},
          {format: 'uint32', offset: 0, shaderLocation: 14},
          {format: 'sint8x2', offset: 0, shaderLocation: 7},
          {format: 'unorm16x2', offset: 0, shaderLocation: 13},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'sint8x4', offset: 0, shaderLocation: 1},
          {format: 'uint8x4', offset: 0, shaderLocation: 12},
          {format: 'sint16x2', offset: 0, shaderLocation: 15},
          {format: 'float32', offset: 0, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 9},
          {format: 'snorm16x2', offset: 0, shaderLocation: 0},
          {format: 'uint8x2', offset: 0, shaderLocation: 4},
          {format: 'unorm8x2', offset: 0, shaderLocation: 3},
          {format: 'unorm16x2', offset: 0, shaderLocation: 6},
          {format: 'unorm16x2', offset: 0, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', unclippedDepth: true},
});
try {
  await promise18;
} catch {}
let commandEncoder101 = device0.createCommandEncoder({});
try {
computePassEncoder13.setBindGroup(2, bindGroup26);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer4, 16, 21);
} catch {}
try {
renderBundleEncoder7.draw(20, 224, 9, 219_378_376);
} catch {}
try {
renderBundleEncoder7.drawIndexedIndirect(buffer6, 8);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData13,
  origin: { x: 2, y: 4 },
  flipY: true,
}, {
  texture: texture44,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup39);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup26, new Uint32Array(1770), 302, 0);
} catch {}
try {
renderBundleEncoder7.drawIndexedIndirect(buffer68, 64);
} catch {}
try {
renderBundleEncoder7.drawIndirect(buffer82, 52);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 0, new Uint32Array(2516).map((_, i) => i * 6), 157, 4);
} catch {}
let commandEncoder102 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  size: [1],
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer73, 0); };
} catch {}
try {
renderBundleEncoder7.draw(14, 45, 0, 262_286_663);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer66, 'uint32', 4, 32);
} catch {}
try {
commandEncoder100.copyBufferToBuffer(buffer2, 4, buffer72, 16, 8);
} catch {}
try {
  await promise17;
} catch {}
let bindGroup43 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 133, resource: {buffer: buffer49, offset: 768}}],
});
let commandEncoder103 = device0.createCommandEncoder({});
let textureView99 = texture90.createView({aspect: 'stencil-only'});
try {
computePassEncoder21.setBindGroup(2, bindGroup19, new Uint32Array(673), 160, 0);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup31, new Uint32Array(2120), 1_254, 0);
} catch {}
try {
commandEncoder40.resolveQuerySet(querySet0, 1, 0, buffer0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer44, 128, new Uint32Array(1035).map((_, i) => i * 3), 166, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup10);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 0, new Uint32Array(32681).map((_, i) => i * 6), 8171, 0);
} catch {}
let commandBuffer5 = commandEncoder9.finish();
try {
computePassEncoder12.setBindGroup(1, bindGroup40);
} catch {}
try {
computePassEncoder7.setBindGroup(1, bindGroup21, new Uint32Array(261), 32, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup26);
} catch {}
try {
renderBundleEncoder7.draw(16, 269, 0, 3_351_771_757);
} catch {}
try {
renderBundleEncoder7.drawIndexed(101, 106, 31, 52_202_308, 470_140_391);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer34, 'uint16', 0, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'iec6196624'} });
let commandEncoder104 = device0.createCommandEncoder({});
let texture104 = device0.createTexture({
  size: [90, 24, 231],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder11.setBindGroup(2, bindGroup19);
} catch {}
try {
computePassEncoder24.end();
} catch {}
try {
buffer39.unmap();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let buffer84 = device0.createBuffer({size: 4144, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let sampler17 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', minFilter: 'linear'});
try {
computePassEncoder13.setBindGroup(0, bindGroup26);
} catch {}
try {
computePassEncoder23.end();
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup40, new Uint32Array(1791), 984, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer66, 'uint16', 2, 2);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup33, new Uint32Array(1129), 241, 0);
} catch {}
try {
renderBundleEncoder7.drawIndexedIndirect(buffer74, 4);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline17);
} catch {}
try {
commandEncoder74.copyTextureToTexture({
  texture: texture11,
  mipLevel: 1,
  origin: {x: 0, y: 51, z: 2},
  aspect: 'all',
},
{
  texture: texture44,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture105 = device0.createTexture({
  size: [1],
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture106 = device0.createTexture({
  size: [180, 48, 24],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder19.setBindGroup(1, bindGroup24);
} catch {}
try {
computePassEncoder1.setBindGroup(0, bindGroup41, new Uint32Array(1017), 110, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(4, buffer31, 0, 1);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup3);
} catch {}
try {
renderBundleEncoder7.drawIndexed(26, 15, 4, 947_590_563, 11);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer18, 'uint16', 24, 34);
} catch {}
try {
commandEncoder71.resolveQuerySet(querySet0, 0, 0, buffer3, 0);
} catch {}
let texture107 = device0.createTexture({
  size: [18],
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder12.setBindGroup(2, bindGroup31, new Uint32Array(388), 130, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup38);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline7);
} catch {}
try {
device0.queue.submit([commandBuffer5]);
} catch {}
let bindGroup44 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: textureView39},
    {binding: 8, resource: textureView18},
    {binding: 591, resource: textureView53},
    {binding: 56, resource: textureView1},
  ],
});
let commandEncoder105 = device0.createCommandEncoder({});
let textureView100 = texture107.createView({});
try {
computePassEncoder12.setBindGroup(2, bindGroup21, new Uint32Array(1744), 359, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup18, new Uint32Array(3034), 32, 0);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer31, 0, 9);
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup4);
} catch {}
try {
device0.queue.writeBuffer(buffer44, 76, new Uint32Array(3711).map((_, i) => i * 1), 865, 4);
} catch {}
let commandBuffer6 = commandEncoder69.finish();
let textureView101 = texture80.createView({});
let textureView102 = texture68.createView({baseMipLevel: 0, mipLevelCount: 1});
let renderBundle3 = renderBundleEncoder7.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder13.draw(0, 98, 0, 162_580_549);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer67, 'uint16', 14, 10);
} catch {}
let imageBitmap1 = await createImageBitmap(imageData14);
let buffer85 = device0.createBuffer({size: 220, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let texture108 = gpuCanvasContext0.getCurrentTexture();
let textureView103 = texture32.createView({});
try {
renderPassEncoder4.setBindGroup(1, bindGroup40);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup39, new Uint32Array(315), 88, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer66, 'uint16', 2, 15);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer48, 96);
} catch {}
try {
commandEncoder7.copyTextureToTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(13); };
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'gamma22curve'} });
let commandEncoder106 = device0.createCommandEncoder({});
let textureView104 = texture59.createView({});
try {
computePassEncoder19.setBindGroup(2, bindGroup41);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer38, 'uint16', 4, 1);
} catch {}
try {
commandEncoder105.copyTextureToTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture44,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise16;
} catch {}
let bindGroup45 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 8, resource: textureView7},
    {binding: 56, resource: textureView23},
    {binding: 591, resource: textureView9},
    {binding: 1, resource: textureView84},
  ],
});
let commandEncoder107 = device0.createCommandEncoder({});
let texture109 = device0.createTexture({
  size: [60, 1, 192],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder18.end();
} catch {}
try {
computePassEncoder19.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup31, new Uint32Array(11), 2, 0);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(4, buffer48, 28);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder108 = device0.createCommandEncoder({label: '\u0601\u9ef9\u{1f96c}\u01b1\u4ad4\uba83'});
let textureView105 = texture50.createView({mipLevelCount: 1});
let renderBundle4 = renderBundleEncoder13.finish();
let externalTexture6 = device0.importExternalTexture({source: videoFrame6});
try {
computePassEncoder19.setBindGroup(0, bindGroup21, new Uint32Array(2224), 948, 0);
} catch {}
document.body.append(canvas0);
let commandEncoder109 = device0.createCommandEncoder({});
let textureView106 = texture52.createView({mipLevelCount: 1});
try {
computePassEncoder6.setBindGroup(2, bindGroup26);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup19);
} catch {}
try {
buffer39.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer39, 20, new DataView(new ArrayBuffer(167520)), 1499, 0);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup46 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let texture110 = device0.createTexture({
  size: {width: 37, height: 1, depthOrArrayLayers: 41},
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture111 = device0.createTexture({
  size: [7],
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder21.setBindGroup(0, bindGroup46);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer19, 'uint32', 8, 24);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 270, depthOrArrayLayers: 264}
*/
{
  source: canvas1,
  origin: { x: 41, y: 2 },
  flipY: true,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 0, y: 66, z: 97},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 75, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas1);
let commandEncoder110 = device0.createCommandEncoder({});
let textureView107 = texture110.createView({});
let texture112 = gpuCanvasContext1.getCurrentTexture();
let textureView108 = texture61.createView({baseArrayLayer: 0});
let renderPassEncoder17 = commandEncoder44.beginRenderPass({
  colorAttachments: [{
  view: textureView31,
  clearValue: { r: -719.3, g: -345.1, b: 243.1, a: 431.7, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder8.beginOcclusionQuery(8);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup40, new Uint32Array(5126), 2_348, 0);
} catch {}
try {
device0.queue.submit([commandBuffer6]);
} catch {}
try {
device0.queue.writeBuffer(buffer71, 0, new DataView(new ArrayBuffer(6648)), 479, 24);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder6.setBindGroup(3, bindGroup18);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(20); };
} catch {}
let imageBitmap2 = await createImageBitmap(canvas0);
let commandBuffer7 = commandEncoder15.finish();
let bindGroup47 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [{binding: 133, resource: {buffer: buffer84, size: 1264}}],
});
let buffer86 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder111 = device0.createCommandEncoder({});
let textureView109 = texture67.createView({baseMipLevel: 0});
try {
computePassEncoder12.setBindGroup(1, bindGroup29);
} catch {}
try {
computePassEncoder3.setBindGroup(0, bindGroup35, new Uint32Array(1797), 21, 0);
} catch {}
try {
computePassEncoder2.setPipeline(pipeline9);
} catch {}
try {
commandEncoder108.copyBufferToTexture({
  /* bytesInLastRow: 128 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 192 */
  offset: 192,
  rowsPerImage: 670,
  buffer: buffer37,
}, {
  texture: texture110,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 2},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let buffer87 = device0.createBuffer({
  label: '\u0997\u98c2\u38b0\u{1f89f}\u{1f997}\ua383\u3a00',
  size: 124,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
let textureView110 = texture111.createView({aspect: 'all'});
let sampler18 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 65.47,
  compare: 'always',
  maxAnisotropy: 10,
});
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer6, 12); };
} catch {}
try {
computePassEncoder6.end();
} catch {}
try {
renderBundleEncoder10.setBindGroup(3, bindGroup32, new Uint32Array(2439), 67, 0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(5, buffer7, 2_560);
} catch {}
try {
device0.queue.writeBuffer(buffer74, 4, new DataView(new ArrayBuffer(10856)), 4666, 0);
} catch {}
let pipeline18 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: 0}],
},
  vertex: {
    module: shaderModule5,
    entryPoint: 'vertex4',
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 652, shaderLocation: 1},
          {format: 'uint32x4', offset: 584, shaderLocation: 13},
          {format: 'unorm16x4', offset: 68, shaderLocation: 7},
          {format: 'float32x4', offset: 1656, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front', unclippedDepth: false},
});
let texture113 = device0.createTexture({
  size: {width: 180, height: 48, depthOrArrayLayers: 462},
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder16.setBindGroup(0, bindGroup19, new Uint32Array(2879), 402, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroups(1, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer59, 8); };
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer49, 'uint32', 328, 58);
} catch {}
try {
commandEncoder81.copyBufferToTexture({
  /* bytesInLastRow: 168 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1736 */
  offset: 1736,
  bytesPerRow: 9216,
  buffer: buffer33,
}, {
  texture: texture77,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let bindGroup48 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout6, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let texture114 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 18},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView111 = texture110.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); };
} catch {}
let buffer88 = device0.createBuffer({size: 112, usage: GPUBufferUsage.COPY_DST});
let texture115 = device0.createTexture({
  size: {width: 15},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder5.setBindGroup(1, bindGroup48, []);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(5, buffer3);
} catch {}
try {
commandEncoder49.copyBufferToBuffer(buffer20, 0, buffer44, 28, 4);
} catch {}
try {
commandEncoder85.copyTextureToBuffer({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4024 */
  offset: 4024,
  bytesPerRow: 28160,
  rowsPerImage: 165,
  buffer: buffer84,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas2 = new OffscreenCanvas(13, 402);
let commandEncoder112 = device0.createCommandEncoder();
let commandBuffer8 = commandEncoder21.finish();
let textureView112 = texture115.createView({});
let computePassEncoder26 = commandEncoder66.beginComputePass();
try {
computePassEncoder11.end();
} catch {}
try {
computePassEncoder26.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer67, 'uint16', 70, 52);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(4, buffer76);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer20, 'uint16', 2, 1);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let commandEncoder113 = device0.createCommandEncoder({});
try {
computePassEncoder1.setBindGroup(2, bindGroup21);
} catch {}
try {
computePassEncoder21.end();
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline8);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 20, new Uint32Array(5075).map((_, i) => i * 9), 428, 8);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(46); };
} catch {}
let recycledExplicitBindGroupLayout9 = pipeline9.getBindGroupLayout(2);
let buffer89 = device0.createBuffer({size: 100, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder114 = device0.createCommandEncoder({label: '\uad3f\u{1fa62}\u{1fb53}\u58e7\ue80c'});
let textureView113 = texture115.createView({dimension: '1d', baseMipLevel: 0});
let texture116 = gpuCanvasContext1.getCurrentTexture();
let renderPassEncoder18 = commandEncoder79.beginRenderPass({colorAttachments: [{view: textureView75, depthSlice: 745, loadOp: 'clear', storeOp: 'store'}]});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer74, 4); };
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(0, buffer39, 0, 21);
} catch {}
try {
buffer39.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(117); };
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpte170m', transfer: 'bt709'} });
let texture117 = device0.createTexture({
  size: {width: 75, height: 1, depthOrArrayLayers: 410},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder5.setBindGroup(0, bindGroup31);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer71, 8); };
} catch {}
try {
commandEncoder58.resolveQuerySet(querySet2, 0, 0, buffer34, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 94}
*/
{
  source: imageBitmap1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture91,
  mipLevel: 1,
  origin: {x: 4, y: 6, z: 27},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 3, depthOrArrayLayers: 0});
} catch {}
let buffer90 = device0.createBuffer({size: 268, usage: GPUBufferUsage.UNIFORM});
let commandEncoder115 = device0.createCommandEncoder({});
let texture118 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 18},
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView114 = texture94.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer9, 12); };
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup48);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer71, 'uint16', 20, 12);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(1, buffer7, 0, 1_207);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
} catch {}
let commandEncoder116 = device0.createCommandEncoder({});
let texture119 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView115 = texture25.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderBundleEncoder14.setPipeline(pipeline10);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 0, new Float16Array(1758).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.7611)), 194, 4);
} catch {}
let bindGroup49 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let commandEncoder117 = device0.createCommandEncoder({});
let textureView116 = texture119.createView({dimension: '2d-array'});
try {
computePassEncoder1.setBindGroup(1, bindGroup29);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer34, 'uint16', 0, 0);
} catch {}
try {
buffer68.unmap();
} catch {}
let commandBuffer9 = commandEncoder20.finish();
let texture120 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 12},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture121 = device0.createTexture({
  size: {width: 7, height: 1, depthOrArrayLayers: 37},
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer85, 4); };
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup34, new Uint32Array(5230), 744, 0);
} catch {}
try {
commandEncoder57.copyTextureToBuffer({
  texture: texture70,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 296 widthInBlocks: 74 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5032 */
  offset: 5032,
  buffer: buffer7,
}, {width: 74, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer89, 8, new BigInt64Array(10304).map((_, i) => BigInt(i - 1)), 382, 0);
} catch {}
await gc();
let bindGroup50 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 56, resource: textureView33},
    {binding: 1, resource: textureView16},
    {binding: 591, resource: textureView106},
    {binding: 8, resource: textureView7},
  ],
});
let texture122 = device0.createTexture({
  size: {width: 1},
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture123 = device0.createTexture({
  size: [60, 1, 1],
  mipLevelCount: 3,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView117 = texture28.createView({});
let computePassEncoder27 = commandEncoder117.beginComputePass();
try {
renderBundleEncoder1.setBindGroup(1, bindGroup29);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline13);
} catch {}
try {
device0.queue.submit([commandBuffer9, commandBuffer7]);
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
document.body.append(canvas2);
let commandEncoder118 = device0.createCommandEncoder({});
let textureView118 = texture117.createView({arrayLayerCount: 1});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], depthReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup44, new Uint32Array(1123), 40, 0);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup20);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder104.resolveQuerySet(querySet4, 168, 7, buffer25, 0);
} catch {}
try {
  await promise19;
} catch {}
let commandEncoder119 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer71, 4); };
} catch {}
try {
renderPassEncoder18.setVertexBuffer(0, buffer3, 24, 5);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup48, new Uint32Array(1716), 71, 0);
} catch {}
try {
commandEncoder93.copyTextureToTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 34, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture53,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer39, 4, new DataView(new ArrayBuffer(52744)), 1450, 8);
} catch {}
let bindGroup51 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let buffer91 = device0.createBuffer({size: 400, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder120 = device0.createCommandEncoder({});
let texture124 = device0.createTexture({
  size: {width: 22, height: 6, depthOrArrayLayers: 57},
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView119 = texture123.createView({dimension: '2d-array', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer31, 0, 11);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([commandBuffer8]);
} catch {}
try {
computePassEncoder7.setBindGroup(0, bindGroup49, new Uint32Array(3278), 925, 0);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup34);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer4);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer48, 'uint16', 80, 8);
} catch {}
let pipeline19 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout4,
  fragment: {module: shaderModule2, targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA}]},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 0, shaderLocation: 14},
          {format: 'sint32x2', offset: 0, shaderLocation: 10},
          {format: 'float16x4', offset: 0, shaderLocation: 7},
          {format: 'snorm8x2', offset: 0, shaderLocation: 11},
          {format: 'uint16x2', offset: 0, shaderLocation: 3},
          {format: 'sint32x4', offset: 0, shaderLocation: 4},
          {format: 'uint32x2', offset: 0, shaderLocation: 5},
          {format: 'sint32x3', offset: 4, shaderLocation: 1},
          {format: 'sint8x4', offset: 0, shaderLocation: 0},
          {format: 'sint16x2', offset: 0, shaderLocation: 6},
          {format: 'float32', offset: 0, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let autogeneratedBindGroupLayout3 = pipeline6.getBindGroupLayout(0);
let buffer92 = device0.createBuffer({size: 252, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, mappedAtCreation: false});
let textureView120 = texture35.createView({});
let externalTexture7 = device0.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'});
try {
computePassEncoder3.setBindGroup(3, bindGroup32, new Uint32Array(263), 0, 0);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder16.setBlendConstant({ r: 265.2, g: 949.3, b: 284.0, a: -95.76, });
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer38, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline18);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(1, buffer86);
} catch {}
try {
adapter0.label = '\u5d62\u{1f8dc}\uec52\u0bf9\u{1fbe0}\u70b0\u09eb\u{1f690}\u{1fafc}\u{1fa98}';
} catch {}
let texture125 = device0.createTexture({
  size: {width: 75, height: 1, depthOrArrayLayers: 1},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let texture126 = gpuCanvasContext1.getCurrentTexture();
let textureView121 = texture84.createView({aspect: 'all'});
try {
computePassEncoder0.setBindGroup(1, bindGroup40);
} catch {}
try {
computePassEncoder22.end();
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup29, new Uint32Array(592), 35, 0);
} catch {}
try {
commandEncoder7.insertDebugMarker('\u8cc8');
} catch {}
let promise20 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(40); };
} catch {}
try {
  await promise20;
} catch {}
let buffer93 = device0.createBuffer({
  size: 34,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
try {
renderBundleEncoder3.setBindGroup(1, bindGroup31, new Uint32Array(968), 555, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 6},
  aspect: 'all',
}, new Uint8Array(138_888).fill(213), /* required buffer size: 138_888 */
{offset: 48, bytesPerRow: 89, rowsPerImage: 130}, {width: 8, height: 0, depthOrArrayLayers: 13});
} catch {}
document.body.append(canvas0);
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {binding: 6, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 51,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 122,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '3d' },
    },
  ],
});
let buffer94 = device0.createBuffer({size: 272, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1); };
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer95 = device0.createBuffer({size: 356, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder121 = device0.createCommandEncoder();
let texture127 = device0.createTexture({
  size: {width: 180, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder19 = commandEncoder58.beginRenderPass({
  colorAttachments: [{view: textureView67, depthSlice: 35, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder1.setBindGroup(2, bindGroup24);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup20);
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(8);
} catch {}
try {
offscreenCanvas2.getContext('webgpu');
} catch {}
let commandEncoder122 = device0.createCommandEncoder({});
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true});
try {
computePassEncoder2.setBindGroup(1, bindGroup49);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer68, 12); };
} catch {}
try {
commandEncoder34.insertDebugMarker('\ufc15');
} catch {}
try {
device0.queue.writeBuffer(buffer72, 64, new Uint32Array(10756).map((_, i) => i * 4), 409, 0);
} catch {}
let commandEncoder123 = device0.createCommandEncoder({});
let textureView122 = texture50.createView({baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder14.setBindGroup(0, bindGroup33, new Uint32Array(383), 0, 0);
} catch {}
try {
commandEncoder76.insertDebugMarker('\u0a7d');
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let commandEncoder124 = device0.createCommandEncoder({});
let texture128 = device0.createTexture({
  size: [30, 1, 1],
  dimension: '2d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView123 = texture11.createView({baseMipLevel: 0, mipLevelCount: 1});
let externalTexture8 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
computePassEncoder16.setBindGroup(2, bindGroup30);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer6, 24); };
} catch {}
try {
computePassEncoder20.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder15.insertDebugMarker('\u4f6b');
} catch {}
let bindGroup52 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 56, resource: textureView23},
    {binding: 8, resource: textureView7},
    {binding: 591, resource: textureView53},
    {binding: 1, resource: textureView29},
  ],
});
let commandEncoder125 = device0.createCommandEncoder();
let texture129 = device0.createTexture({size: [7, 1, 6], format: 'r8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer68, 8); };
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(2, buffer17, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(3, bindGroup30, new Uint32Array(790), 4, 0);
} catch {}
try {
commandEncoder115.copyTextureToBuffer({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 50, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 2740 */
  offset: 2740,
  bytesPerRow: 22016,
  buffer: buffer7,
}, {width: 8, height: 4, depthOrArrayLayers: 0});
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
let buffer96 = device0.createBuffer({size: 180, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
try {
renderBundleEncoder11.setIndexBuffer(buffer87, 'uint32', 16, 15);
} catch {}
try {
commandEncoder75.copyTextureToTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder10.insertDebugMarker('\u0d05');
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
let buffer97 = device0.createBuffer({size: 76, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder126 = device0.createCommandEncoder({label: '\u{1fb25}\ud1e6\u0c15\u0a9e\ud8d6\u8d4e\u244e\u{1ff69}'});
let texture130 = device0.createTexture({
  size: {width: 1, height: 540, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder5.setBindGroup(2, bindGroup46);
} catch {}
try {
computePassEncoder0.setBindGroup(2, bindGroup46, new Uint32Array(1706), 60, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder14.dispatchWorkgroupsIndirect(buffer59, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer66, 32, new Float32Array(16583).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.236)), 2140, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(169).fill(59), /* required buffer size: 169 */
{offset: 169}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: imageBitmap0,
  origin: { x: 1, y: 2 },
  flipY: false,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise21;
} catch {}
let commandEncoder127 = device0.createCommandEncoder({});
try {
computePassEncoder16.setBindGroup(1, bindGroup47, new Uint32Array(2044), 29, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup10);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup26, new Uint32Array(891), 138, 0);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer66, 'uint16', 22, 65);
} catch {}
let bindGroup53 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let buffer98 = device0.createBuffer({
  size: 38,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture131 = device0.createTexture({
  size: [60, 1, 103],
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder3.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup16);
} catch {}
document.body.append(canvas0);
let offscreenCanvas3 = new OffscreenCanvas(147, 272);
let commandEncoder128 = device0.createCommandEncoder({});
let texture132 = device0.createTexture({
  size: [15],
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView124 = texture23.createView({dimension: '2d'});
let sampler19 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 36.79});
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup21);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup33);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup10, new Uint32Array(5265), 496, 0);
} catch {}
try {
commandEncoder63.copyTextureToBuffer({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1112 */
  offset: 1112,
  buffer: buffer7,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer99 = device0.createBuffer({size: 92, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder9.setBindGroup(3, bindGroup8, new Uint32Array(1164), 77, 0);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer87, 0);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
commandEncoder93.clearBuffer(buffer93, 0, 0);
} catch {}
let gpuCanvasContext3 = offscreenCanvas3.getContext('webgpu');
let recycledExplicitBindGroupLayout10 = pipeline7.getBindGroupLayout(0);
let commandEncoder129 = device0.createCommandEncoder({});
let commandBuffer10 = commandEncoder74.finish();
let texture133 = device0.createTexture({
  size: [64, 64, 162],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
renderPassEncoder9.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer67, 'uint32', 120, 140);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline8);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1504 */
  offset: 1504,
  buffer: buffer33,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer10]);
} catch {}
let bindGroup54 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let textureView125 = texture124.createView({format: 'rg8sint', baseArrayLayer: 0});
try {
renderPassEncoder13.setVertexBuffer(3, buffer12);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline8);
} catch {}
try {
commandEncoder68.copyBufferToBuffer(buffer27, 12, buffer14, 0, 8);
} catch {}
let canvas3 = document.createElement('canvas');
let buffer100 = device0.createBuffer({
  size: 116,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView126 = texture81.createView({});
try {
computePassEncoder27.setBindGroup(2, bindGroup40);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup8);
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup23);
} catch {}
try {
adapter0.label = '\udad9\u0a49';
} catch {}
let recycledExplicitBindGroupLayout11 = pipeline15.getBindGroupLayout(1);
let bindGroup55 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout9, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let buffer101 = device0.createBuffer({size: 372, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let externalTexture9 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'});
try {
computePassEncoder20.setBindGroup(0, bindGroup47);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(2, buffer31, 0, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let buffer102 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false});
let commandEncoder130 = device0.createCommandEncoder({});
let texture134 = device0.createTexture({
  size: [75, 1, 1],
  mipLevelCount: 4,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true});
try {
computePassEncoder10.setBindGroup(1, bindGroup49, new Uint32Array(574), 163, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer71, 'uint16', 4, 52);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(3, buffer39, 0, 8);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
buffer101.unmap();
} catch {}
document.body.append(canvas0);
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'bt470m', transfer: 'bt2020_10bit'} });
let commandBuffer11 = commandEncoder28.finish();
let texture135 = device0.createTexture({
  size: {width: 15, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  dimension: '2d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView127 = texture107.createView({});
let renderPassEncoder20 = commandEncoder114.beginRenderPass({
  label: '\u{1ff60}\uaeed\u050b\u3e9a\u867b\u34d5\u01c2\u604c\u0d41',
  colorAttachments: [{
  view: textureView56,
  clearValue: { r: 693.2, g: 358.1, b: -572.6, a: 240.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder19.beginOcclusionQuery(10);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup33);
} catch {}
try {
commandEncoder42.copyBufferToBuffer(buffer27, 12, buffer13, 12, 28);
} catch {}
let recycledExplicitBindGroupLayout12 = pipeline15.getBindGroupLayout(0);
try {
computePassEncoder26.setBindGroup(1, bindGroup19);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup39, new Uint32Array(980), 39, 0);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline17);
} catch {}
let gpuCanvasContext4 = canvas3.getContext('webgpu');
let commandEncoder131 = device0.createCommandEncoder({});
let texture136 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView128 = texture2.createView({});
let externalTexture10 = device0.importExternalTexture({source: videoFrame4});
try {
renderBundleEncoder16.setBindGroup(3, bindGroup6);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(0, buffer100);
} catch {}
try {
adapter0.label = '\u1c78\ufcd7\u{1fc5d}\u{1f8ce}\u{1f809}\u5449\u{1f8cf}\u6b6b\u34ce\u{1fed5}';
} catch {}
let bindGroup56 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [{binding: 133, resource: {buffer: buffer49, offset: 2560}}],
});
let buffer103 = device0.createBuffer({size: 116, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let renderPassEncoder21 = commandEncoder7.beginRenderPass({
  colorAttachments: [{
  view: textureView73,
  depthSlice: 63,
  clearValue: { r: 669.3, g: -603.3, b: 468.0, a: 247.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 147244586,
});
try {
computePassEncoder19.setBindGroup(1, bindGroup10);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer20, 'uint16', 6, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup39);
} catch {}
try {
renderBundleEncoder24.setBindGroup(2, bindGroup30, new Uint32Array(5172), 214, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData16,
  origin: { x: 1, y: 3 },
  flipY: true,
}, {
  texture: texture128,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder132 = device0.createCommandEncoder();
let textureView129 = texture29.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder8.setBindGroup(2, bindGroup18);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer93, 4); };
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup23);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(61); };
} catch {}
let computePassEncoder28 = commandEncoder87.beginComputePass();
try {
computePassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder28.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup51, new Uint32Array(468), 8, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.append(canvas2);
let bindGroup57 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 133, resource: {buffer: buffer84}}]});
let textureView130 = texture66.createView({dimension: '2d-array', mipLevelCount: 1});
let renderPassEncoder22 = commandEncoder105.beginRenderPass({colorAttachments: [{view: textureView31, loadOp: 'load', storeOp: 'store'}]});
try {
renderPassEncoder7.setVertexBuffer(1, buffer103, 0);
} catch {}
try {
commandEncoder125.resolveQuerySet(querySet1, 482, 0, buffer34, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer89, 40, new DataView(new Uint8Array(9137).map((_, i) => i).buffer), 43, 4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas0);
let texture137 = device0.createTexture({
  size: [1, 270, 105],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder29 = commandEncoder111.beginComputePass();
try {
computePassEncoder14.setBindGroup(3, bindGroup50, new Uint32Array(1103), 155, 0);
} catch {}
try {
computePassEncoder14.end();
} catch {}
try {
computePassEncoder26.setPipeline(pipeline6);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer67, 'uint16', 30, 61);
} catch {}
let buffer104 = device0.createBuffer({size: 7, usage: GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder7.setBindGroup(0, bindGroup41, new Uint32Array(390), 50, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer76, 'uint32', 20, 2);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder121.insertDebugMarker('\u391f');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData10,
  origin: { x: 6, y: 2 },
  flipY: true,
}, {
  texture: texture128,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture138 = device0.createTexture({
  size: {width: 45, height: 12, depthOrArrayLayers: 35},
  sampleCount: 1,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder7.setBindGroup(1, bindGroup55, new Uint32Array(2590), 1_348, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer27, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer41, 52, new DataView(new Uint8Array(2246).map((_, i) => i).buffer), 116, 32);
} catch {}
let imageData17 = new ImageData(132, 80);
let bindGroup58 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer84}}]});
let buffer105 = device0.createBuffer({size: 252, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer46, 0); };
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer100);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer71, 'uint16', 32, 3);
} catch {}
try {
commandEncoder42.resolveQuerySet(querySet0, 3, 0, buffer105, 0);
} catch {}
let externalTexture11 = device0.importExternalTexture({source: videoFrame3});
try {
renderPassEncoder7.setBindGroup(1, bindGroup44, new Uint32Array(1703), 110, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 37, height: 1, depthOrArrayLayers: 45}
*/
{
  source: imageData8,
  origin: { x: 3, y: 8 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 5},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise22 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule2, constants: {}, targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.RED}]},
  vertex: {
    module: shaderModule6,
    buffers: [
      {
        arrayStride: 16,
        attributes: [
          {format: 'float16x4', offset: 0, shaderLocation: 7},
          {format: 'uint32x3', offset: 0, shaderLocation: 2},
          {format: 'float32x3', offset: 0, shaderLocation: 3},
          {format: 'float32x3', offset: 0, shaderLocation: 5},
          {format: 'uint16x4', offset: 0, shaderLocation: 8},
          {format: 'uint32x2', offset: 0, shaderLocation: 0},
          {format: 'float16x4', offset: 0, shaderLocation: 13},
          {format: 'sint8x4', offset: 0, shaderLocation: 15},
          {format: 'snorm16x4', offset: 0, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12},
        ],
      },
    ],
  },
});
let texture139 = device0.createTexture({
  size: {width: 22, height: 6, depthOrArrayLayers: 57},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView131 = texture69.createView({format: 'rgba8unorm', arrayLayerCount: 1});
try {
renderBundleEncoder9.setIndexBuffer(buffer0, 'uint32', 0, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture124,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(2_823).fill(32), /* required buffer size: 2_823 */
{offset: 48, bytesPerRow: 37, rowsPerImage: 75}, {width: 1, height: 0, depthOrArrayLayers: 2});
} catch {}
let bindGroup59 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout9,
  entries: [{binding: 133, resource: {buffer: buffer49, offset: 256}}],
});
let commandEncoder133 = device0.createCommandEncoder({});
let texture140 = device0.createTexture({
  size: {width: 18},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder14.setBindGroup(2, bindGroup33);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline4);
} catch {}
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'iec61966-2-1'} });
let sampler20 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 89.24,
  maxAnisotropy: 15,
});
try {
computePassEncoder5.setBindGroup(2, bindGroup19, new Uint32Array(3877), 970, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(3); };
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup31, new Uint32Array(1068), 79, 0);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(2, buffer27, 16, 15);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let texture141 = device0.createTexture({
  size: {width: 75, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder8.setBindGroup(2, bindGroup6, new Uint32Array(1113), 109, 0);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline18);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup53, new Uint32Array(1059), 244, 0);
} catch {}
try {
commandEncoder43.resolveQuerySet(querySet0, 0, 1, buffer3, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let bindGroup60 = device0.createBindGroup({layout: autogeneratedBindGroupLayout3, entries: []});
let commandBuffer12 = commandEncoder12.finish();
let externalTexture12 = device0.importExternalTexture({source: videoFrame7});
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(2); };
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer71, 'uint16', 4, 6);
} catch {}
try {
commandEncoder30.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2276 */
  offset: 2276,
  buffer: buffer37,
}, {
  texture: texture25,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer12, commandBuffer11]);
} catch {}
let img0 = await imageWithData(38, 38, '#10101010', '#20202020');
let bindGroup61 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout9, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let texture142 = device0.createTexture({
  size: {width: 1, height: 135, depthOrArrayLayers: 1},
  mipLevelCount: 8,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup61);
} catch {}
try {
renderPassEncoder19.setStencilReference(218);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer103, 52, 0);
} catch {}
try {
commandEncoder112.copyTextureToBuffer({
  texture: texture139,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 11},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4454 */
  offset: 4454,
  buffer: buffer7,
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let bindGroup62 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [{binding: 133, resource: {buffer: buffer49, offset: 0, size: 4760}}],
});
let computePassEncoder30 = commandEncoder40.beginComputePass({
  timestampWrites: {querySet: querySet2, beginningOfPassWriteIndex: 5, endOfPassWriteIndex: 4294967295},
});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder7.setBindGroup(0, bindGroup62, new Uint32Array(1649), 136, 0);
} catch {}
try {
computePassEncoder30.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder15.setBindGroup(1, bindGroup46, new Uint32Array(869), 39, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder23.setBindGroup(1, bindGroup0, new Uint32Array(3519), 315, 0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer100, 'uint32', 24, 34);
} catch {}
try {
commandEncoder24.resolveQuerySet(querySet1, 139, 4, buffer92, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 37, height: 1, depthOrArrayLayers: 45}
*/
{
  source: imageData13,
  origin: { x: 1, y: 2 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap3 = await createImageBitmap(imageData14);
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer74, 4); };
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup31, new Uint32Array(462), 62, 0);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer6, 'uint16', 18, 41);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(7, buffer86);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout9]});
let commandEncoder134 = device0.createCommandEncoder({});
let texture143 = device0.createTexture({
  size: [1, 1080, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8sint'],
});
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer6, 16); };
} catch {}
try {
computePassEncoder0.end();
} catch {}
try {
renderPassEncoder19.setBlendConstant({ r: 371.9, g: -393.1, b: 87.12, a: 699.7, });
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer66, 'uint32', 4, 10);
} catch {}
try {
commandEncoder118.clearBuffer(buffer89);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 4, new Uint32Array(7086).map((_, i) => i * 3), 314, 12);
} catch {}
document.body.append(img0);
let buffer106 = device0.createBuffer({size: 180, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandBuffer13 = commandEncoder26.finish();
let texture144 = device0.createTexture({size: [1], mipLevelCount: 1, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder10.setBindGroup(0, bindGroup24);
} catch {}
try {
computePassEncoder12.end();
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup21);
} catch {}
try {
buffer32.unmap();
} catch {}
try {
commandEncoder86.insertDebugMarker('\uc72d');
} catch {}
let pipeline20 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule4, constants: {}}});
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer107 = device0.createBuffer({size: 96, usage: GPUBufferUsage.VERTEX});
let commandEncoder135 = device0.createCommandEncoder();
let texture145 = device0.createTexture({
  size: [1, 540, 1],
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderBundleEncoder3.drawIndirect(buffer94, 116);
} catch {}
let commandBuffer14 = commandEncoder0.finish();
let texture146 = device0.createTexture({
  label: '\u2c30\ub4f4',
  size: [7, 1, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let texture147 = gpuCanvasContext4.getCurrentTexture();
let externalTexture13 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder30.setBindGroup(1, bindGroup48);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer11, 'uint16', 22, 10);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '3d' },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 90,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup63 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 2, resource: {buffer: buffer84}}]});
let textureView132 = texture102.createView({});
try {
computePassEncoder28.setBindGroup(3, bindGroup13);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer73, 4); };
} catch {}
try {
computePassEncoder29.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(1, buffer27, 0, 78);
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
} catch {}
try {
device0.queue.writeBuffer(buffer13, 0, new Uint16Array(7131).map((_, i) => i + 2), 852, 8);
} catch {}
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 5, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 18, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 68,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 105,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {
      binding: 106,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {
      binding: 118,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 132,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d' },
    },
    {binding: 257, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 383,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 421,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 556,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
  ],
});
try {
computePassEncoder29.setBindGroup(0, bindGroup48, new Uint32Array(478), 89, 0);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(7, buffer87);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline18);
} catch {}
try {
commandEncoder113.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 220 */
  offset: 220,
  bytesPerRow: 9472,
  buffer: buffer73,
}, {
  texture: texture45,
  mipLevel: 1,
  origin: {x: 0, y: 14, z: 0},
  aspect: 'all',
}, {width: 0, height: 13, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer10, 36, new Float32Array(54882).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7118)), 42487, 0);
} catch {}
let pipeline21 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4}});
let bindGroup64 = device0.createBindGroup({
  label: '\u{1fa5a}\u88a5\ua02b\u0b05\u{1fc7b}\u053f\u39c5',
  layout: recycledExplicitBindGroupLayout10,
  entries: [
    {binding: 8, resource: textureView128},
    {binding: 56, resource: textureView94},
    {binding: 1, resource: textureView14},
    {binding: 591, resource: textureView9},
  ],
});
try {
renderPassEncoder15.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder3.draw(277, 1, 3_278_110_366, 1);
} catch {}
let bindGroup65 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer84}}]});
let buffer108 = device0.createBuffer({size: 92, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder136 = device0.createCommandEncoder({});
let texture148 = device0.createTexture({
  size: {width: 45, height: 12, depthOrArrayLayers: 1},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer94, 4); };
} catch {}
try {
computePassEncoder25.end();
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(2, buffer39, 0, 3);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture142,
  mipLevel: 4,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(764).fill(121), /* required buffer size: 764 */
{offset: 764, bytesPerRow: 81, rowsPerImage: 32}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas2);
let commandEncoder137 = device0.createCommandEncoder({});
let texture149 = device0.createTexture({
  size: {width: 64},
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder16.setBindGroup(3, bindGroup22, new Uint32Array(7431), 1_774, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder10.setBindGroup(2, bindGroup45);
} catch {}
try {
device0.queue.submit([commandBuffer13]);
} catch {}
let buffer109 = device0.createBuffer({size: 52, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let commandEncoder138 = device0.createCommandEncoder({});
let texture150 = device0.createTexture({
  size: [18, 1, 132],
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm']});
let externalTexture14 = device0.importExternalTexture({source: videoFrame11});
try {
renderPassEncoder14.setIndexBuffer(buffer59, 'uint16', 112, 147);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(2, buffer4, 0, 3);
} catch {}
try {
commandEncoder115.resolveQuerySet(querySet1, 95, 0, buffer0, 0);
} catch {}
let bindGroup66 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 3, resource: sampler13},
    {binding: 4, resource: textureView122},
    {binding: 90, resource: {buffer: buffer70}},
    {binding: 0, resource: textureView106},
    {binding: 2, resource: {buffer: buffer51}},
    {binding: 1, resource: textureView111},
  ],
});
let buffer110 = device0.createBuffer({size: 376, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder139 = device0.createCommandEncoder({});
let textureView133 = texture150.createView({label: '\u0ade\u0832\u6d2f\u9472\u0cdc\uedc1'});
try {
computePassEncoder7.setBindGroup(1, bindGroup61);
} catch {}
try {
renderBundleEncoder3.drawIndirect(buffer74, 20);
} catch {}
try {
commandEncoder71.pushDebugGroup('\u{1ff52}');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 12, y: 1, z: 17},
  aspect: 'all',
}, new Uint8Array(2_300).fill(152), /* required buffer size: 2_300 */
{offset: 115, bytesPerRow: 21, rowsPerImage: 8}, {width: 1, height: 1, depthOrArrayLayers: 14});
} catch {}
let texture151 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 93},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let externalTexture15 = device0.importExternalTexture({source: videoFrame12});
try {
renderPassEncoder13.setBindGroup(0, bindGroup5, new Uint32Array(404), 9, 0);
} catch {}
try {
renderPassEncoder13.draw(140, 0, 1_237_475_255);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer71, 28);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer39, 0);
} catch {}
try {
commandEncoder112.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1632 */
  offset: 1632,
  bytesPerRow: 26112,
  buffer: buffer83,
}, {
  texture: texture144,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: imageData2,
  origin: { x: 14, y: 0 },
  flipY: true,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer111 = device0.createBuffer({size: 292, usage: GPUBufferUsage.VERTEX});
let commandEncoder140 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
globalThis.someLabel = shaderModule3.label;
} catch {}
let textureView134 = texture100.createView({});
let textureView135 = texture60.createView({});
let computePassEncoder31 = commandEncoder75.beginComputePass();
let renderBundle5 = renderBundleEncoder3.finish({});
try {
renderPassEncoder13.drawIndirect(buffer46, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 45, height: 12, depthOrArrayLayers: 35}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture138,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas4 = document.createElement('canvas');
let bindGroup67 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: []});
let texture152 = device0.createTexture({
  size: [18],
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup19);
} catch {}
try {
computePassEncoder31.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder13.draw(416, 0, 161_268_044);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer39, 20);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer89, 'uint16', 0, 15);
} catch {}
try {
  await buffer40.mapAsync(GPUMapMode.WRITE);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture93,
  mipLevel: 0,
  origin: {x: 0, y: 7, z: 0},
  aspect: 'all',
}, new Uint8Array(44).fill(249), /* required buffer size: 44 */
{offset: 44, rowsPerImage: 20}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline22 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 60,
        attributes: [
          {format: 'sint32x3', offset: 0, shaderLocation: 4},
          {format: 'uint32x4', offset: 0, shaderLocation: 3},
          {format: 'sint8x4', offset: 0, shaderLocation: 6},
          {format: 'float32', offset: 8, shaderLocation: 11},
          {format: 'uint8x2', offset: 10, shaderLocation: 5},
          {format: 'float32x2', offset: 0, shaderLocation: 2},
          {format: 'sint32', offset: 4, shaderLocation: 1},
          {format: 'float32x3', offset: 20, shaderLocation: 7},
          {format: 'sint16x2', offset: 8, shaderLocation: 0},
          {format: 'unorm16x4', offset: 8, shaderLocation: 14},
          {format: 'sint8x2', offset: 24, shaderLocation: 10},
        ],
      },
    ],
  },
});
let buffer112 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder141 = device0.createCommandEncoder({});
let textureView136 = texture118.createView({dimension: '2d-array', format: 'rgba8uint', baseArrayLayer: 2, arrayLayerCount: 4});
let textureView137 = texture118.createView({dimension: 'cube-array', baseArrayLayer: 5, arrayLayerCount: 6});
let sampler21 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'linear',
  lodMaxClamp: 74.86,
});
try {
renderBundleEncoder15.setIndexBuffer(buffer11, 'uint16', 30, 7);
} catch {}
try {
device0.queue.writeBuffer(buffer87, 4, new Uint16Array(4512).map((_, i) => i + 4), 7, 4);
} catch {}
let pipeline23 = await promise22;
await gc();
let commandEncoder142 = device0.createCommandEncoder({});
let commandBuffer15 = commandEncoder51.finish();
let texture153 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView138 = texture0.createView({mipLevelCount: 1});
try {
computePassEncoder7.setBindGroup(2, bindGroup65, new Uint32Array(2067), 155, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer6, 12); };
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer68, 28);
} catch {}
try {
renderBundleEncoder6.setBindGroup(2, bindGroup46);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer0, 'uint16', 4, 0);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(2, buffer38, 0, 1);
} catch {}
document.body.append(img0);
let commandBuffer16 = commandEncoder30.finish({});
let texture154 = device0.createTexture({
  size: {width: 1, height: 135, depthOrArrayLayers: 1013},
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder13.draw(8, 0, 464_716_317);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer86, 60, 9);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer17);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let videoFrame15 = new VideoFrame(canvas2, {timestamp: 0});
try {
renderPassEncoder13.draw(113, 0, 199_978_694);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer98, 0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup62);
} catch {}
try {
renderBundleEncoder8.drawIndexedIndirect(buffer6, 0);
} catch {}
try {
renderBundleEncoder8.drawIndirect(buffer46, 4);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder49.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3708 */
  offset: 3708,
  rowsPerImage: 165,
  buffer: buffer37,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer16]);
} catch {}
let pipeline24 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule1,
    constants: {},
    buffers: [
      {
        arrayStride: 1220,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 436, shaderLocation: 3},
          {format: 'sint8x2', offset: 96, shaderLocation: 7},
          {format: 'snorm8x2', offset: 12, shaderLocation: 8},
          {format: 'sint32x3', offset: 120, shaderLocation: 5},
          {format: 'uint8x4', offset: 36, shaderLocation: 12},
          {format: 'sint32x3', offset: 68, shaderLocation: 15},
          {format: 'float16x2', offset: 0, shaderLocation: 9},
          {format: 'unorm8x4', offset: 156, shaderLocation: 2},
          {format: 'snorm16x2', offset: 56, shaderLocation: 13},
          {format: 'float16x4', offset: 400, shaderLocation: 6},
          {format: 'uint16x4', offset: 236, shaderLocation: 4},
          {format: 'float16x4', offset: 184, shaderLocation: 10},
          {format: 'uint16x2', offset: 472, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 0, shaderLocation: 0},
          {format: 'float32x2', offset: 0, shaderLocation: 11},
          {format: 'sint16x4', offset: 4, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw'},
});
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'unspecified', transfer: 'smpte170m'} });
let bindGroup68 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let textureView139 = texture122.createView({});
try {
computePassEncoder28.setBindGroup(3, bindGroup40);
} catch {}
try {
renderPassEncoder13.draw(85, 0, 587_892_391, 0);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer82, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder8.drawIndexedIndirect(buffer74, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
let commandEncoder143 = device0.createCommandEncoder({});
let texture155 = device0.createTexture({
  size: {width: 150, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder32 = commandEncoder137.beginComputePass();
try {
computePassEncoder8.setBindGroup(0, bindGroup60);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer68, 20);
} catch {}
try {
renderBundleEncoder8.drawIndexed(3, 0, 0, 293_536_560);
} catch {}
try {
renderBundleEncoder8.drawIndexedIndirect(buffer68, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer34, 'uint16', 0, 1);
} catch {}
let gpuCanvasContext5 = canvas4.getContext('webgpu');
let commandEncoder144 = device0.createCommandEncoder({});
let textureView140 = texture154.createView({dimension: '3d', baseMipLevel: 0});
let textureView141 = texture114.createView({dimension: '2d', format: 'rgba8unorm', baseMipLevel: 0, baseArrayLayer: 1});
let renderBundle6 = renderBundleEncoder8.finish({});
try {
renderPassEncoder21.setBindGroup(1, bindGroup36);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer39, 8);
} catch {}
try {
commandEncoder71.copyTextureToTexture({
  texture: texture138,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 11},
  aspect: 'all',
},
{
  texture: texture91,
  mipLevel: 0,
  origin: {x: 6, y: 10, z: 72},
  aspect: 'all',
},
{width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer9, 4); };
} catch {}
try {
renderPassEncoder13.draw(67, 0, 546_983_873);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer59, 'uint16', 40, 133);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(2, buffer107, 0, 3);
} catch {}
try {
device0.queue.writeBuffer(buffer41, 8, new Uint32Array(29296).map((_, i) => i * 10), 1865, 16);
} catch {}
let buffer113 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
try {
computePassEncoder1.setBindGroup(2, bindGroup30);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer46, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer59, 'uint32', 88, 216);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline18);
} catch {}
try {
commandEncoder102.copyBufferToBuffer(buffer44, 0, buffer10, 4, 12);
} catch {}
try {
commandEncoder71.popDebugGroup();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
await gc();
let imageData18 = new ImageData(24, 56);
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpte170m', transfer: 'unspecified'} });
let bindGroup69 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 2, resource: {buffer: buffer49}}]});
let sampler22 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMaxClamp: 74.60,
});
try {
computePassEncoder16.setBindGroup(2, bindGroup51);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline7);
} catch {}
try {
commandEncoder130.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3980 */
  offset: 3980,
  buffer: buffer37,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 37, height: 1, depthOrArrayLayers: 45}
*/
{
  source: canvas4,
  origin: { x: 52, y: 81 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 11},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
canvas0.height = 2395;
let commandEncoder145 = device0.createCommandEncoder({});
try {
renderPassEncoder13.draw(99, 0, 1_132_538_257);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer75, 40);
} catch {}
try {
buffer86.unmap();
} catch {}
try {
commandEncoder143.copyBufferToBuffer(buffer7, 172, buffer102, 24, 12);
} catch {}
try {
commandEncoder54.clearBuffer(buffer102);
} catch {}
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'gamma22curve'} });
let bindGroup70 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 90, resource: {buffer: buffer84}},
    {binding: 3, resource: sampler3},
    {binding: 2, resource: {buffer: buffer3, size: 64}},
    {binding: 0, resource: textureView106},
    {binding: 1, resource: textureView111},
    {binding: 4, resource: textureView105},
  ],
});
let computePassEncoder33 = commandEncoder83.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 162, endOfPassWriteIndex: 298}});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder33.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(0, buffer105, 4, 68);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup71 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout12, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let buffer114 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDEX});
let renderPassEncoder23 = commandEncoder129.beginRenderPass({
  colorAttachments: [{
  view: textureView85,
  depthSlice: 497,
  clearValue: { r: -358.1, g: 319.8, b: -352.0, a: -664.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderBundleEncoder20.setBindGroup(3, bindGroup28, new Uint32Array(815), 3, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture65,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 50},
  aspect: 'all',
}, new Uint8Array(2_699).fill(40), /* required buffer size: 2_699 */
{offset: 139, bytesPerRow: 10, rowsPerImage: 8}, {width: 2, height: 0, depthOrArrayLayers: 33});
} catch {}
let promise23 = device0.queue.onSubmittedWorkDone();
let textureView142 = texture13.createView({dimension: '2d'});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer74, 0); };
} catch {}
try {
renderPassEncoder13.end();
} catch {}
let pipeline25 = device0.createComputePipeline({
  layout: pipelineLayout1,
  compute: {module: shaderModule1, entryPoint: 'compute1', constants: {28_210: 1}},
});
let commandEncoder146 = device0.createCommandEncoder({});
try {
computePassEncoder1.setBindGroup(0, bindGroup55);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer105, 'uint16', 10, 7);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer76, 'uint16', 4, 3);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer76, 'uint32', 24, 12);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(5, buffer86, 0, 41);
} catch {}
try {
device0.queue.submit([commandBuffer15]);
} catch {}
let textureView143 = texture124.createView({});
try {
computePassEncoder2.setBindGroup(2, bindGroup29);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup46);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup38, new Uint32Array(1105), 228, 0);
} catch {}
try {
renderBundleEncoder26.setBindGroup(1, bindGroup11);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer100, 'uint32', 20, 8);
} catch {}
try {
commandEncoder101.copyBufferToBuffer(buffer95, 80, buffer72, 20, 56);
} catch {}
try {
commandEncoder35.resolveQuerySet(querySet1, 721, 202, buffer33, 0);
} catch {}
try {
  await promise23;
} catch {}
let img1 = await imageWithData(19, 32, '#10101010', '#20202020');
let commandEncoder147 = device0.createCommandEncoder({});
try {
renderPassEncoder12.setBindGroup(1, bindGroup34);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(0, buffer39);
} catch {}
try {
renderBundleEncoder21.setBindGroup(1, bindGroup13);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(85).fill(69), /* required buffer size: 85 */
{offset: 85}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise24 = device0.queue.onSubmittedWorkDone();
let pipeline26 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  multisample: {},
  fragment: {
  module: shaderModule2,
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-dst'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 44,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32', offset: 0, shaderLocation: 3},
          {format: 'sint32x3', offset: 8, shaderLocation: 4},
          {format: 'sint32', offset: 0, shaderLocation: 0},
          {format: 'float16x2', offset: 8, shaderLocation: 7},
          {format: 'float16x2', offset: 8, shaderLocation: 2},
          {format: 'float32x2', offset: 0, shaderLocation: 11},
          {format: 'uint16x4', offset: 4, shaderLocation: 5},
          {format: 'sint32x2', offset: 0, shaderLocation: 1},
          {format: 'sint32', offset: 0, shaderLocation: 10},
          {format: 'sint16x2', offset: 0, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 12,
        stepMode: 'vertex',
        attributes: [{format: 'unorm8x4', offset: 0, shaderLocation: 14}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
let textureView144 = texture99.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder26.setBindGroup(0, bindGroup60, []);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup22);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer27);
} catch {}
let pipeline27 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule6,
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 0, shaderLocation: 12},
          {format: 'uint16x2', offset: 0, shaderLocation: 0},
          {format: 'uint8x2', offset: 0, shaderLocation: 8},
          {format: 'sint8x4', offset: 0, shaderLocation: 15},
          {format: 'uint8x2', offset: 0, shaderLocation: 2},
          {format: 'snorm8x2', offset: 0, shaderLocation: 3},
          {format: 'snorm16x2', offset: 0, shaderLocation: 11},
          {format: 'float32', offset: 0, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 248,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 60, shaderLocation: 7},
          {format: 'float32x2', offset: 48, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
let autogeneratedBindGroupLayout4 = pipeline18.getBindGroupLayout(1);
let commandEncoder148 = device0.createCommandEncoder({});
let commandBuffer17 = commandEncoder48.finish();
try {
computePassEncoder3.setBindGroup(2, bindGroup69);
} catch {}
try {
computePassEncoder16.setBindGroup(1, bindGroup48, new Uint32Array(1455), 407, 0);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline23);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(5, buffer107, 0, 62);
} catch {}
try {
buffer14.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer110, 12, new Float32Array(9872).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.01457)), 2900, 44);
} catch {}
let promise25 = device0.queue.onSubmittedWorkDone();
let pipeline28 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x68f7c19},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-src-alpha'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 52,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 4, shaderLocation: 3},
          {format: 'unorm8x4', offset: 0, shaderLocation: 2},
          {format: 'snorm8x2', offset: 14, shaderLocation: 13},
          {format: 'uint32x3', offset: 12, shaderLocation: 0},
          {format: 'sint16x4', offset: 4, shaderLocation: 1},
          {format: 'uint32x4', offset: 0, shaderLocation: 5},
          {format: 'unorm16x4', offset: 4, shaderLocation: 4},
          {format: 'sint32', offset: 32, shaderLocation: 10},
          {format: 'float16x4', offset: 16, shaderLocation: 11},
          {format: 'uint8x4', offset: 8, shaderLocation: 15},
          {format: 'uint32x2', offset: 8, shaderLocation: 9},
          {format: 'uint16x4', offset: 8, shaderLocation: 6},
          {format: 'uint32x2', offset: 4, shaderLocation: 7},
          {format: 'uint16x4', offset: 0, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 0, shaderLocation: 8},
          {format: 'float16x2', offset: 0, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back'},
});
let imageData19 = new ImageData(24, 152);
let buffer115 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_SRC});
let texture156 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 381},
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder34 = commandEncoder122.beginComputePass();
try {
renderPassEncoder9.setVertexBuffer(0, buffer38);
} catch {}
let commandEncoder149 = device0.createCommandEncoder({});
try {
renderBundleEncoder26.setIndexBuffer(buffer20, 'uint32', 0, 0);
} catch {}
try {
commandEncoder143.copyTextureToBuffer({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1152 */
  offset: 1152,
  bytesPerRow: 2048,
  buffer: buffer84,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
offscreenCanvas3.width = 170;
let buffer116 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder150 = device0.createCommandEncoder({});
let texture157 = device0.createTexture({
  size: [37, 1, 236],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture158 = device0.createTexture({
  size: {width: 180, height: 48, depthOrArrayLayers: 33},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView145 = texture151.createView({baseArrayLayer: 6, arrayLayerCount: 22});
let computePassEncoder35 = commandEncoder132.beginComputePass({timestampWrites: {querySet: querySet4}});
try {
computePassEncoder34.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer59, 20);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(1, buffer12, 0, 82);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer71, 'uint16', 0, 3);
} catch {}
let imageData20 = new ImageData(12, 8);
let commandEncoder151 = device0.createCommandEncoder({});
let textureView146 = texture118.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6});
let textureView147 = texture60.createView({});
try {
device0.queue.writeTexture({
  texture: texture44,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(87).fill(159), /* required buffer size: 87 */
{offset: 87}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise24;
} catch {}
let imageData21 = new ImageData(68, 88);
let bindGroup72 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout10,
  entries: [
    {binding: 591, resource: textureView9},
    {binding: 8, resource: textureView7},
    {binding: 1, resource: textureView14},
    {binding: 56, resource: textureView28},
  ],
});
let commandEncoder152 = device0.createCommandEncoder();
try {
computePassEncoder33.setBindGroup(0, bindGroup51, new Uint32Array(1928), 268, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer75, 4); };
} catch {}
try {
computePassEncoder3.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup50);
} catch {}
try {
renderPassEncoder22.draw(2, 108, 5, 247_989_167);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer49, 3_872);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer9, 4);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(0, buffer86);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer72, 0, new Uint32Array(9624).map((_, i) => i * 9), 1058, 4);
} catch {}
let autogeneratedBindGroupLayout5 = pipeline13.getBindGroupLayout(0);
let bindGroup73 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout11, entries: [{binding: 133, resource: {buffer: buffer84}}]});
let commandEncoder153 = device0.createCommandEncoder();
let textureView148 = texture90.createView({});
let textureView149 = texture124.createView({});
try {
computePassEncoder5.end();
} catch {}
try {
computePassEncoder35.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer75, 0);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline10);
} catch {}
try {
buffer110.unmap();
} catch {}
try {
  await buffer2.mapAsync(GPUMapMode.WRITE, 8, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 37, height: 1, depthOrArrayLayers: 45}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 13},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline29 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4'}});
let commandEncoder154 = device0.createCommandEncoder({});
let textureView150 = texture150.createView({format: 'r32float'});
try {
renderPassEncoder9.draw(2, 89, 0, 43_614_751);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 317, 0, 244_929_618, 1_167_462_355);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer73, 12);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer73, 16);
} catch {}
try {
renderBundleEncoder6.setBindGroup(3, bindGroup72, new Uint32Array(1068), 119, 0);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(4, buffer105, 0, 30);
} catch {}
try {
buffer46.unmap();
} catch {}
try {
commandEncoder71.resolveQuerySet(querySet4, 120, 1, buffer96, 0);
} catch {}
let buffer117 = device0.createBuffer({
  size: 332,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
try {
renderPassEncoder18.setBindGroup(0, bindGroup40, new Uint32Array(867), 14, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer113, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer83, 1_072);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer105, 'uint16', 10, 7);
} catch {}
let commandEncoder155 = device0.createCommandEncoder({});
let textureView151 = texture119.createView({dimension: '2d-array'});
let renderPassEncoder24 = commandEncoder98.beginRenderPass({
  colorAttachments: [{
  view: textureView92,
  depthSlice: 26,
  clearValue: { r: 195.4, g: -493.4, b: -140.8, a: -963.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet2, beginningOfPassWriteIndex: 4294967295},
});
let externalTexture16 = device0.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer82, 16); };
} catch {}
try {
computePassEncoder10.end();
} catch {}
try {
renderPassEncoder22.draw(4, 867, 6, 983_867_018);
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 85, 0, 69_104_107, 629_552_529);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer98, 0);
} catch {}
try {
renderBundleEncoder24.setBindGroup(2, bindGroup21, new Uint32Array(812), 34, 0);
} catch {}
try {
commandEncoder63.copyBufferToTexture({
  /* bytesInLastRow: 112 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3464 */
  offset: 3464,
  bytesPerRow: 23808,
  buffer: buffer83,
}, {
  texture: texture29,
  mipLevel: 1,
  origin: {x: 6, y: 7, z: 0},
  aspect: 'all',
}, {width: 28, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder127.clearBuffer(buffer72, 104, 24);
} catch {}
await gc();
let bindGroup74 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout12,
  entries: [{binding: 133, resource: {buffer: buffer49, size: 2744}}],
});
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout8, veryExplicitBindGroupLayout7]});
let textureView152 = texture58.createView({dimension: '2d', mipLevelCount: 1});
let texture159 = device0.createTexture({
  size: [1, 135, 1],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder3.setBindGroup(0, bindGroup71, new Uint32Array(1737), 151, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer48, 12); };
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup14, new Uint32Array(279), 36, 0);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer46, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer111, 0);
} catch {}
let texture160 = device0.createTexture({
  size: {width: 1, height: 270, depthOrArrayLayers: 841},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView153 = texture143.createView({dimension: '2d-array'});
try {
renderPassEncoder9.drawIndexedIndirect(buffer93, 0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup44, new Uint32Array(1716), 67, 0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(2, buffer105);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 270, depthOrArrayLayers: 264}
*/
{
  source: canvas0,
  origin: { x: 88, y: 261 },
  flipY: true,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 0, y: 88, z: 5},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 47, depthOrArrayLayers: 0});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer85, 40); };
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer91, 36);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(7, buffer0);
} catch {}
try {
renderBundleEncoder24.setBindGroup(1, bindGroup0, new Uint32Array(231), 23, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let bindGroup75 = device0.createBindGroup({layout: veryExplicitBindGroupLayout9, entries: [{binding: 133, resource: {buffer: buffer84}}]});
let texture161 = device0.createTexture({
  size: {width: 7, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder22.draw(8, 87, 0, 80_913_950);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer98, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer73, 12);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer48);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer44, 24, new Uint32Array(24979).map((_, i) => i * 6), 3857, 12);
} catch {}
try {
  await promise25;
} catch {}
let bindGroup76 = device0.createBindGroup({
  label: '\u2b69\u0a6e\uf830\u059c\u{1fe3e}\u08e4\u{1f654}\u{1feed}\u099f',
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 4, resource: {buffer: buffer49}},
    {binding: 515, resource: sampler14},
    {binding: 100, resource: {buffer: buffer51, offset: 0}},
    {binding: 1, resource: {buffer: buffer49}},
    {binding: 529, resource: textureView5},
  ],
});
let buffer118 = device0.createBuffer({size: 28, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandBuffer18 = commandEncoder46.finish();
let texture162 = device0.createTexture({
  size: [1, 135, 433],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder3.setBindGroup(0, bindGroup31);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder22.draw(7, 292, 10, 210_194_604);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 280, 0, -650_338_813, 197_872_698);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer6, 24);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer7, 0, 981);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(3, buffer71, 24, 4);
} catch {}
try {
device0.queue.submit([commandBuffer14, commandBuffer18, commandBuffer4]);
} catch {}
let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup77 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout12, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let commandEncoder156 = device0.createCommandEncoder({});
let computePassEncoder36 = commandEncoder106.beginComputePass();
try {
renderPassEncoder12.setBindGroup(1, bindGroup28);
} catch {}
try {
renderPassEncoder22.draw(6, 216, 12, 892_987_678);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer94, 60);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer87, 'uint16', 18, 4);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(1, buffer38, 4, 7);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline22);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
globalThis.someLabel = externalTexture12.label;
} catch {}
let commandEncoder157 = device0.createCommandEncoder({});
let textureView154 = texture47.createView({});
let sampler23 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 94.17,
});
try {
computePassEncoder36.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup51, new Uint32Array(1345), 147, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer85, 52);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer114, 'uint16', 4, 1);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder2.drawIndexedIndirect(buffer113, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 80, new Uint32Array(9119).map((_, i) => i * 9), 1923, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture163 = device0.createTexture({size: [1], dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer46, 0); };
} catch {}
try {
renderPassEncoder22.draw(2, 153, 2, 3_843_965_205);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer113, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer20, 'uint16', 0, 1);
} catch {}
try {
renderBundleEncoder2.draw(1, 14, 0, 136_368_320);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(1, buffer12, 76);
} catch {}
try {
commandEncoder91.insertDebugMarker('\u0658');
} catch {}
try {
computePassEncoder1.insertDebugMarker('\u8847');
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 11}
*/
{
  source: offscreenCanvas2,
  origin: { x: 4, y: 127 },
  flipY: true,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder32.setBindGroup(0, bindGroup73);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 214, 0, 104_111_773, 506_979_589);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer76);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup2);
} catch {}
let bindGroup78 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 56, resource: textureView23},
    {binding: 591, resource: textureView38},
    {binding: 1, resource: textureView39},
    {binding: 8, resource: textureView7},
  ],
});
let buffer119 = device0.createBuffer({
  size: 56,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture164 = device0.createTexture({
  size: {width: 37, height: 1, depthOrArrayLayers: 83},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder22.drawIndexed(2, 74, 0, 305_479_688, 1_147_229_092);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer117, 12);
} catch {}
try {
renderPassEncoder17.drawIndirect(buffer75, 16);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer73, 44);
} catch {}
try {
commandEncoder112.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 10000 */
  offset: 10000,
  rowsPerImage: 542,
  buffer: buffer7,
}, {
  texture: texture152,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder138.copyTextureToTexture({
  texture: texture77,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder158 = device0.createCommandEncoder({});
try {
computePassEncoder7.setBindGroup(3, bindGroup14);
} catch {}
try {
computePassEncoder19.setBindGroup(0, bindGroup30, new Uint32Array(347), 12, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2, 2); };
} catch {}
try {
computePassEncoder19.end();
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 96, 0, 297_879_423, 4_294_967_199);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer83, 3_344);
} catch {}
try {
renderBundleEncoder2.draw(1, 260, 0, 362_015_311);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(0, buffer71, 0);
} catch {}
try {
commandEncoder116.pushDebugGroup('\u{1fdef}');
} catch {}
try {
commandEncoder116.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer43, 28, new Float16Array(13250).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.076)), 823, 12);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer93, 0); };
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 485, 0, 366_306_937, 665_549_118);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup52, []);
} catch {}
try {
renderBundleEncoder9.drawIndirect(buffer46, 0);
} catch {}
try {
commandEncoder119.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2344 */
  offset: 2344,
  buffer: buffer83,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let externalTexture17 = device0.importExternalTexture({source: videoFrame16, colorSpace: 'srgb'});
try {
computePassEncoder32.setBindGroup(2, bindGroup58);
} catch {}
try {
computePassEncoder7.end();
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer94, 60);
} catch {}
try {
renderBundleEncoder20.setBindGroup(3, bindGroup25);
} catch {}
try {
renderBundleEncoder9.drawIndirect(buffer6, 12);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer114, 'uint32', 28, 5);
} catch {}
try {
renderPassEncoder23.insertDebugMarker('\u01f5');
} catch {}
await gc();
let commandEncoder159 = device0.createCommandEncoder({});
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 82});
let textureView155 = texture19.createView({dimension: '2d', format: 'bgra8unorm', baseArrayLayer: 13, arrayLayerCount: 1});
try {
computePassEncoder33.setBindGroup(1, bindGroup40, new Uint32Array(1062), 217, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 98, 0, 70_803_637, 1_657_808_735);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup75, new Uint32Array(439), 34, 0);
} catch {}
try {
renderBundleEncoder2.draw(1, 309, 0, 385_999_097);
} catch {}
try {
renderBundleEncoder2.drawIndexed(3, 425, 0, 496_255_331, 29_981_918);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer103, 24);
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
try {
  await promise26;
} catch {}
let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let commandEncoder160 = device0.createCommandEncoder();
let texture165 = device0.createTexture({
  label: '\u7ecd\ua8f5\ubd95\u98c7\u0bc3\uebf5',
  size: {width: 1, height: 135, depthOrArrayLayers: 1},
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder37 = commandEncoder17.beginComputePass();
try {
computePassEncoder30.setBindGroup(0, bindGroup55, new Uint32Array(3946), 35, 0);
} catch {}
try {
computePassEncoder37.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup61, new Uint32Array(904), 26, 0);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer46, 4);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer38, 'uint16', 4, 2);
} catch {}
try {
commandEncoder90.resolveQuerySet(querySet0, 0, 2, buffer89, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 75, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture31,
  mipLevel: 1,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline30 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    constants: {},
    buffers: [
      {
        arrayStride: 80,
        attributes: [
          {format: 'float32x3', offset: 12, shaderLocation: 13},
          {format: 'float32x4', offset: 28, shaderLocation: 3},
          {format: 'uint32x3', offset: 0, shaderLocation: 14},
          {format: 'snorm8x2', offset: 14, shaderLocation: 12},
          {format: 'uint16x2', offset: 4, shaderLocation: 0},
          {format: 'uint32x2', offset: 4, shaderLocation: 6},
          {format: 'unorm16x2', offset: 8, shaderLocation: 8},
          {format: 'snorm8x2', offset: 24, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 468,
        attributes: [
          {format: 'uint16x2', offset: 84, shaderLocation: 9},
          {format: 'sint16x2', offset: 8, shaderLocation: 10},
          {format: 'uint32x3', offset: 56, shaderLocation: 5},
          {format: 'uint32x4', offset: 16, shaderLocation: 7},
          {format: 'sint32x4', offset: 256, shaderLocation: 1},
          {format: 'uint32x4', offset: 304, shaderLocation: 15},
          {format: 'unorm8x2', offset: 16, shaderLocation: 2},
        ],
      },
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 0, shaderLocation: 11}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
document.body.prepend(canvas1);
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout5, autogeneratedBindGroupLayout4]});
try {
renderPassEncoder22.drawIndexed(2, 72, 0, -863_506_357, 421_650_737);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer7);
} catch {}
try {
renderBundleEncoder9.draw(3, 444, 3, 33_642_197);
} catch {}
let promise27 = device0.queue.onSubmittedWorkDone();
try {
renderPassEncoder17.setBlendConstant({ r: 811.1, g: -875.2, b: 373.7, a: -667.3, });
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 39, 0, 570_243_112, 387_347_129);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer118, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer4, 20);
} catch {}
try {
buffer51.unmap();
} catch {}
let textureView156 = texture100.createView({});
let textureView157 = texture148.createView({format: 'rgba8unorm'});
let renderBundle7 = renderBundleEncoder9.finish({});
try {
computePassEncoder30.setBindGroup(2, bindGroup71);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup78, []);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer83, 1_372);
} catch {}
document.body.append(canvas3);
let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '3d' },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 90,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let textureView158 = texture33.createView({});
try {
renderPassEncoder9.drawIndexedIndirect(buffer94, 52);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer91, 168);
} catch {}
document.body.prepend(img1);
let img2 = await imageWithData(52, 33, '#10101010', '#20202020');
let textureView159 = texture157.createView({});
let externalTexture18 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'});
try {
computePassEncoder13.setBindGroup(1, bindGroup19, new Uint32Array(3774), 187, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder9.draw(2, 162, 0, 774_204_905);
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 36, 0, 422_603_038, 75_479_940);
} catch {}
try {
renderBundleEncoder21.setBindGroup(3, bindGroup35, []);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer49, 88);
} catch {}
try {
commandEncoder94.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 288 */
  offset: 288,
  bytesPerRow: 1280,
  rowsPerImage: 15,
  buffer: buffer7,
}, {
  texture: texture45,
  mipLevel: 1,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
}, {width: 0, height: 9, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder24.pushDebugGroup('\ube1a');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(227).fill(141), /* required buffer size: 227 */
{offset: 227}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder161 = device0.createCommandEncoder({});
try {
renderPassEncoder23.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup62, new Uint32Array(2474), 241, 0);
} catch {}
try {
renderPassEncoder9.draw(2, 151, 1, 250_414_113);
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 119, 0, 250_644_838, 91_387_724);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer94, 24);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer100, 'uint16', 4, 7);
} catch {}
try {
renderBundleEncoder27.setBindGroup(2, bindGroup35, new Uint32Array(1255), 517, 0);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer114, 'uint32', 8, 20);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(81).fill(90), /* required buffer size: 81 */
{offset: 81}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
canvas2.width = 1494;
let bindGroup79 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout12, entries: [{binding: 133, resource: {buffer: buffer49}}]});
try {
computePassEncoder27.setBindGroup(1, bindGroup26, new Uint32Array(1969), 149, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1, 2, 1); };
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 83, 0, -2_099_756_264, 381_813_604);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer74, 0);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer114, 'uint32', 36, 12);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(7, buffer31, 4, 38);
} catch {}
try {
commandEncoder100.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 212 */
  offset: 212,
  buffer: buffer27,
}, {
  texture: texture142,
  mipLevel: 5,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 591,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let bindGroup80 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer84}}]});
let commandEncoder162 = device0.createCommandEncoder({});
try {
computePassEncoder8.setBindGroup(0, bindGroup60, new Uint32Array(841), 9, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(4);
} catch {}
try {
renderPassEncoder9.draw(2, 5, 0, 1_033_757_283);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup57);
} catch {}
try {
renderBundleEncoder2.drawIndexed(3, 177, 0, -1_838_555_563, 82_620_840);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer6, 'uint32', 0, 3);
} catch {}
let bindGroup81 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer84}}]});
let texture166 = device0.createTexture({size: [30], dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC});
let textureView160 = texture94.createView({arrayLayerCount: 1});
try {
computePassEncoder35.setBindGroup(1, bindGroup40, new Uint32Array(2803), 1_333, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer49, 552); };
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 45, 0, 766_033_900, 74_861_214);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer68, 168);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer6, 0);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(7, buffer7, 6_792, 3_696);
} catch {}
try {
renderBundleEncoder2.draw(1, 25, 0, 1_198_424_887);
} catch {}
try {
buffer28.unmap();
} catch {}
try {
commandEncoder89.copyBufferToTexture({
  /* bytesInLastRow: 14 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 2356 */
  offset: 2356,
  buffer: buffer83,
}, {
  texture: texture125,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder24.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer14, 0, new Float32Array(3158).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9790)), 243, 0);
} catch {}
let pipeline31 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute2'}});
let texture167 = device0.createTexture({
  size: [64, 64, 18],
  mipLevelCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView161 = texture110.createView({});
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder2.drawIndexed(3, 135, 0, 547_477_690, 2_003_878_762);
} catch {}
try {
commandEncoder158.copyBufferToBuffer(buffer37, 2676, buffer102, 16, 20);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1888 */
  offset: 1888,
  rowsPerImage: 68,
  buffer: buffer83,
}, {
  texture: texture105,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder6.insertDebugMarker('\ud2bf');
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
texture124.label = '\u40a1\u7ba7\u4d3d\u0e27\ue32e';
} catch {}
let textureView162 = texture167.createView({baseArrayLayer: 9, arrayLayerCount: 1});
let texture168 = device0.createTexture({
  size: [1, 540, 130],
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView163 = texture111.createView({});
try {
renderPassEncoder21.setBindGroup(1, bindGroup67, new Uint32Array(47), 0, 0);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer83, 848);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer103, 0, 31);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let commandEncoder163 = device0.createCommandEncoder();
let externalTexture19 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder26.setBindGroup(0, bindGroup60, new Uint32Array(1360), 76, 0);
} catch {}
try {
renderPassEncoder22.draw(5, 75, 7, 889_662_172);
} catch {}
try {
renderBundleEncoder2.draw(1, 383, 0, 30_965_271);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer49, 'uint32', 2_476, 315);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline17);
} catch {}
try {
commandEncoder55.copyTextureToBuffer({
  texture: texture132,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1880 */
  offset: 1880,
  bytesPerRow: 11264,
  buffer: buffer7,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer14, 0, new Uint16Array(10210).map((_, i) => i + 3), 3945, 8);
} catch {}
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470m', transfer: 'gamma22curve'} });
let renderBundle8 = renderBundleEncoder2.finish({});
let externalTexture20 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'});
try {
computePassEncoder36.setBindGroup(2, bindGroup77, new Uint32Array(483), 92, 0);
} catch {}
try {
renderPassEncoder17.end();
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer103, 0);
} catch {}
try {
commandEncoder148.clearBuffer(buffer29, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(11); };
} catch {}
let bindGroup82 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [{binding: 133, resource: {buffer: buffer84, offset: 0}}],
});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup81);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup18, new Uint32Array(2517), 435, 0);
} catch {}
try {
renderPassEncoder9.draw(3, 72, 1, 141_372_972);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 16, 0, 32_626_953, 147_595_331);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(4, buffer111);
} catch {}
try {
renderBundleEncoder11.insertDebugMarker('\u{1fbcd}');
} catch {}
let commandEncoder164 = device0.createCommandEncoder({});
let externalTexture21 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'});
try {
renderPassEncoder4.setBindGroup(3, bindGroup47);
} catch {}
try {
renderPassEncoder9.draw(2, 11, 0, 373_517_041);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline18);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(7, buffer39);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture106,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(191).fill(90), /* required buffer size: 191 */
{offset: 191}, {width: 86, height: 0, depthOrArrayLayers: 1});
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470bg', transfer: 'bt1361ExtendedColourGamut'} });
let buffer120 = device0.createBuffer({size: 452, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture169 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 92},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder27.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 57, 0, -1_115_105_547, 924_200_010);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
  await promise27;
} catch {}
document.body.append(img2);
let buffer121 = device0.createBuffer({size: 123, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let textureView164 = texture101.createView({mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 7});
let textureView165 = texture110.createView({});
try {
computePassEncoder35.setBindGroup(0, bindGroup80);
} catch {}
try {
renderPassEncoder9.draw(2, 75, 0, 519_367_833);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup53);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder18.pushDebugGroup('\u01d1');
} catch {}
try {
device0.queue.writeBuffer(buffer71, 32, new DataView(new ArrayBuffer(71144)), 1268, 0);
} catch {}
let texture170 = device0.createTexture({
  label: '\u089c\u0d6a\u0923\u33c6',
  size: [150],
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture22 = device0.importExternalTexture({source: videoFrame0});
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer48, 8); };
} catch {}
try {
computePassEncoder30.end();
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(6);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer68, 56);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer6, 72);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer105, 'uint32', 8, 27);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline23);
} catch {}
try {
computePassEncoder31.insertDebugMarker('\u9bdd');
} catch {}
let commandEncoder165 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup77);
} catch {}
try {
renderPassEncoder9.draw(2, 74, 1, 519_949_034);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer117, 128);
} catch {}
try {
renderBundleEncoder6.setBindGroup(2, bindGroup26, []);
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup75, new Uint32Array(699), 406, 0);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer66, 'uint16', 18, 10);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(7); };
} catch {}
let bindGroup83 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 1, resource: {buffer: buffer84}},
    {binding: 529, resource: textureView46},
    {binding: 100, resource: {buffer: buffer67}},
    {binding: 515, resource: sampler2},
    {binding: 4, resource: {buffer: buffer49}},
  ],
});
let commandEncoder166 = device0.createCommandEncoder({});
let texture171 = device0.createTexture({
  size: [1, 540, 1],
  sampleCount: 1,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder26.setBindGroup(0, bindGroup67, new Uint32Array(2953), 515, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer91, 24); };
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup27);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder22.draw(3, 930, 1, 264_963_254);
} catch {}
try {
renderPassEncoder14.drawIndexedIndirect(buffer71, 20);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer75, 0);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline22);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
document.body.append(canvas2);
let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
  ],
});
let commandBuffer19 = commandEncoder14.finish();
let textureView166 = texture36.createView({dimension: '2d-array'});
try {
renderPassEncoder20.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup6);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(1, buffer107);
} catch {}
try {
computePassEncoder31.insertDebugMarker('\u01b1');
} catch {}
let commandEncoder167 = device0.createCommandEncoder();
let textureView167 = texture153.createView({dimension: '2d-array'});
let sampler24 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 94.32});
try {
computePassEncoder16.setBindGroup(2, bindGroup49, new Uint32Array(617), 36, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer9, 8); };
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup11);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(8);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 83, 0, 277_057_715, 362_353_569);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer93, 0);
} catch {}
let pipeline32 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, constants: {}}});
let commandEncoder168 = device0.createCommandEncoder({});
let texture172 = device0.createTexture({
  size: [45],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView168 = texture14.createView({mipLevelCount: 2});
try {
computePassEncoder3.setBindGroup(0, bindGroup55, new Uint32Array(942), 112, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 141, 0, -2_145_137_613, 353_602_091);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer117, 24);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup18);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame21 = new VideoFrame(imageBitmap3, {timestamp: 0});
let texture173 = device0.createTexture({
  size: [7, 1, 65],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture174 = gpuCanvasContext2.getCurrentTexture();
let textureView169 = texture36.createView({dimension: '2d-array'});
let computePassEncoder38 = commandEncoder35.beginComputePass();
try {
renderPassEncoder9.draw(2, 33, 1, 1_089_825_113);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline30);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup17);
} catch {}
try {
renderBundleEncoder28.setBindGroup(3, bindGroup55, new Uint32Array(791), 201, 0);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline30);
} catch {}
try {
device0.queue.writeBuffer(buffer119, 4, new Uint16Array(6538).map((_, i) => i + 8), 39, 4);
} catch {}
let bindGroup84 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout6, entries: [{binding: 133, resource: {buffer: buffer49}}]});
let buffer122 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC});
try {
computePassEncoder38.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.end();
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer49, 296);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer67, 'uint32', 136, 40);
} catch {}
try {
commandEncoder133.copyBufferToBuffer(buffer117, 60, buffer102, 16, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
adapter0.label = '\u08c6\u66b6\ud3b2\uc692\uc9c6\u{1fcde}\u{1fc64}\u07af';
} catch {}
let textureView170 = texture117.createView({});
try {
renderBundleEncoder20.setBindGroup(2, bindGroup64, new Uint32Array(2099), 294, 0);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(3, buffer105);
} catch {}
try {
  await shaderModule3.getCompilationInfo();
} catch {}
try {
commandEncoder76.insertDebugMarker('\u3cbf');
} catch {}
try {
device0.queue.writeBuffer(buffer101, 72, new Float16Array(6295).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.796)), 368, 32);
} catch {}
let bindGroup85 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 591, resource: textureView142},
    {binding: 56, resource: textureView28},
    {binding: 8, resource: textureView128},
    {binding: 1, resource: textureView14},
  ],
});
let buffer123 = device0.createBuffer({size: 224, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true, stencilReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer75, 8); };
} catch {}
try {
computePassEncoder3.end();
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer9, 24);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer48, 180);
} catch {}
let promise28 = device0.queue.onSubmittedWorkDone();
let texture175 = device0.createTexture({
  label: '\u{1fd43}\uf857\u{1fd34}\u{1ff22}',
  size: {width: 18, height: 1, depthOrArrayLayers: 1},
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler25 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.82,
});
try {
renderPassEncoder2.setBindGroup(1, bindGroup85);
} catch {}
try {
renderPassEncoder9.draw(2, 52, 0, 1_763_012);
} catch {}
try {
commandEncoder141.resolveQuerySet(querySet5, 5, 1, buffer22, 0);
} catch {}
let bindGroup86 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 1, resource: textureView111},
    {binding: 3, resource: sampler9},
    {binding: 90, resource: {buffer: buffer51, size: 268}},
    {binding: 4, resource: textureView105},
    {binding: 0, resource: textureView152},
    {binding: 2, resource: {buffer: buffer117}},
  ],
});
let buffer124 = device0.createBuffer({size: 79, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
try {
computePassEncoder32.setBindGroup(0, bindGroup80, []);
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 333, 0, 43_711_329, 1_600_317_922);
} catch {}
try {
renderBundleEncoder11.setBindGroup(3, bindGroup13, new Uint32Array(2259), 1_086, 0);
} catch {}
let commandEncoder169 = device0.createCommandEncoder();
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup57, new Uint32Array(92), 39, 0);
} catch {}
try {
renderPassEncoder22.draw(17, 358, 2, 320_017_170);
} catch {}
try {
renderPassEncoder18.popDebugGroup();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
try {
renderPassEncoder9.draw(2, 88, 0, 745_265_187);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 66, 0, -1_430_573_302, 335_160_048);
} catch {}
try {
computePassEncoder36.insertDebugMarker('\u930f');
} catch {}
let bindGroup87 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout7,
  entries: [
    {binding: 56, resource: textureView135},
    {binding: 8, resource: textureView128},
    {binding: 591, resource: textureView152},
    {binding: 1, resource: textureView39},
  ],
});
let textureView171 = texture76.createView({aspect: 'all', mipLevelCount: 1});
try {
renderPassEncoder20.setBindGroup(2, bindGroup70);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup80, new Uint32Array(2830), 911, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 78, 0, -1_766_764_370, 1_062_849_577);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer118, 0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(3, buffer111, 20, 107);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(171); };
} catch {}
let buffer125 = device0.createBuffer({size: 248, usage: GPUBufferUsage.INDIRECT});
let commandEncoder170 = device0.createCommandEncoder();
try {
computePassEncoder2.setBindGroup(0, bindGroup41, new Uint32Array(1478), 166, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer6, 32); };
} catch {}
try {
renderPassEncoder22.drawIndexed(2, 294, 0, -1_996_967_095, 1_234_905_499);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer59, 16);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer6, 8);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer0, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline23);
} catch {}
try {
commandEncoder170.insertDebugMarker('\u811b');
} catch {}
try {
renderPassEncoder18.insertDebugMarker('\u0537');
} catch {}
await gc();
let buffer126 = device0.createBuffer({size: 364, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
let commandEncoder171 = device0.createCommandEncoder({});
let texture176 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 104},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder39 = commandEncoder123.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer82, 8); };
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder22.drawIndexedIndirect(buffer39, 8);
} catch {}
try {
renderPassEncoder22.drawIndirect(buffer39, 20);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer105, 0, 5);
} catch {}
try {
renderBundleEncoder6.setBindGroup(3, bindGroup7);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup33, new Uint32Array(133), 80, 0);
} catch {}
let pipeline33 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule0}});
try {
  await promise28;
} catch {}
let imageData22 = new ImageData(64, 80);
try {
computePassEncoder39.setPipeline(pipeline29);
} catch {}
try {
renderPassEncoder22.draw(12, 18, 3, 283_734_772);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer98, 4);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(7, buffer17);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(0, buffer126, 0, 185);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 18, height: 1, depthOrArrayLayers: 45}
*/
{
  source: videoFrame19,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 18},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture177 = device0.createTexture({
  size: [90, 24, 1],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView172 = texture125.createView({dimension: '2d-array', format: 'r8unorm'});
let computePassEncoder40 = commandEncoder49.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder18.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder22.end();
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer94, 44);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer85, 4);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup62);
} catch {}
try {
computePassEncoder31.insertDebugMarker('\u5d4a');
} catch {}
let textureView173 = texture167.createView({arrayLayerCount: 3});
let textureView174 = texture70.createView({format: 'rgba8unorm'});
try {
computePassEncoder26.setBindGroup(3, bindGroup38, new Uint32Array(1234), 319, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer48, 4); };
} catch {}
try {
computePassEncoder40.setPipeline(pipeline32);
} catch {}
try {
renderPassEncoder9.draw(2, 376, 1, 689_118_416);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer49, 232);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer75, 36);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer113, 0, 0);
} catch {}
try {
commandEncoder29.copyBufferToBuffer(buffer112, 56, buffer116, 12, 16);
} catch {}
let recycledExplicitBindGroupLayout13 = pipeline2.getBindGroupLayout(1);
let texture178 = device0.createTexture({
  size: [1, 1080, 1],
  mipLevelCount: 2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm-srgb'],
});
let textureView175 = texture48.createView({});
let sampler26 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  lodMaxClamp: 99.20,
  compare: 'not-equal',
  maxAnisotropy: 1,
});
try {
renderPassEncoder15.setBindGroup(1, bindGroup18, new Uint32Array(245), 58, 0);
} catch {}
try {
renderPassEncoder9.draw(2, 111, 1, 807_691_270);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer49, 1_188);
} catch {}
try {
commandEncoder157.pushDebugGroup('\u02a2');
} catch {}
let pipeline34 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}});
try {
gpuCanvasContext5.unconfigure();
} catch {}
let commandEncoder172 = device0.createCommandEncoder({});
let commandBuffer20 = commandEncoder4.finish();
let texture179 = device0.createTexture({
  size: [1, 135, 1],
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView176 = texture177.createView({mipLevelCount: 1});
try {
renderPassEncoder9.end();
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(0, buffer113, 0, 6);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(1, 2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer93, 0); };
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline30);
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup66);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer121, 32);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline27);
} catch {}
try {
  await shaderModule4.getCompilationInfo();
} catch {}
try {
device0.queue.submit([commandBuffer20]);
} catch {}
await gc();
let commandBuffer21 = commandEncoder70.finish();
let texture180 = device0.createTexture({
  size: {width: 90, height: 24, depthOrArrayLayers: 14},
  mipLevelCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle9 = renderBundleEncoder6.finish({});
try {
computePassEncoder31.setBindGroup(0, bindGroup32);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer76, 'uint16', 4, 7);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer111, 32, 71);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer48, 'uint16', 112, 29);
} catch {}
try {
device0.queue.writeBuffer(buffer71, 40, new DataView(new ArrayBuffer(53240)), 1929, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap3,
  origin: { x: 0, y: 2 },
  flipY: false,
}, {
  texture: texture128,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView177 = texture143.createView({dimension: '2d-array'});
try {
renderPassEncoder19.setPipeline(pipeline30);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer100, 'uint16', 6, 2);
} catch {}
try {
device0.queue.submit([commandBuffer21, commandBuffer19]);
} catch {}
let buffer127 = device0.createBuffer({size: 24, usage: GPUBufferUsage.VERTEX});
let commandEncoder173 = device0.createCommandEncoder();
let textureView178 = texture150.createView({baseMipLevel: 0});
let textureView179 = texture158.createView({arrayLayerCount: 1});
try {
computePassEncoder35.setBindGroup(2, bindGroup61);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer71, 'uint32', 0, 23);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer71, 'uint32', 12, 3);
} catch {}
try {
commandEncoder99.copyBufferToBuffer(buffer120, 36, buffer87, 12, 52);
} catch {}
try {
commandEncoder149.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 292 */
  offset: 292,
  buffer: buffer33,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline35 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule4}});
let texture181 = device0.createTexture({
  size: [1, 135, 1],
  mipLevelCount: 2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder4.setBindGroup(3, bindGroup2, new Uint32Array(2576), 456, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer59, 'uint32', 68, 193);
} catch {}
try {
renderBundleEncoder18.setBindGroup(1, bindGroup16);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup18, new Uint32Array(684), 299, 0);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer18, 'uint16', 6, 6);
} catch {}
try {
commandEncoder167.copyBufferToBuffer(buffer25, 8, buffer66, 8, 36);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(16); };
} catch {}
await gc();
let canvas5 = document.createElement('canvas');
let bindGroup88 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout19,
  entries: [
    {binding: 2, resource: {buffer: buffer44}},
    {binding: 90, resource: {buffer: buffer49, offset: 2816}},
    {binding: 3, resource: sampler17},
    {binding: 1, resource: textureView107},
    {binding: 4, resource: textureView122},
    {binding: 0, resource: textureView106},
  ],
});
let commandEncoder174 = device0.createCommandEncoder({});
let textureView180 = texture181.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let renderPassEncoder25 = commandEncoder97.beginRenderPass({
  colorAttachments: [{view: textureView93, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet5,
  timestampWrites: {querySet: querySet4, endOfPassWriteIndex: 32},
  maxDrawCount: 133163665,
});
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer49, 3_656); };
} catch {}
try {
computePassEncoder20.end();
} catch {}
try {
computePassEncoder34.setPipeline(pipeline35);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
});
} catch {}
let pipeline36 = device0.createRenderPipeline({
  label: '\uf7b5\u07c0\u{1fabe}\udb38\u0cb6',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule2,
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 484,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 108, shaderLocation: 7},
          {format: 'sint32x3', offset: 104, shaderLocation: 6},
          {format: 'uint16x2', offset: 76, shaderLocation: 5},
          {format: 'sint32x2', offset: 28, shaderLocation: 4},
          {format: 'sint32x4', offset: 24, shaderLocation: 0},
          {format: 'uint32x4', offset: 24, shaderLocation: 3},
          {format: 'sint32', offset: 0, shaderLocation: 1},
          {format: 'unorm16x4', offset: 64, shaderLocation: 2},
          {format: 'float16x4', offset: 68, shaderLocation: 11},
          {format: 'float32', offset: 16, shaderLocation: 14},
          {format: 'sint32x2', offset: 88, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw'},
});
try {
renderPassEncoder6.setPipeline(pipeline30);
} catch {}
try {
renderBundleEncoder22.setBindGroup(3, bindGroup87, new Uint32Array(480), 56, 0);
} catch {}
try {
buffer22.unmap();
} catch {}
let gpuCanvasContext6 = canvas5.getContext('webgpu');
document.body.append(canvas3);
let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({
  entries: [
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 100,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 515,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 529,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let recycledExplicitBindGroupLayout14 = pipeline20.getBindGroupLayout(0);
let buffer128 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true, stencilReadOnly: false});
try {
renderPassEncoder0.setIndexBuffer(buffer66, 'uint32', 4, 11);
} catch {}
let commandEncoder175 = device0.createCommandEncoder({});
let texture182 = gpuCanvasContext1.getCurrentTexture();
try {
computePassEncoder35.setBindGroup(2, bindGroup48);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup74, new Uint32Array(1636), 504, 0);
} catch {}
try {
commandEncoder157.popDebugGroup();
} catch {}
try {
renderBundleEncoder18.insertDebugMarker('\u05a9');
} catch {}
videoFrame0.close();
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame7.close();
videoFrame8.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
videoFrame17.close();
videoFrame18.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
}
async function window1() {
let promise0 = navigator.gpu.requestAdapter({});
let promise1 = navigator.gpu.requestAdapter({});
let adapter0 = await navigator.gpu.requestAdapter();
let device0 = await adapter0.requestDevice({
  defaultQueue: {},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
    'float16-renderable',
    'float32-renderable',
    'core-features-and-limits',
    'timestamp-query',
  ],
});
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte432', transfer: 'bt2020_12bit'} });
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let buffer0 = device0.createBuffer({size: 136, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false});
let texture0 = device0.createTexture({
  size: [4, 6, 1],
  dimension: '2d',
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let pipelineLayout0 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0],
});
let commandEncoder0 = device0.createCommandEncoder({});
let textureView0 = texture0.createView({mipLevelCount: 1});
let texture1 = device0.createTexture({size: [4, 6, 1], format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder0 = commandEncoder0.beginComputePass();
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let texture2 = device0.createTexture({
  size: {width: 4, height: 6, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture3 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 14},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32sint'],
});
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let buffer1 = device0.createBuffer({size: 536, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder1 = device0.createCommandEncoder({});
let texture4 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 1058},
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
await gc();
let buffer2 = device0.createBuffer({size: 21, usage: GPUBufferUsage.COPY_DST});
let sampler0 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'linear', compare: 'always'});
let videoFrame1 = new VideoFrame(videoFrame0, {timestamp: 0});
let textureView1 = texture2.createView({dimension: '2d-array', baseMipLevel: 0});
try {
device0.queue.submit([]);
} catch {}
let buffer3 = device0.createBuffer({size: 160, usage: GPUBufferUsage.INDIRECT});
let textureView2 = texture4.createView({dimension: '3d'});
let computePassEncoder1 = commandEncoder1.beginComputePass();
let commandEncoder2 = device0.createCommandEncoder({});
let texture5 = device0.createTexture({
  size: [97, 60, 1],
  dimension: '2d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let pipelineLayout1 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout2],
});
let buffer4 = device0.createBuffer({size: 212, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let sampler1 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'mirror-repeat', compare: 'equal'});
let texture6 = device0.createTexture({
  size: [780, 480, 1],
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView3 = texture0.createView({aspect: 'depth-only', baseMipLevel: 0, baseArrayLayer: 0});
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout1]});
let commandEncoder3 = device0.createCommandEncoder({});
let textureView4 = texture4.createView({dimension: '3d', arrayLayerCount: 1});
let textureView5 = texture5.createView({aspect: 'all', baseMipLevel: 0});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 1});
try {
buffer3.unmap();
} catch {}
let commandEncoder4 = device0.createCommandEncoder();
let texture7 = device0.createTexture({
  size: [390, 24, 1],
  sampleCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture8 = device0.createTexture({
  size: [8, 12, 2],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder2 = commandEncoder3.beginComputePass();
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], stencilReadOnly: true});
let commandEncoder5 = device0.createCommandEncoder({});
let texture9 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
buffer1.unmap();
} catch {}
let commandEncoder6 = device0.createCommandEncoder({});
let texture10 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView6 = texture8.createView({mipLevelCount: 1});
try {
buffer3.unmap();
} catch {}
let texture11 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  format: 'r32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], stencilReadOnly: true});
try {
buffer2.unmap();
} catch {}
try {
commandEncoder2.copyBufferToBuffer(buffer0, 48, buffer2, 0, 4);
} catch {}
try {
commandEncoder2.copyTextureToTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 4, y: 11, z: 0},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 0,
  origin: {x: 2, y: 8, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder7 = device0.createCommandEncoder({});
let textureView7 = texture7.createView({});
let texture12 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 26},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
texture7.destroy();
} catch {}
let buffer5 = device0.createBuffer({size: 308, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder8 = device0.createCommandEncoder({});
let texture13 = device0.createTexture({
  size: [780, 480, 72],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture14 = device0.createTexture({
  size: {width: 195, height: 12, depthOrArrayLayers: 225},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView8 = texture1.createView({dimension: '2d-array'});
try {
device0.queue.writeBuffer(buffer2, 0, new Float32Array(21081).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.2245)), 6977, 0);
} catch {}
let img0 = await imageWithData(71, 74, '#10101010', '#20202020');
let commandEncoder9 = device0.createCommandEncoder({});
let texture15 = device0.createTexture({size: [390, 24, 1], mipLevelCount: 2, format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder3 = commandEncoder4.beginComputePass();
document.body.append(img0);
try {
globalThis.someLabel = device0.queue.label;
} catch {}
let commandEncoder10 = device0.createCommandEncoder({});
let texture16 = device0.createTexture({
  size: [16, 24, 1],
  mipLevelCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView9 = texture6.createView({mipLevelCount: 1});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true, stencilReadOnly: true});
let externalTexture1 = device0.importExternalTexture({source: videoFrame1});
let promise2 = device0.queue.onSubmittedWorkDone();
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true});
try {
buffer2.unmap();
} catch {}
try {
commandEncoder5.clearBuffer(buffer2, 12, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 0, new Float64Array(5781).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/5776)), 660, 0);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 52, 96);
} catch {}
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt2020', transfer: 'smpte240m'} });
let texture17 = device0.createTexture({
  size: {width: 4, height: 6, depthOrArrayLayers: 58},
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder4 = commandEncoder2.beginComputePass();
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true});
let promise3 = device0.queue.onSubmittedWorkDone();
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let buffer6 = device0.createBuffer({size: 407, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let texture18 = device0.createTexture({
  size: [1560, 96, 29],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true});
try {
renderBundleEncoder5.setIndexBuffer(buffer1, 'uint16', 106, 40);
} catch {}
let buffer7 = device0.createBuffer({size: 56, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder11 = device0.createCommandEncoder({});
try {
  await promise3;
} catch {}
let commandEncoder12 = device0.createCommandEncoder({});
let computePassEncoder5 = commandEncoder6.beginComputePass();
let canvas0 = document.createElement('canvas');
let renderPassEncoder0 = commandEncoder5.beginRenderPass({
  label: '\u70a6\ue607\u4984\u01bf\ud0e2',
  colorAttachments: [{view: textureView9, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 278214320,
});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
buffer1.unmap();
} catch {}
let texture19 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 67},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true});
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 308, 21);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 4, new Float32Array(6584).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.6330)), 1101, 0);
} catch {}
canvas0.height = 1283;
let buffer8 = device0.createBuffer({
  label: '\ua4cc\u0a3a\u{1fbbf}\u6cc3\ue25b\u0aff\u9dcb\u071c',
  size: 56,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let computePassEncoder6 = commandEncoder8.beginComputePass();
let externalTexture2 = device0.importExternalTexture({source: videoFrame1});
try {
renderBundleEncoder5.setIndexBuffer(buffer1, 'uint32', 304, 68);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(5, buffer8, 12);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
let buffer9 = device0.createBuffer({size: 152, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder13 = device0.createCommandEncoder({});
let textureView10 = texture15.createView({format: 'r16sint', mipLevelCount: 1});
try {
renderBundleEncoder5.insertDebugMarker('\u427b');
} catch {}
let buffer10 = device0.createBuffer({size: 256, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView11 = texture9.createView({dimension: '2d-array'});
try {
renderBundleEncoder0.setVertexBuffer(0, buffer9, 0, 58);
} catch {}
document.body.prepend(canvas0);
let textureView12 = texture11.createView({dimension: '2d-array', baseArrayLayer: 0});
let computePassEncoder7 = commandEncoder9.beginComputePass();
try {
buffer5.unmap();
} catch {}
try {
  await promise4;
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 1, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 138,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' },
    },
  ],
});
let commandEncoder14 = device0.createCommandEncoder({});
let textureView13 = texture16.createView({mipLevelCount: 1});
try {
renderBundleEncoder3.setIndexBuffer(buffer9, 'uint32', 8, 21);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer9, 'uint32', 12, 54);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 0, new Float32Array(6918).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.843)), 1294, 12);
} catch {}
try {
  await promise2;
} catch {}
let textureView14 = texture2.createView({dimension: '2d-array'});
let textureView15 = texture17.createView({baseArrayLayer: 16, arrayLayerCount: 1});
try {
renderBundleEncoder8.setIndexBuffer(buffer1, 'uint32', 8, 34);
} catch {}
try {
buffer0.unmap();
} catch {}
let gpuCanvasContext0 = canvas0.getContext('webgpu');
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
globalThis.someLabel = textureView7.label;
} catch {}
let texture20 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture21 = device0.createTexture({
  size: [780],
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 72, 38);
} catch {}
let textureView16 = texture5.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder0.setVertexBuffer(0, buffer5, 80);
} catch {}
let buffer11 = device0.createBuffer({size: 2008, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
try {
renderPassEncoder0.setVertexBuffer(6, buffer9, 0, 2);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer11, 136, new Float32Array(9294).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.8971)), 2827, 64);
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

/* zero global variables used */
fn fn0() {
  let vf0: vec4f = unpack4x8unorm(unconst_u32(173046604));
  if bool(acosh(vec2f(unconst_f32(0.00953), unconst_f32(-0.6875e-3)))[1]) {
  var vf1: u32 = pack2x16unorm(vec2f(unconst_f32(0.08384e15), unconst_f32(0.1264)));
  return;
}
  var vf2: vec4u = unpack4xU8(unconst_u32(2932223629));
}

struct T1 {
  @size(20) f0: vec4u,
  @size(64) f1: array<array<f16, 2>, 8>,
  @size(360) f2: mat2x4f,
}

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

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

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

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

struct VertexInput0 {
  @builtin(instance_index) instance_index: u32,
  @location(7) @interpolate(flat) location_7: f32,
  @location(1) location_1: u32,
  @builtin(vertex_index) vertex_index: u32,
  @location(9) @interpolate(flat, either) location_9: vec4u,
  @location(12) location_12: vec2f,
}

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

struct VertexOutput0 {
  @location(4) location_4: vec2u,
  @location(15) @interpolate(flat, centroid) location_15: vec4u,
  @builtin(position) position: vec4f,
  @location(8) location_8: vec2i,
  @location(14) @interpolate(flat, centroid) location_14: vec4u,
  @location(2) @interpolate(flat, sample) location_2: i32,
  @location(10) @interpolate(linear, sample) location_10: vec2f,
  @location(0) @interpolate(linear) location_0: vec4f,
  @location(6) location_6: vec4h,
  @location(5) @interpolate(flat) location_5: vec2h,
  @location(9) location_9: vec4h,
  @location(11) location_11: f32,
}

struct VertexInput1 {
  @location(8) location_8: f32,
  @location(3) location_3: f32,
}

struct T2 {
  @size(448) f0: vec2h,
  @align(32) f1: array<u32>,
}

@group(1) @binding(26) var st0: texture_storage_3d<rgba8sint, read>;

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

@group(1) @binding(10) var<storage, read> buffer17: array<array<array<array<array<f16, 1>, 1>, 10>, 3>>;

/* used global variables: st0 */
@vertex
fn vertex0(@location(14) @interpolate(perspective) location_14: f16, a1: VertexInput0, a2: VertexInput1, @location(6) @interpolate(flat) location_6: vec2u, @location(0) location_0: vec2u, @location(2) @interpolate(perspective) location_2: f32, @location(4) location_4: vec2f) -> VertexOutput0 {
  var out: VertexOutput0;
  out.location_10 = vec2f(out.location_5.xx);
  out = VertexOutput0(vec2u(a1.vertex_index), vec4u(a1.vertex_index), vec4f(bitcast<f32>(a1.vertex_index)), vec2i(i32(a1.vertex_index)), unpack4xU8(a1.vertex_index), bitcast<i32>(a1.vertex_index), unpack2x16snorm(a1.vertex_index), unpack4x8unorm(a1.vertex_index), vec4h(f16(a1.vertex_index)), bitcast<vec2h>(a1.vertex_index), vec4h(f16(a1.vertex_index)), f32(a1.vertex_index));
  switch bitcast<u32>(out.location_5) { 
  default {
  out.location_15 <<= vec4u(a1.location_1);
  var vf3: VertexInput1 = a2;
}
case 1769379258: {
  let ptr0: ptr<function, vec2h> = &out.location_5;
  fn0();
  out.location_4 = vec2u(a1.location_1);
  fn0();
}
  }
  out.location_5 *= vec2h(vec2h(unconst_f16(-4485.6), unconst_f16(-4569.5)));
  out.location_10 = vec2f((vec3u(unconst_u32(1023506175), unconst_u32(273443277), unconst_u32(161775951)) == vec3u(unconst_u32(370141143), unconst_u32(453008247), unconst_u32(219028505))).rb.yy.xx.xx);
  let vf4: f32 = out.location_10[unconst_u32(2463031477)];
  return out;
  _ = st0;
}

/* used global variables: buffer17 */
@compute @workgroup_size(1, 1, 1)
fn compute0() {
  let ptr1: ptr<storage, f16, read> = &buffer17[arrayLength(&buffer17)][unconst_u32(393825461)][9][0][0];
  _ = buffer17;
}`,
});
let bindGroup0 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 138, resource: textureView7},
    {binding: 1, resource: externalTexture2},
    {binding: 0, resource: externalTexture0},
  ],
});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4});
try {
computePassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470bg', transfer: 'smpte170m'} });
let buffer19 = device0.createBuffer({size: 108, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder15 = device0.createCommandEncoder({});
let textureView17 = texture0.createView({});
try {
computePassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer1, 'uint16', 352, 23);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(6, buffer19, 0, 10);
} catch {}
let buffer20 = device0.createBuffer({size: 232, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let sampler2 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 89.74});
try {
renderBundleEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(2090), 92, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 28, new Float32Array(7694).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.128)), 667, 56);
} catch {}
let buffer21 = device0.createBuffer({
  label: '\u{1fe6b}\u95f7\u{1fd46}\u{1fe8b}\u0b75\u0524\u{1f904}\u07a4\u7123',
  size: 3562,
  usage: GPUBufferUsage.STORAGE,
});
let texture22 = device0.createTexture({
  size: {width: 4, height: 6, depthOrArrayLayers: 1},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView18 = texture1.createView({});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['r16sint']});
try {
renderBundleEncoder0.setIndexBuffer(buffer1, 'uint16', 42, 30);
} catch {}
try {
commandEncoder10.copyTextureToTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 7, y: 19, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 424, y: 30, z: 0},
  aspect: 'all',
},
{width: 2, height: 2, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(27, 147);
let commandEncoder16 = device0.createCommandEncoder();
let computePassEncoder8 = commandEncoder11.beginComputePass();
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, depthReadOnly: true});
try {
computePassEncoder0.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer19, 'uint32', 4, 5);
} catch {}
let sampler3 = device0.createSampler({addressModeU: 'mirror-repeat'});
try {
computePassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(3965), 398, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup0);
} catch {}
try {
commandEncoder13.clearBuffer(buffer10);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer2, 0, new Uint32Array(1696).map((_, i) => i * 5), 1266, 0);
} catch {}
let bindGroup1 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 0, resource: externalTexture0},
    {binding: 1, resource: externalTexture2},
    {binding: 138, resource: textureView13},
  ],
});
try {
computePassEncoder7.setBindGroup(0, bindGroup0, new Uint32Array(1881), 277, 0);
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 138, resource: textureView13},
    {binding: 1, resource: externalTexture1},
    {binding: 0, resource: externalTexture1},
  ],
});
try {
computePassEncoder3.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder6.setBindGroup(2, bindGroup0, new Uint32Array(1381), 79, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 0, 12);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(1, buffer5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(392).fill(116), /* required buffer size: 392 */
{offset: 68, bytesPerRow: 1, rowsPerImage: 54}, {width: 0, height: 0, depthOrArrayLayers: 7});
} catch {}
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpteSt4281', transfer: 'bt709'} });
let textureView19 = texture8.createView({baseMipLevel: 0, mipLevelCount: 1});
let sampler4 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 81.10,
  maxAnisotropy: 18,
});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder16.copyTextureToBuffer({
  texture: texture12,
  mipLevel: 2,
  origin: {x: 24, y: 8, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 54 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 286 */
  offset: 286,
  bytesPerRow: 10240,
  buffer: buffer11,
}, {width: 27, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer22 = device0.createBuffer({
  size: 92,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let sampler5 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.72,
  compare: 'greater-equal',
});
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 12, 60);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer5, 0, 12);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer19, 0, 16);
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires pointer_composite_access;

requires readonly_and_readwrite_storage_textures;

enable f16;

enable f16;

struct VertexInput2 {
  @location(11) location_11: f32,
  @builtin(vertex_index) vertex_index: u32,
  @location(6) location_6: vec4h,
  @location(4) @interpolate(flat) location_4: vec2u,
  @location(3) @interpolate(flat) location_3: vec2u,
  @location(2) @interpolate(perspective, either) location_2: f16,
}

struct FragmentOutput0 {
  @location(0) location_0: vec2i,
  @builtin(sample_mask) sample_mask: u32,
}

struct VertexInput6 {
  @location(9) location_9: vec2h,
  @location(1) @interpolate(flat) location_1: vec2u,
}

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

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

@id(31623) override override1 = false;

struct VertexInput5 {
  @location(15) @interpolate(flat) location_15: vec4u,
}

struct VertexInput3 {
  @location(14) @interpolate(perspective) location_14: f16,
  @location(0) @interpolate(flat, sample) location_0: i32,
}

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

struct VertexInput4 {
  @location(8) @interpolate(perspective) location_8: f16,
  @location(5) location_5: f32,
  @location(7) location_7: i32,
}

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

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

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

struct VertexOutput1 {
  @location(11) @interpolate(flat, first) location_11: vec4f,
  @location(7) @interpolate(perspective, sample) location_7: vec2f,
  @location(1) location_1: vec2i,
  @invariant @builtin(position) position: vec4f,
  @location(3) @interpolate(flat, either) location_3: vec2u,
  @location(8) @interpolate(flat) location_8: vec4u,
  @location(6) location_6: vec2h,
  @location(15) @interpolate(flat, center) location_15: vec4h,
}

struct VertexInput7 {
  @location(13) location_13: vec4i,
}

override override0: i32 = 131935833;

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

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

var<private> vp0: vec4f = vec4f(0.08912e16, 0.1392, 0.4787, 0.06014e-45);

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

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

/* used global variables: et3 */
@vertex
fn vertex1(a0: VertexInput2, a1: VertexInput3, @location(10) @interpolate(flat) location_10: i32, @location(12) @interpolate(linear, center) location_12: vec2h, a4: VertexInput4, a5: VertexInput5, a6: VertexInput6, a7: VertexInput7, @builtin(instance_index) instance_index: u32) -> VertexOutput1 {
  var out: VertexOutput1;
  loop {
  switch i32(out.location_11[unconst_u32(2306066201)]) { 
  case 28606159, default, 719301726 {
  var vf5: bool =  !bool(out.location_6.r);
  loop {
  out.position = vec4f(a6.location_9.xxxx.aabb);
  out.location_11 = vec4f(mix(vec2h(unconst_f16(-1597.5), unconst_f16(8750.8)), vec2h(unconst_f16(1150.9), unconst_f16(12259.7)), vec2h(unconst_f16(4340.7), unconst_f16(9704.3))).grgg.gggg);
  let vf6: bool =  !unconst_bool(true);
  break;
}
  var vf7: f32 = smoothstep(unconst_f32(-0.00808), unconst_f32(0.2830), unconst_f32(0.05238));
  out.location_1 = vec2i(i32(all(vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(false)))));
}
  }
  let vf8: f32 = out.location_7[pack4x8unorm(refract(vec4f(unconst_f32(0.3008), unconst_f32(0.1538), unconst_f32(0.3642e38), unconst_f32(0.1261e1)), vec4f(unconst_f32(0.2007e16), unconst_f32(0.03631e7), unconst_f32(0.01722e-38), unconst_f32(-0.03821)), unconst_f32(0.00961)))];
  var vf9: i32 = override0;
  let ptr2: ptr<function, vec2f> = &out.location_7;
  break;
  _ = override0;
}
  out.location_11 += vec4f(a0.location_6);
  out.location_3 -= vec2u(bitcast<u32>(a4.location_5));
  {
  out.location_11 = vec4f(vec4f(unconst_f32(0.06696), unconst_f32(0.01411e34), unconst_f32(0.3527e8), unconst_f32(0.1740)));
  _ = et3;
}
  return out;
  _ = override0;
  _ = et3;
}

/* used global variables: et3 */
@fragment
fn fragment0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  var vf10: vec2f = unpack2x16unorm(unconst_u32(112792187));
  let ptr3: ptr<function, vec2f> = &vf10;
  vf10 -= vec2f(step(vec2h(unconst_f16(7356.2), unconst_f16(-7230.6)), vec2h(unconst_f16(-12137.7), unconst_f16(1089.6))));
  let ptr4: ptr<function, u32> = &out.sample_mask;
  let ptr5: ptr<function, vec2i> = &out.location_0;
  var vf11: vec2i = select(vec2i(unconst_i32(243887591), unconst_i32(-42649991)), vec2i(unconst_i32(211267511), unconst_i32(37075320)), vec2<bool>(unconst_bool(false), unconst_bool(false)));
  loop {
  var vf12: vec3h = trunc(vec3h((vec3u(unconst_u32(894803911), unconst_u32(514287009), unconst_u32(34081382)) >= vec3u(unconst_u32(1891560520), unconst_u32(397399290), unconst_u32(1297236704)))));
  out.location_0 -= bitcast<vec2i>(textureDimensions(et3));
  var vf13: f16 = vf12[unconst_u32(1223018598)];
  break;
  _ = et3;
}
  return out;
  _ = et3;
}

/* used global variables: et2 */
@compute @workgroup_size(2, 1, 1)
fn compute1(a0: ComputeInput0, a1: ComputeInput1) {
  vp0 *= vec4f(vec4f(unconst_f32(0.1045), unconst_f32(0.2375e6), unconst_f32(0.09954e38), unconst_f32(0.2263)));
  vp0 = vec4f(insertBits(vec2u(unpack4x8unorm(unconst_u32(785751675)).yz.rg), vec2u(unconst_u32(177140341), unconst_u32(3925648177)), unconst_u32(1938095415), unconst_u32(759749759)).gggr.rgbg);
  var vf14: bool = override1;
  vp0 = vec4f(vp0[vec3u(cross(vec3f(unconst_f32(0.08826e31), unconst_f32(0.03036), unconst_f32(0.1300e-22)), vec3f(unconst_f32(0.02982e-31), unconst_f32(0.3194), unconst_f32(0.03868))))[0]]);
  _ = et2;
  vp0 += normalize(vec3f(unconst_f32(0.4261), unconst_f32(-0.00576), unconst_f32(0.1968e-3))).yzyy;
  _ = override1;
  _ = et2;
}`,
});
try {
buffer2.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let textureView20 = texture5.createView({format: 'r32sint'});
let texture23 = device0.createTexture({
  size: {width: 195, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView21 = texture1.createView({mipLevelCount: 1});
try {
renderPassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(1985), 67, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(132540)), 4492, 0);
} catch {}
let pipeline0 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}});
let gpuCanvasContext1 = offscreenCanvas0.getContext('webgpu');
let imageData0 = new ImageData(124, 16);
let texture24 = device0.createTexture({
  size: [8, 12, 2],
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView22 = texture3.createView({format: 'rg32sint', baseArrayLayer: 1, arrayLayerCount: 2});
try {
renderPassEncoder0.setVertexBuffer(2, buffer9, 0, 46);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer19, 'uint32', 8, 30);
} catch {}
let imageBitmap0 = await createImageBitmap(videoFrame0);
let commandEncoder17 = device0.createCommandEncoder({});
let textureView23 = texture20.createView({dimension: '2d-array'});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
renderPassEncoder0.setVertexBuffer(4, buffer5, 0, 0);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup2, new Uint32Array(10000), 511, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  toneMapping: {mode: 'extended'},
});
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires pointer_composite_access;

enable f16;

struct VertexInput9 {
  @location(6) location_6: vec4h,
  @location(2) location_2: u32,
}

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

@group(0) @binding(58) var<storage, read_write> buffer25: array<array<f16, 96>, 3>;

struct T3 {
  @align(16) f0: array<f32>,
}

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

struct T0 {
  @size(104) f0: array<vec4<bool>, 1>,
}

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

/* used global variables: buffer23 */
@must_use 
fn fn5(a0: ptr<function, vec4i>) -> f16 {
  var out: f16;
  _ = fn0(array<vec2f, 1>(vec2f((vec2f(unconst_f32(0.07805), unconst_f32(0.05857e10)) == vec2f(unconst_f32(0.1374e30), unconst_f32(0.03705))))));
  buffer23.f0[unconst_u32(269043619)] = sqrt(vec2f(unconst_f32(-0.1175e-7), unconst_f32(0.01389)))[1];
  return out;
  _ = buffer23;
}

/* used global variables: buffer24 */
fn fn4(a0: vec4i) {
  var vf24: vec3u = extractBits(vec3u(unconst_u32(786886861), unconst_u32(475171122), unconst_u32(650024904)), unconst_u32(76043755), unconst_u32(477007050));
  vf24 -= vec3u(u32(distance(vec3h(unconst_f16(15351.6), unconst_f16(25980.2), unconst_f16(3272.2)), vec3h(unconst_f16(2279.0), unconst_f16(12575.7), unconst_f16(2497.1)))));
  vf24 <<= vec3u(bitcast<u32>(a0[unconst_u32(519162206)]));
  _ = fn0(array<vec2f, 1>(vec2f(vp1[0].fract)));
  vp1[unconst_u32(1100594457)].fract -= vec4f((*&buffer24)).x;
  let vf25: vec4i = a0;
  vp1[unconst_u32(2099673272)] = modf(f32((*&buffer24)[unconst_u32(408836050)]));
  vf24 = bitcast<vec3u>(a0.rbr);
  for (var it0=pack4xU8((vec4u(unconst_u32(605176588), unconst_u32(2969884591), unconst_u32(659822346), unconst_u32(584850938)) << vec4u(unconst_u32(384454762), unconst_u32(17341885), unconst_u32(911843904), unconst_u32(1260761482)))); it0<(bitcast<u32>(vp1[0].whole) & 0xfff); it0++) {
  let ptr8 = &vp1[0];
  var vf26 = fn0(array<vec2f, 1>(acosh(vec3f(unconst_f32(0.1781e21), unconst_f32(0.1840), unconst_f32(-0.4401e-44))).xz));
  return;
}
  vp1[unconst_u32(114674974)] = modf(bitcast<vec4f>(a0.rgag.yxwz)[0]);
  switch bitcast<u32>(vp1[unconst_u32(475360472)].fract) { 
  case default: {
  vp1[unconst_u32(109879857)].whole = vp1[0].fract;
  vp1[0].whole = vp1[unconst_u32(140978453)].whole;
  vp1[0] = modf(f32((*&buffer24).g));
  _ = buffer24;
}
case 308324724, 285053377: {
  _ = fn0(array<vec2f, 1>(vec2f(vp1[0].fract)));
}
  }
  let vf27: u32 = vf24[unconst_u32(269977601)];
  _ = buffer24;
}

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

/* used global variables: buffer24, buffer25 */
fn fn3() -> vec4h {
  var out: vec4h;
  var vf19 = fn1(&vw0);
  let vf20: bool = (unconst_u32(445472895) == unconst_u32(283079596));
  atomicCompareExchangeWeak(&vw2, unconst_u32(799212354), unconst_u32(1038856112));
  loop {
  var vf21: u32 = atomicLoad(&(*&vw2));
  let vf22: u32 = extractBits(unconst_u32(363815926), unconst_u32(264073390), unconst_u32(229757419));
  break;
}
  var vf23: u32 = pack4xI8(vec4i(unconst_i32(787156152), unconst_i32(201593546), unconst_i32(324172652), unconst_i32(1190675155)));
  buffer25[unconst_u32(121285257)][unconst_u32(454559093)] = (*&buffer24)[3];
  return out;
  _ = buffer24;
  _ = buffer25;
}

/* zero global variables used */
fn fn2() {
  vp1[unconst_u32(1338560693)].fract = f32(all(unconst_bool(true)));
  var vf16: vec4f = unpack4x8snorm(bitcast<u32>(unpack4xI8(bitcast<u32>(asinh(vec3f(unconst_f32(0.1943), unconst_f32(0.1307e-39), unconst_f32(0.1608e-21)))[2]))[1]));
  vf16 = vec4f(vp1[unconst_u32(539575389)].whole);
  let vf17: vec2f = step(vec2f(unconst_f32(0.2272), unconst_f32(0.07497)), vec2f(cosh(vec3h(unconst_f16(7157.2), unconst_f16(4093.8), unconst_f16(27726.1))).gg.rg.xy));
  var vf18: vec4i = unpack4xI8(u32(all(unconst_bool(false))));
}

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

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

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

alias vec3b = vec3<bool>;

/* zero global variables used */
fn fn1(a0: ptr<workgroup, vec2f>) -> mat3x2h {
  var out: mat3x2h;
  let ptr6: ptr<workgroup, vec2f> = &(*a0);
  fn0(array<vec2f, 1>(vec2f(f32(out[unconst_u32(551166073)][unconst_u32(2765009761)]))));
  let ptr7 = &vp1[unconst_u32(327975518)];
  return out;
}

@group(0) @binding(6) var<storage, read_write> buffer23: T3;

struct T4 {
  f0: array<array<vec4<bool>, 1>>,
}

/* zero global variables used */
fn fn0(a0: array<vec2f, 1>) -> array<array<vec2h, 14>, 2> {
  var out: array<array<vec2h, 14>, 2>;
  vp1[unconst_u32(2338802874)].fract *= bitcast<vec4f>(unpack4xI8(u32(out[1][13][unconst_u32(109582376)]))).z;
  out[bitcast<u32>(out[1][13])][13] *= out[unconst_u32(1685425947)][13];
  for (var jj47=0u; jj47<4; jj47++) { out[jj47][unconst_u32(1455711834)] += vec2h(log(vec4f(unconst_f32(0.1553e27), unconst_f32(0.02242), unconst_f32(0.1680e14), unconst_f32(0.3848e-44))).rr.rg.gg.gg.rr.rg.yy.yx); }
  let vf15: bool = all(unconst_bool(true));
  out[unconst_u32(1101547075)][unconst_u32(168691885)] *= vec2h(out[1][13][unconst_u32(774795374)]);
  return out;
}

var<workgroup> vw2: atomic<u32>;

struct VertexInput8 {
  @builtin(instance_index) instance_index: u32,
}

struct T2 {
  @size(64) f0: atomic<u32>,
  @align(32) @size(1248) f1: array<array<vec4u, 1>, 1>,
}

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

var<private> vp1 = array(modf(f32(0.3933e35)));

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

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

@group(0) @binding(43) var<uniform> buffer24: vec4h;

struct T5 {
  @align(64) @size(64) f0: atomic<i32>,
  @size(64) f1: array<array<array<array<atomic<u32>, 1>, 1>, 1>, 8>,
  @align(64) @size(384) f2: atomic<i32>,
  @align(32) f3: array<vec2<bool>>,
}

var<workgroup> vw0: vec2f;

/* used global variables: buffer24 */
@vertex
fn vertex2(@location(14) @interpolate(flat) location_14: vec4u, a1: VertexInput8, a2: VertexInput9) -> @builtin(position) vec4f {
  var out: vec4f;
  out = vec4f(faceForward(vec4h(unconst_f16(-20427.7), unconst_f16(4960.5), unconst_f16(1691.6), unconst_f16(3879.9)), vec4h(unconst_f16(9122.6), unconst_f16(5469.0), unconst_f16(-15225.5), unconst_f16(9752.4)), vec4h(unconst_f16(1180.1), unconst_f16(1175.4), unconst_f16(5941.8), unconst_f16(1361.0))));
  out = step(vec2f(unconst_f32(-0.1712), unconst_f32(0.3079e25)), vec2f(unconst_f32(0.00025e-5), unconst_f32(0.07531))).grrr;
  out += vec4f(f32(a2.location_6[unconst_u32(1866651959)]));
  vp1[unconst_u32(677603408)].fract = vp1[unconst_u32(252887443)].fract;
  out *= vec4f(f32((unconst_u32(30334843) >= unconst_u32(69906681))));
  let vf28: vec2i = (vec2i(unconst_i32(62308173), unconst_i32(617995507)) ^ vec2i(unconst_i32(410991003), unconst_i32(1655438637)));
  out *= vec4f((vec4i(unconst_i32(19850344), unconst_i32(-3061137), unconst_i32(191914748), unconst_i32(350943925)) < vec4i(unconst_i32(181195626), unconst_i32(702399807), unconst_i32(-204100208), unconst_i32(357461099))).rgbg);
  let ptr9 = &vp1[0];
  fn4(vec4i(i32(dot(vec2h(unconst_f16(38779.5), unconst_f16(-77.42)), vec2h(unconst_f16(2412.1), unconst_f16(-2271.8))))));
  return out;
  _ = buffer24;
}

/* used global variables: buffer23 */
@fragment
fn fragment1() -> @location(200) @interpolate(linear) i32 {
  var out: i32;
  buffer23.f0[bitcast<u32>(ceil(vec2h(unconst_f16(16553.2), unconst_f16(11132.0))))] = vec4f(round(vec4h(unconst_f16(5439.9), unconst_f16(21892.9), unconst_f16(-4122.5), unconst_f16(28794.1))).agag.xwwz.bbgg.yyzw)[0];
  return out;
  _ = buffer23;
}

/* used global variables: buffer23, buffer24, buffer25 */
@compute @workgroup_size(1, 1, 2)
fn compute2(a0: ComputeInput2, a1: ComputeInput3, a2: ComputeInput4) {
  var vf29: vec3u = a0.global_invocation_id;
  fn4(bitcast<vec4i>(a1.num_workgroups.ggrb));
  buffer23 = (*&buffer23);
  fn4(unpack4xI8(atomicLoad(&(*&vw1)[unconst_u32(338511088)])));
  for (var it1=bitcast<u32>(vp1[0].whole); it1<(bitcast<u32>(countTrailingZeros(vec3i(unconst_i32(66222964), unconst_i32(268121467), unconst_i32(1276884672))).b) & 0xfff); it1++) {
  vp1[unconst_u32(39587558)].fract = f32((*&buffer25)[unconst_u32(572610426)][95]);
  _ = fn1(&vw0);
  _ = buffer25;
}
  let ptr10: ptr<workgroup, array<atomic<u32>, 1>> = &vw1;
  buffer25[unconst_u32(427693920)][unconst_u32(414501584)] = f16(a0.global_invocation_id.b);
  fn4(unpack4xI8(atomicLoad(&(*ptr10)[0])));
  vf29 = vec3u(u32(buffer23.f0[arrayLength(&buffer23.f0)]));
  _ = buffer25;
  _ = buffer23;
  _ = buffer24;
}`,
});
let textureView24 = texture24.createView({});
let textureView25 = texture21.createView({baseMipLevel: 0});
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer19);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer1, 'uint16', 12, 104);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 100, new DataView(new Uint8Array(12405).map((_, i) => i).buffer), 1199, 412);
} catch {}
let commandEncoder18 = device0.createCommandEncoder({});
let textureView26 = texture10.createView({format: 'r32sint'});
let sampler6 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.02,
});
try {
computePassEncoder6.setBindGroup(0, bindGroup2, new Uint32Array(255), 3, 0);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(85), 35, 0);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 140, 3);
} catch {}
try {
  await buffer10.mapAsync(GPUMapMode.READ);
} catch {}
try {
commandEncoder15.copyTextureToBuffer({
  texture: texture18,
  mipLevel: 0,
  origin: {x: 474, y: 5, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 136 widthInBlocks: 68 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 192 */
  offset: 192,
  bytesPerRow: 2048,
  rowsPerImage: 262,
  buffer: buffer11,
}, {width: 68, height: 34, depthOrArrayLayers: 0});
} catch {}
let texture25 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 259},
  mipLevelCount: 5,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView27 = texture0.createView({aspect: 'stencil-only'});
try {
renderPassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer1, 'uint32', 68, 106);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(43).fill(190), /* required buffer size: 43 */
{offset: 43, bytesPerRow: 42}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let texture26 = device0.createTexture({
  size: [390],
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView28 = texture16.createView({dimension: '2d-array', format: 'r32uint'});
try {
computePassEncoder1.setBindGroup(2, bindGroup1);
} catch {}
try {
buffer2.unmap();
} catch {}
let img1 = await imageWithData(21, 53, '#10101010', '#20202020');
let commandEncoder19 = device0.createCommandEncoder();
let texture27 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 598},
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint32', 68, 177);
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
enable f16;

enable f16;

requires packed_4x8_integer_dot_product;

struct VertexInput10 {
  @location(1) @interpolate(linear) location_1: vec2f,
  @location(4) location_4: vec4i,
  @builtin(vertex_index) vertex_index: u32,
  @location(9) location_9: f16,
}

struct T7 {
  @size(24) f0: vec2<bool>,
}

struct VertexInput15 {
  @builtin(instance_index) instance_index: u32,
}

struct T11 {
  @size(3392) f0: T0,
  @align(16) f1: array<array<T7, 1>>,
}

struct T13 {
  f0: array<u32>,
}

struct T16 {
  f0: array<u32>,
}

alias vec3b = vec3<bool>;

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

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

@group(0) @binding(6) var<storage, read_write> buffer26: T15;

struct VertexInput11 {
  @location(0) location_0: vec4f,
  @location(3) location_3: u32,
  @location(14) @interpolate(flat) location_14: vec2i,
}

struct T10 {
  @align(128) @size(1024) f0: T7,
  @size(384) f1: i32,
}

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

struct T3 {
  @size(60) f0: atomic<i32>,
}

@id(62227) override override2: i32 = 598790124;

@group(1) @binding(10) var<storage, read> buffer30: array<array<array<array<f16, 3>, 2>, 5>>;

struct T6 {
  f0: array<u32>,
}

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

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

var<workgroup> vw4: array<vec4i, 1>;

struct T2 {
  @align(64) @size(192) f0: T1,
  @size(192) f1: atomic<i32>,
  f2: array<u32>,
}

struct VertexInput14 {
  @location(10) location_10: f32,
}

var<private> vp2: array<array<array<vec2<bool>, 1>, 31>, 1> = array(array(array(vec2<bool>(true, true)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(), array(vec2<bool>(false, false)), array(vec2<bool>(false, true)), array(vec2<bool>(true, true)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(), array(vec2<bool>(true, true)), array(vec2<bool>(true, true)), array(vec2<bool>(true, true)), array(vec2<bool>(false, true)), array(vec2<bool>(false, false)), array(vec2<bool>(true, false)), array(vec2<bool>(true, false)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(), array(vec2<bool>(false, false)), array<vec2<bool>, 1>(vec2<bool>(true, true)), array(vec2<bool>(true, false)), array(vec2<bool>(false, true)), array(vec2<bool>(false, true)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(), array(vec2<bool>(false, false)), array(vec2<bool>(false, false)), array<vec2<bool>, 1>(), array(vec2<bool>(false, false)), array(vec2<bool>(false, true)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(vec2<bool>(true, false))));

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

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

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

struct T4 {
  @size(2048) f0: T1,
}

@group(1) @binding(3) var<storage, read_write> buffer29: array<array<array<vec2h, 103>, 16>>;

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

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

struct VertexInput13 {
  @location(8) location_8: f32,
  @location(6) @interpolate(linear) location_6: f16,
  @location(2) location_2: f32,
  @location(15) @interpolate(flat) location_15: vec4u,
}

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

struct FragmentInput0 {
  @location(11) @interpolate(flat, first) location_11: vec4f,
}

struct VertexInput12 {
  @location(11) location_11: vec2f,
  @location(12) location_12: i32,
  @location(5) @interpolate(flat, centroid) location_5: vec4h,
}

struct T17 {
  f0: array<T9>,
}

struct T0 {
  @size(64) f0: vec4u,
  @align(32) @size(896) f1: array<array<array<f16, 1>, 1>, 1>,
}

struct T14 {
  f0: array<T7>,
}

struct FragmentInput1 {
  @location(8) @interpolate(flat) location_8: vec4u,
}

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

@group(1) @binding(115) var st4: texture_storage_2d_array<r32sint, write>;

struct T1 {
  @size(8) f0: i32,
  f1: array<array<array<vec4f, 1>, 1>, 1>,
  @align(8) @size(80) f2: f32,
}

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

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

/* used global variables: tex2 */
@vertex @must_use
fn vertex3(a0: VertexInput10, a1: VertexInput11, @location(7) @interpolate(perspective, first) location_7: vec2h, @location(13) @interpolate(flat) location_13: vec4f, a4: VertexInput12, a5: VertexInput13, a6: VertexInput14, a7: VertexInput15) -> VertexOutput2 {
  var out: VertexOutput2;
  out.position += vec4f(textureDimensions(tex2, unconst_i32(234711125)).rgrr.bgga.aggg.ywww.wxxw);
  let ptr11: ptr<private, array<vec2<bool>, 1>> = &vp2[0][30];
  out.position = vec4f(a4.location_5.arrb);
  vp2[unconst_u32(3557110492)][unconst_u32(533295629)][unconst_u32(864028017)] = vec2<bool>(textureDimensions(tex2, unconst_i32(393809949)));
  let ptr12: ptr<private, array<array<vec2<bool>, 1>, 31>> = &vp2[u32(out.position[0])];
  out.position += bitcast<vec4f>(a1.location_14.xyxx);
  return out;
  _ = tex2;
}

/* used global variables: buffer26, buffer29, st4 */
@fragment
fn fragment2(a0: FragmentInput0, a1: FragmentInput1) -> FragmentOutput1 {
  var out: FragmentOutput1;
  let ptr13: ptr<private, array<vec2<bool>, 1>> = &vp2[0][30];
  let ptr14: ptr<private, vec2<bool>> = &vp2[0][unconst_u32(707809916)][unconst_u32(544944171)];
  var vf30: f32 = sin(unconst_f32(-0.5712e-9));
  textureStore(st4, vec2i(unconst_i32(30744571), unconst_i32(291866583)), unconst_i32(672367542), vec4i(vec4i(unconst_i32(1260663248), unconst_i32(44205430), unconst_i32(420807019), unconst_i32(343810135))));
  vf30 -= f32(all(vec2<bool>(bool(pack4xI8(vec4i(unconst_i32(1364154396), unconst_i32(-28852579), unconst_i32(93426194), unconst_i32(50099796)))))));
  let ptr15: ptr<private, array<vec2<bool>, 1>> = &vp2[0][30];
  for (var jj9=0u; jj9<18; jj9++) { buffer29[unconst_u32(469293485)][jj9][unconst_u32(1126825927)] = bitcast<vec2h>(distance(vec2f(unconst_f32(0.03563), unconst_f32(-0.03330)), vec2f(vp2[0][unconst_u32(907219202)][unconst_u32(1381551462)]))); }
  let vf31: u32 = a1.location_8[unconst_u32(1476334231)];
  out.location_0 = vec4i((*&buffer29)[unconst_u32(751619127)][15][102].xyyx);
  switch bitcast<i32>((*&buffer29)[unconst_u32(571276440)][unconst_u32(4294967295)][102]) { 
  case default {
  discard;
  let ptr16: ptr<storage, T15, read_write> = &buffer26;
  _ = buffer26;
}
  }
  return out;
  _ = buffer26;
  _ = buffer29;
  _ = st4;
}

/* used global variables: buffer30 */
@compute @workgroup_size(1, 1, 1)
fn compute3() {
  let ptr17: ptr<storage, f16, read> = &buffer30[unconst_u32(312551323)][4][unconst_u32(32212616)][2];
  _ = buffer30;
}`,
});
let buffer32 = device0.createBuffer({size: 120, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, mappedAtCreation: false});
let texture28 = device0.createTexture({
  size: [390, 24, 1],
  format: 'astc-6x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture29 = device0.createTexture({
  size: [195, 120, 25],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler7 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.83,
  maxAnisotropy: 6,
});
try {
renderPassEncoder0.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
document.body.prepend(img1);
try {
adapter0.label = '\ud5b9\u6027\u0254';
} catch {}
let buffer33 = device0.createBuffer({size: 320, usage: GPUBufferUsage.INDIRECT});
let commandEncoder20 = device0.createCommandEncoder({});
let texture30 = device0.createTexture({
  size: {width: 8, height: 5, depthOrArrayLayers: 1},
  format: 'astc-8x5-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView29 = texture2.createView({mipLevelCount: 1});
let computePassEncoder9 = commandEncoder13.beginComputePass();
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
buffer2.unmap();
} catch {}
let bindGroup3 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 58, resource: {buffer: buffer21, size: 580}},
    {binding: 6, resource: {buffer: buffer22}},
    {binding: 43, resource: {buffer: buffer4}},
    {binding: 3, resource: textureView3},
  ],
});
let textureView30 = texture27.createView({dimension: '3d', aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup3, [0]);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup2, new Uint32Array(626), 61, 0);
} catch {}
try {
buffer19.unmap();
} catch {}
try {
renderBundleEncoder9.pushDebugGroup('\uf6ee');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'premultiplied',
});
} catch {}
document.body.prepend(img1);
try {
adapter0.label = '\u5c9d\u876a\u96ac\u2bea\u0bff\u{1fc9c}\u{1f911}\uc270\u03cf\u{1f713}';
} catch {}
let texture31 = device0.createTexture({
  size: [195, 12, 270],
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder6.setBindGroup(1, bindGroup2, new Uint32Array(653), 148, 0);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(528), 128, 0);
} catch {}
let bindGroup4 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 3, resource: textureView17},
    {binding: 43, resource: {buffer: buffer4}},
    {binding: 58, resource: {buffer: buffer21, size: 748}},
    {binding: 6, resource: {buffer: buffer5}},
  ],
});
let texture32 = device0.createTexture({
  size: [195],
  dimension: '1d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
let pipeline1 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rg8sint'}]},
  vertex: {
    module: shaderModule3,
    constants: {},
    buffers: [
      {
        arrayStride: 76,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 0, shaderLocation: 1},
          {format: 'uint32x2', offset: 12, shaderLocation: 3},
          {format: 'sint32', offset: 8, shaderLocation: 12},
          {format: 'snorm16x4', offset: 4, shaderLocation: 13},
          {format: 'snorm16x2', offset: 0, shaderLocation: 7},
          {format: 'sint32x3', offset: 0, shaderLocation: 14},
          {format: 'uint16x2', offset: 0, shaderLocation: 15},
          {format: 'float16x2', offset: 4, shaderLocation: 9},
          {format: 'float32x3', offset: 20, shaderLocation: 0},
          {format: 'float32x2', offset: 44, shaderLocation: 2},
          {format: 'sint32x3', offset: 12, shaderLocation: 4},
          {format: 'snorm8x4', offset: 44, shaderLocation: 8},
          {format: 'snorm16x4', offset: 32, shaderLocation: 5},
          {format: 'snorm16x4', offset: 32, shaderLocation: 10},
          {format: 'float32x3', offset: 0, shaderLocation: 6},
          {format: 'unorm16x2', offset: 48, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'back'},
});
let buffer34 = device0.createBuffer({
  size: 460,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let texture33 = device0.createTexture({
  size: {width: 780},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let bindGroup5 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 3, resource: textureView0},
    {binding: 58, resource: {buffer: buffer21, size: 664}},
    {binding: 6, resource: {buffer: buffer21, size: 264}},
    {binding: 43, resource: {buffer: buffer4}},
  ],
});
let commandEncoder21 = device0.createCommandEncoder();
let textureView31 = texture32.createView({format: 'rgba8snorm'});
let renderPassEncoder1 = commandEncoder19.beginRenderPass({colorAttachments: [{view: textureView9, loadOp: 'clear', storeOp: 'store'}], maxDrawCount: 280944085});
try {
computePassEncoder3.setBindGroup(0, bindGroup4, [0]);
} catch {}
try {
computePassEncoder4.setBindGroup(2, bindGroup3, new Uint32Array(1263), 364, 1);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(1, bindGroup2, new Uint32Array(346), 16, 0);
} catch {}
try {
commandEncoder21.copyBufferToBuffer(buffer0, 104, buffer2, 0, 0);
} catch {}
let textureView32 = texture30.createView({});
let textureView33 = texture6.createView({dimension: '2d', mipLevelCount: 1});
try {
computePassEncoder7.setBindGroup(1, bindGroup2);
} catch {}
try {
computePassEncoder8.setBindGroup(3, bindGroup1, new Uint32Array(103), 9, 0);
} catch {}
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 408, new DataView(new Uint8Array(10256).map((_, i) => i).buffer), 178, 116);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder22 = device0.createCommandEncoder({});
let textureView34 = texture31.createView({});
let textureView35 = texture4.createView({baseMipLevel: 0, baseArrayLayer: 0});
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
commandEncoder9.label = '\u7012\u{1fe8f}\u7fd4\u11b1\u027e\u02dc\uf317';
} catch {}
let bindGroup6 = device0.createBindGroup({
  label: '\u{1f7f2}\ue922\u0cf5',
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 43, resource: {buffer: buffer4}},
    {binding: 58, resource: {buffer: buffer21, size: 616}},
    {binding: 6, resource: {buffer: buffer5}},
    {binding: 3, resource: textureView3},
  ],
});
let textureView36 = texture26.createView({format: 'r32uint'});
let renderPassEncoder2 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView33,
  clearValue: { r: -754.3, g: -398.8, b: 929.4, a: 730.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let externalTexture3 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder0.setBindGroup(2, bindGroup6, new Uint32Array(1839), 278, 1);
} catch {}
try {
computePassEncoder4.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 56, y: 6, z: 0},
  aspect: 'all',
}, new Uint8Array(269).fill(148), /* required buffer size: 269 */
{offset: 269, bytesPerRow: 73}, {width: 3, height: 18, depthOrArrayLayers: 0});
} catch {}
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 58, resource: {buffer: buffer21, size: 684}},
    {binding: 6, resource: {buffer: buffer21, size: 80}},
    {binding: 3, resource: textureView17},
    {binding: 43, resource: {buffer: buffer4, offset: 0}},
  ],
});
let buffer35 = device0.createBuffer({
  size: 108,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder23 = device0.createCommandEncoder({});
let texture34 = device0.createTexture({
  size: [780],
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.setBindGroup(0, bindGroup6, new Uint32Array(1571), 24, 1);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup6, [0]);
} catch {}
try {
renderBundleEncoder13.insertDebugMarker('\uc626');
} catch {}
try {
device0.queue.writeBuffer(buffer34, 12, new DataView(new ArrayBuffer(9248)), 80, 12);
} catch {}
let textureView37 = texture34.createView({});
let texture35 = device0.createTexture({size: [4], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let externalTexture4 = device0.importExternalTexture({source: videoFrame3});
try {
renderBundleEncoder11.setIndexBuffer(buffer19, 'uint32', 16, 13);
} catch {}
try {
buffer19.unmap();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt709', transfer: 'gamma22curve'} });
let buffer36 = device0.createBuffer({size: 64, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder24 = device0.createCommandEncoder({});
let renderPassEncoder3 = commandEncoder17.beginRenderPass({colorAttachments: [{view: textureView33, loadOp: 'load', storeOp: 'discard'}]});
let sampler8 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 86.88});
try {
computePassEncoder4.setBindGroup(3, bindGroup7, [0]);
} catch {}
try {
  await buffer7.mapAsync(GPUMapMode.READ, 24, 0);
} catch {}
document.body.append(img1);
let buffer37 = device0.createBuffer({size: 992, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder3.setIndexBuffer(buffer9, 'uint16', 22, 106);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup3, new Uint32Array(1117), 165, 1);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(6, buffer19);
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
try {
computePassEncoder7.setBindGroup(0, bindGroup7, [0]);
} catch {}
try {
renderBundleEncoder2.setBindGroup(3, bindGroup1);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(7, buffer8);
} catch {}
let imageData1 = new ImageData(24, 12);
let buffer38 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let texture36 = device0.createTexture({
  size: {width: 780, height: 480, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder10 = commandEncoder20.beginComputePass();
let externalTexture5 = device0.importExternalTexture({source: videoFrame3});
try {
renderPassEncoder3.setBindGroup(1, bindGroup5, [0]);
} catch {}
try {
renderBundleEncoder11.setBindGroup(2, bindGroup7, [0]);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(7, buffer19);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture37 = device0.createTexture({size: [195, 120, 1], mipLevelCount: 2, format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView38 = texture36.createView({});
let sampler9 = device0.createSampler({
  label: '\u1c7a\u94ee\ucdb1\u81a1',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 11,
});
try {
renderPassEncoder2.setIndexBuffer(buffer1, 'uint16', 76, 235);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(5, buffer35, 48);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(5, buffer35, 8);
} catch {}
try {
commandEncoder23.copyTextureToBuffer({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 60, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 208 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 448 */
  offset: 448,
  bytesPerRow: 14848,
  buffer: buffer34,
}, {width: 78, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer39 = device0.createBuffer({size: 396, usage: GPUBufferUsage.INDIRECT});
try {
renderBundleEncoder9.popDebugGroup();
} catch {}
try {
  await promise5;
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

enable f16;

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

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

struct VertexInput16 {
  @builtin(instance_index) instance_index: u32,
  @location(15) @interpolate(flat, first) location_15: vec2i,
  @location(14) location_14: vec4u,
}

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

/* zero global variables used */
fn fn0() {
  let vf32: vec3f = log(bitcast<vec3f>((vec4i(unconst_i32(-177637222), unconst_i32(-398695416), unconst_i32(-313458305), unconst_i32(-342832739)) ^ vec4i(unconst_i32(70661769), unconst_i32(1405300125), unconst_i32(163288280), unconst_i32(99644762))).yzw));
  var vf33: vec4i = sign(sign(vec4i(unconst_i32(19400813), unconst_i32(149548355), unconst_i32(285166500), unconst_i32(365878168))));
  let vf34: f32 = vf32[unconst_u32(617162656)];
  var vf35: vec4i = unpack4xI8(unconst_u32(1187123770));
  let vf36: i32 = vp3[u32(ldexp(unconst_f16(762.9), unconst_i32(633976614)))];
  vf35 = vec4i(vf36);
  vf33 = vec4i(sin(log(vec2h(unconst_f16(-752.7), unconst_f16(16650.4)))).yxxy);
  var vf37: vec3f = vf32;
  var vf38: vec4i = (vf33 ^ vec4i(unconst_i32(402547905), unconst_i32(154428099), unconst_i32(484810277), unconst_i32(-211179582)));
  let vf39: bool = any(vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false), unconst_bool(true)));
  return;
}

struct VertexInput21 {
  @location(0) location_0: vec4u,
}

struct VertexInput19 {
  @location(7) @interpolate(perspective, first) location_7: vec4h,
}

struct T4 {
  f0: array<array<array<array<array<vec4f, 1>, 1>, 1>, 1>, 1>,
}

struct T6 {
  f0: array<T4, 1>,
}

@group(0) @binding(3) var tex3: texture_depth_2d;

struct VertexOutput3 {
  @location(7) @interpolate(flat, sample) location_7: vec2f,
  @location(3) @interpolate(linear, sample) location_3: vec2f,
  @location(5) @interpolate(flat, sample) location_5: u32,
  @location(10) @interpolate(flat, first) location_10: vec4i,
  @location(1) location_1: vec4h,
  @builtin(position) position: vec4f,
}

struct T0 {
  @size(8) f0: u32,
  @size(96) f1: vec4i,
}

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

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

@group(0) @binding(6) var<storage, read_write> buffer40: T7;

struct FragmentInput2 {
  @location(6) location_6: vec2h,
}

var<private> vp3: vec4i = vec4i(509626037, 318795331, 473697557, 452286346);

struct VertexInput17 {
  @location(12) location_12: vec4i,
}

struct VertexInput20 {
  @location(2) location_2: f16,
  @builtin(vertex_index) vertex_index: u32,
  @location(10) @interpolate(perspective, centroid) location_10: vec2f,
  @location(11) location_11: vec4f,
  @location(5) location_5: i32,
}

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

struct VertexInput18 {
  @location(8) @interpolate(flat, center) location_8: vec4i,
  @location(4) location_4: u32,
  @location(13) @interpolate(perspective, centroid) location_13: f16,
  @location(9) @interpolate(flat, center) location_9: vec4i,
}

struct T7 {
  f0: array<T4>,
}

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

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

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

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

/* used global variables: tex3 */
@vertex
fn vertex4(@location(6) @interpolate(flat, sample) location_6: vec2i, a1: VertexInput16, a2: VertexInput17, a3: VertexInput18, a4: VertexInput19, @location(1) location_1: vec4u, a6: VertexInput20, a7: VertexInput21, @location(3) location_3: vec4h) -> VertexOutput3 {
  var out: VertexOutput3;
  fn0();
  let vf40: i32 = a3.location_9[unconst_u32(510904130)];
  var vf41: vec2i = a1.location_15;
  out.position -= vec4f(textureDimensions(tex3, a1.location_15.x).xyyy);
  vp3 = bitcast<vec4i>(out.location_3.grgr.wxxy);
  fn0();
  let vf42: vec4h = mix(vec4h(unconst_f16(5717.2), unconst_f16(14605.7), unconst_f16(47375.1), unconst_f16(-173.3)), bitcast<vec4h>(a1.location_15), unconst_f16(-995.4));
  out.position += a6.location_11;
  fn0();
  vf41 &= bitcast<vec2i>(log2(vec4h(unconst_f16(33637.0), unconst_f16(10557.5), unconst_f16(16811.2), unconst_f16(10619.5))));
  fn0();
  var vf43: i32 = a3.location_9[unconst_u32(1535792043)];
  return out;
  _ = tex3;
}

/* used global variables: buffer40 */
@fragment
fn fragment3(@location(7) @interpolate(flat) location_7: vec2f, a1: FragmentInput2, @location(1) @interpolate(flat, center) location_1: vec2i) -> @location(200) @interpolate(flat, sample) vec4i {
  var out: vec4i;
  fn0();
  var vf44: vec2f = (vec2f(unconst_f32(0.00403), unconst_f32(0.1200)) - unconst_f32(-0.1891e36));
  vf44 = unpack4x8unorm(unconst_u32(42394638)).xx;
  fn0();
  let ptr18: ptr<storage, array<array<vec4f, 1>, 1>, read_write> = &buffer40.f0[arrayLength(&buffer40.f0)].f0[0][u32((*&buffer40).f0[unconst_u32(880057525)].f0[0][unconst_u32(59116726)][unconst_u32(159701307)][0][0][pack4x8snorm((*&buffer40).f0[arrayLength(&(*&buffer40).f0)].f0[0][unconst_u32(1556081660)][0][unconst_u32(257925210)][unconst_u32(57251579)])])][unconst_u32(2138613235)];
  return out;
  _ = buffer40;
}`,
});
let bindGroup8 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 6, resource: {buffer: buffer35}},
    {binding: 3, resource: textureView0},
    {binding: 58, resource: {buffer: buffer37}},
    {binding: 43, resource: {buffer: buffer37}},
  ],
});
let buffer43 = device0.createBuffer({size: 28, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let textureView39 = texture22.createView({dimension: '2d-array'});
try {
computePassEncoder0.setBindGroup(3, bindGroup5, new Uint32Array(6321), 201, 1);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
buffer38.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer11, 48, new Uint32Array(15480).map((_, i) => i * 1), 841, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 68, y: 12, z: 0},
  aspect: 'all',
}, new Uint8Array(99).fill(56), /* required buffer size: 99 */
{offset: 99, bytesPerRow: 92}, {width: 28, height: 28, depthOrArrayLayers: 0});
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'bt709'} });
let commandEncoder25 = device0.createCommandEncoder();
let texture38 = device0.createTexture({
  size: [780, 48, 41],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
renderPassEncoder2.setVertexBuffer(3, buffer43, 0);
} catch {}
try {
commandEncoder7.copyBufferToTexture({
  /* bytesInLastRow: 26 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 690 */
  offset: 690,
  bytesPerRow: 4864,
  buffer: buffer11,
}, {
  texture: texture15,
  mipLevel: 1,
  origin: {x: 28, y: 1, z: 0},
  aspect: 'all',
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder26 = device0.createCommandEncoder();
let renderPassEncoder4 = commandEncoder16.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: 510.5, g: -609.7, b: -372.8, a: -915.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let externalTexture6 = device0.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder2.setBindGroup(2, bindGroup6, [0]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer38, 'uint16', 6, 12);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer38, 8, new Float32Array(519).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.653)), 69, 4);
} catch {}
let commandEncoder27 = device0.createCommandEncoder({});
let textureView40 = texture24.createView({format: 'r32sint'});
let textureView41 = texture38.createView({mipLevelCount: 1});
try {
computePassEncoder4.setBindGroup(3, bindGroup4, new Uint32Array(182), 31, 1);
} catch {}
let texture39 = device0.createTexture({
  size: [780, 48, 1],
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder11 = commandEncoder18.beginComputePass();
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer19, 'uint32', 28, 3);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer19, 0, 16);
} catch {}
let pipeline2 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
let commandEncoder28 = device0.createCommandEncoder({});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4});
try {
computePassEncoder9.setBindGroup(0, bindGroup7, new Uint32Array(2977), 198, 1);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer1, 'uint32', 40, 42);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 352, new DataView(new Uint8Array(6049).map((_, i) => i).buffer), 1039, 748);
} catch {}
document.body.append(canvas0);
let textureView42 = texture35.createView({});
let texture40 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 2},
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder12 = commandEncoder24.beginComputePass();
try {
computePassEncoder7.setBindGroup(0, bindGroup0, new Uint32Array(790), 293, 0);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup4, [0]);
} catch {}
try {
commandEncoder27.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 35, y: 48, z: 0},
  aspect: 'all',
},
{width: 31, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder14.clearBuffer(buffer7);
} catch {}
try {
adapter0.label = '\ua44b\u0979\u64d5\u5233\ub52b\u6716\u07e4\ufeff\u2592\u{1fc2a}';
} catch {}
let texture41 = device0.createTexture({size: {width: 390}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder10.setBindGroup(1, bindGroup3, [0]);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer5);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder29 = device0.createCommandEncoder({});
let externalTexture7 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'srgb'});
let img2 = await imageWithData(6, 24, '#10101010', '#20202020');
let bindGroup9 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 138, resource: textureView7},
    {binding: 0, resource: externalTexture7},
    {binding: 1, resource: externalTexture0},
  ],
});
try {
renderPassEncoder3.setVertexBuffer(4, buffer43);
} catch {}
let bindGroup10 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 6, resource: {buffer: buffer5, size: 128}},
    {binding: 58, resource: {buffer: buffer37}},
    {binding: 43, resource: {buffer: buffer4, offset: 0}},
    {binding: 3, resource: textureView0},
  ],
});
try {
renderPassEncoder2.setVertexBuffer(7, buffer43, 4, 0);
} catch {}
let bindGroup11 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 58, resource: {buffer: buffer37}},
    {binding: 43, resource: {buffer: buffer4}},
    {binding: 6, resource: {buffer: buffer32}},
    {binding: 3, resource: textureView3},
  ],
});
let buffer44 = device0.createBuffer({size: 182, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView43 = texture32.createView({label: '\ud35c\uf9a8\u67a1\u0392\u3c2c\u393b', mipLevelCount: 1, arrayLayerCount: 1});
let textureView44 = texture28.createView({});
let computePassEncoder13 = commandEncoder25.beginComputePass();
try {
renderPassEncoder1.setIndexBuffer(buffer19, 'uint32', 24, 11);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
await gc();
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(0, buffer8, 0, 7);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 28, new Float32Array(10703).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.7637)), 234, 0);
} catch {}
try {
externalTexture1.label = '\ufbe8\u0266\u{1fdf8}\uaef1\u07e3\u00b1\u{1faac}\udd67';
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false },
    },
    {binding: 4, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 9, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 11, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 13,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 29,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 95,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 183,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 216,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 243,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 362,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let computePassEncoder14 = commandEncoder21.beginComputePass();
try {
computePassEncoder14.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer9, 'uint32', 20, 13);
} catch {}
let buffer45 = device0.createBuffer({size: 48, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder30 = device0.createCommandEncoder({});
let textureView45 = texture21.createView({format: 'rg8sint', mipLevelCount: 1, baseArrayLayer: 0});
try {
commandEncoder28.copyTextureToBuffer({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 40 */
  offset: 40,
  bytesPerRow: 29440,
  buffer: buffer44,
}, {width: 0, height: 4, depthOrArrayLayers: 0});
} catch {}
let commandEncoder31 = device0.createCommandEncoder();
let querySet0 = device0.createQuerySet({type: 'timestamp', count: 384});
try {
renderPassEncoder2.setIndexBuffer(buffer9, 'uint16', 6, 20);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer1, 'uint32', 44, 74);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 138, resource: textureView7},
    {binding: 1, resource: externalTexture5},
    {binding: 0, resource: externalTexture6},
  ],
});
let textureView46 = texture11.createView({format: 'r32uint'});
let externalTexture8 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'});
try {
computePassEncoder1.setBindGroup(3, bindGroup6, new Uint32Array(1189), 209, 1);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(2453), 403, 1);
} catch {}
try {
commandEncoder7.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 163, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture19,
  mipLevel: 0,
  origin: {x: 0, y: 5, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer44, 28, new BigInt64Array(7986).map((_, i) => BigInt(i - 2)), 643, 0);
} catch {}
let buffer46 = device0.createBuffer({size: 61, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder32 = device0.createCommandEncoder();
try {
renderPassEncoder4.setVertexBuffer(5, buffer43, 4, 5);
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

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

@group(0) @binding(58) var<storage, read_write> buffer49: array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 3>, 4>, 1>, 24>, 1>, 1>>;

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

struct FragmentOutput2 {
  @location(7) @interpolate(perspective, sample) location_7: f32,
  @location(0) @interpolate(flat, first) location_0: vec2i,
}

override override3: u32 = (140200032 % 103) + 1;

struct FragmentInput5 {
  @location(6) location_6: vec4h,
  @location(15) @interpolate(flat, centroid) location_15: vec4u,
}

struct T0 {
  @size(8) f0: bool,
  @align(8) @size(96) f1: vec2h,
}

override override4: u32;

struct FragmentInput4 {
  @location(9) location_9: vec4h,
  @location(8) location_8: vec2i,
  @location(4) location_4: vec2u,
}

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

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

var<private> vp4 = array(modf(vec3f(0.08166e1, 0.1473e-7, 0.3913e19)));

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

struct FragmentInput3 {
  @location(0) @interpolate(linear) location_0: vec4f,
}

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

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

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

@group(0) @binding(6) var<storage, read_write> buffer47: vec4f;

/* used global variables: buffer47 */
@fragment
fn fragment4(@location(14) @interpolate(flat) location_14: vec4u, @location(10) location_10: vec2f, a2: FragmentInput3, @location(5) location_5: vec2h, a4: FragmentInput4, a5: FragmentInput5, a6: FragmentInput6, @location(2) location_2: i32) -> FragmentOutput2 {
  var out: FragmentOutput2;
  out.location_0 -= vec2i(bitcast<i32>(location_10[location_14[unconst_u32(894580163)]]));
  var vf45: vec4u = a5.location_15;
  for (var it2=pack4xU8Clamp(location_14); it2<(bitcast<u32>(out.location_0[unconst_u32(188299568)]) & 0xfff); it2++) {
  var vf46: vec2u = (vec2u(unconst_u32(1496225667), unconst_u32(1404486959)) << vec2u(unconst_u32(349774633), unconst_u32(108395161)));
  buffer47 = vec4f(a2.location_0[unconst_u32(601041534)]);
  let vf47: vec4i = (vec4i(unconst_i32(298060404), unconst_i32(3229128), unconst_i32(175180156), unconst_i32(555301660)) % vec4i(i32(a5.location_6[unconst_u32(321296950)])));
  out.location_0 *= vec2i(vp4[0].whole.xx.yy);
  let vf48: FragmentInput3 = a2;
  _ = buffer47;
}
  {
  var vf49: f32 = a2.location_0[unconst_u32(1561018445)];
  buffer47 += vp4[unconst_u32(587201661)].whole.xxzx;
  let ptr19 = &vp4[unconst_u32(1036039377)];
  var vf50: f32 = a2.location_0[unconst_u32(54557082)];
  var vf51: FragmentInput6 = a6;
  vp4[unconst_u32(1085529080)] = modf(vp4[unconst_u32(769216155)].fract);
  _ = buffer47;
}
  let vf52: f32 = location_10[unconst_u32(3531954230)];
  out = FragmentOutput2(f32(a4.location_8[unconst_u32(55530851)]), vec2i(a4.location_8[unconst_u32(55530851)]));
  var vf53: f16 = a4.location_9[unconst_u32(821758682)];
  return out;
  _ = buffer47;
}

/* used global variables: buffer47, buffer49 */
@compute @workgroup_size(1, 1, 1)
fn compute4(@builtin(local_invocation_index) local_invocation_index: u32, a1: ComputeInput5, @builtin(num_workgroups) num_workgroups: vec3u) {
  buffer47 -= vec4f(f32((*&buffer49)[unconst_u32(262077955)][unconst_u32(272390449)][unconst_u32(240164927)][23][0][unconst_u32(761907919)][unconst_u32(22269189)][0][0]));
  buffer49[unconst_u32(692873148)][unconst_u32(733386992)][unconst_u32(372485894)][unconst_u32(305602329)][unconst_u32(1241056263)][unconst_u32(1048625353)][unconst_u32(74794683)][unconst_u32(1310835203)][unconst_u32(882438201)] *= (*&buffer49)[arrayLength(&(*&buffer49))][unconst_u32(665432587)][unconst_u32(502236393)][23][unconst_u32(565667893)][unconst_u32(412589324)][2][unconst_u32(1831110691)][0];
  _ = buffer49;
  _ = buffer47;
}`,
});
let buffer50 = device0.createBuffer({size: 0, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let texture42 = device0.createTexture({size: {width: 16}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
let renderPassEncoder5 = commandEncoder23.beginRenderPass({
  colorAttachments: [{
  view: textureView33,
  clearValue: { r: -551.4, g: -180.9, b: -567.5, a: 278.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder4.setBindGroup(0, bindGroup3, new Uint32Array(346), 130, 1);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup2, new Uint32Array(1410), 21, 0);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(4, buffer19, 20);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 0, new Uint32Array(1640).map((_, i) => i * 10), 28, 0);
} catch {}
let bindGroup13 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 0, resource: externalTexture3},
    {binding: 1, resource: externalTexture0},
    {binding: 138, resource: textureView7},
  ],
});
let commandEncoder33 = device0.createCommandEncoder({label: '\ue962\ua8a7\u46be\u1cb9\u{1fa23}\u913b\u0b0e\u1b06\u{1f919}'});
try {
computePassEncoder4.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(6, buffer19, 16);
} catch {}
try {
  await buffer44.mapAsync(GPUMapMode.READ, 0, 28);
} catch {}
let pipeline3 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}});
let imageData2 = new ImageData(72, 4);
let commandEncoder34 = device0.createCommandEncoder({});
try {
commandEncoder10.copyBufferToTexture({
  /* bytesInLastRow: 68 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1072 */
  offset: 1072,
  bytesPerRow: 1280,
  buffer: buffer11,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 7, y: 20, z: 0},
  aspect: 'all',
}, {width: 17, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer46, 0, new BigInt64Array(2923).map((_, i) => BigInt(i - 5)), 205, 4);
} catch {}
let texture43 = device0.createTexture({
  size: [780, 480, 1],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder5.setBindGroup(0, bindGroup9);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup5, new Uint32Array(676), 41, 1);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer19, 'uint32', 8, 2);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline1);
} catch {}
try {
commandEncoder26.copyBufferToTexture({
  /* bytesInLastRow: 1036 widthInBlocks: 259 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 336 */
  offset: 336,
  buffer: buffer6,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 63, y: 0, z: 0},
  aspect: 'all',
}, {width: 259, height: 0, depthOrArrayLayers: 0});
} catch {}
let renderPassEncoder6 = commandEncoder30.beginRenderPass({
  colorAttachments: [{
  view: textureView33,
  clearValue: { r: -896.3, g: 993.1, b: -610.2, a: 71.10, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 68, endOfPassWriteIndex: 254},
});
try {
renderPassEncoder5.setVertexBuffer(3, buffer5);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup4, [0]);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(6, buffer19, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 43, resource: {buffer: buffer4}},
    {binding: 58, resource: {buffer: buffer21, size: 1784}},
    {binding: 3, resource: textureView0},
    {binding: 6, resource: {buffer: buffer22}},
  ],
});
let buffer51 = device0.createBuffer({size: 296, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let texture44 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 13},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
renderPassEncoder2.setBindGroup(1, bindGroup5, [0]);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer1, 'uint32', 4, 214);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(3, buffer5, 4, 8);
} catch {}
try {
renderBundleEncoder16.insertDebugMarker('\u0490');
} catch {}
let commandEncoder35 = device0.createCommandEncoder({});
let computePassEncoder15 = commandEncoder29.beginComputePass();
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], sampleCount: 1, depthReadOnly: true});
try {
computePassEncoder15.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer19, 'uint32', 0, 7);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup5, [0]);
} catch {}
try {
buffer11.unmap();
} catch {}
let pipeline4 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
let buffer52 = device0.createBuffer({size: 24, usage: GPUBufferUsage.INDEX});
let commandEncoder36 = device0.createCommandEncoder({});
let textureView47 = texture33.createView({});
try {
computePassEncoder11.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer9, 'uint16', 16, 30);
} catch {}
try {
buffer9.unmap();
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
await gc();
try {
computePassEncoder12.setBindGroup(3, bindGroup3, new Uint32Array(550), 39, 1);
} catch {}
let imageData3 = new ImageData(192, 80);
try {
adapter0.label = '\u{1fe34}\u013e\ue1e5\u1dfd\u6b63\ue15b\u0a40\u40f2\uaa59';
} catch {}
let commandEncoder37 = device0.createCommandEncoder({});
let textureView48 = texture38.createView({mipLevelCount: 1});
try {
renderPassEncoder2.setVertexBuffer(7, buffer35, 0);
} catch {}
let bindGroup15 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 6, resource: {buffer: buffer45}},
    {binding: 58, resource: {buffer: buffer21, offset: 0, size: 584}},
    {binding: 43, resource: {buffer: buffer35}},
    {binding: 3, resource: textureView0},
  ],
});
let buffer53 = device0.createBuffer({size: 12, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder38 = device0.createCommandEncoder({});
let texture45 = device0.createTexture({
  size: [2, 2, 14],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
buffer1.unmap();
} catch {}
let buffer54 = device0.createBuffer({size: 62, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let textureView49 = texture10.createView({dimension: '2d-array', format: 'r32sint'});
try {
computePassEncoder9.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 4, new BigInt64Array(10493).map((_, i) => BigInt(i - 8)), 3297, 0);
} catch {}
let imageData4 = new ImageData(28, 20);
let buffer55 = device0.createBuffer({size: 15968, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup12, new Uint32Array(785), 25, 0);
} catch {}
document.body.prepend(canvas0);
await gc();
let texture46 = device0.createTexture({
  size: [780, 48, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder13.setBindGroup(3, bindGroup7, new Uint32Array(190), 6, 1);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer35);
} catch {}
try {
device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(113400)), 99, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
bindGroup15.label = '\u4d8a\u031d\u75ab\u{1fbd3}\ued14\u18cb\u7471\u{1f6d7}\u0696\u{1fd90}';
} catch {}
let bindGroup16 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 0, resource: externalTexture3},
    {binding: 1, resource: externalTexture8},
    {binding: 138, resource: textureView13},
  ],
});
let buffer56 = device0.createBuffer({size: 5472, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let texture47 = device0.createTexture({
  size: [195, 120, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture48 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 3},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder1.setBindGroup(1, bindGroup13, new Uint32Array(1220), 588, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer55, 'uint16', 526, 6_888);
} catch {}
try {
computePassEncoder2.insertDebugMarker('\u4c72');
} catch {}
document.body.prepend(img2);
let offscreenCanvas1 = new OffscreenCanvas(14, 67);
let textureView50 = texture47.createView({});
let externalTexture9 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder14.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer53, 'uint32', 0, 0);
} catch {}
let arrayBuffer0 = buffer44.getMappedRange(0, 0);
let texture49 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder5.setBindGroup(3, bindGroup2);
} catch {}
let arrayBuffer1 = buffer44.getMappedRange(8, 8);
let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu');
let textureView51 = texture49.createView({label: '\u0e04\u0583\u3237\ud779\u03e5\ucd00\u07ec\ua1f4', mipLevelCount: 1, baseArrayLayer: 0});
let textureView52 = texture48.createView({label: '\uccef\ue95a\ueec2\ua19c', mipLevelCount: 1});
try {
computePassEncoder13.setBindGroup(0, bindGroup0, new Uint32Array(2131), 126, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer38, 'uint16', 0, 9);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer19);
} catch {}
try {
renderBundleEncoder11.setBindGroup(0, bindGroup0, new Uint32Array(388), 5, 0);
} catch {}
try {
  await promise6;
} catch {}
let textureView53 = texture49.createView({dimension: '2d', aspect: 'all'});
try {
computePassEncoder12.setBindGroup(3, bindGroup14, new Uint32Array(403), 41, 1);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup15, new Uint32Array(5627), 2_568, 1);
} catch {}
let textureView54 = texture26.createView({});
await gc();
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout3]});
let buffer57 = device0.createBuffer({size: 52, usage: GPUBufferUsage.QUERY_RESOLVE});
let textureView55 = texture33.createView({mipLevelCount: 1});
try {
renderPassEncoder3.setBindGroup(1, bindGroup10, new Uint32Array(514), 11, 1);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer53, 'uint32', 0, 0);
} catch {}
try {
shaderModule2.label = '\u3c37\ua218\ue173\u{1f6cf}\u22d1\u66f3\u077d\u189c\u0b86\u929e';
} catch {}
let textureView56 = texture41.createView({aspect: 'all'});
try {
computePassEncoder0.setBindGroup(0, bindGroup10, [0]);
} catch {}
try {
renderPassEncoder6.insertDebugMarker('\u098f');
} catch {}
let commandEncoder39 = device0.createCommandEncoder({});
let textureView57 = texture16.createView({dimension: '2d-array'});
try {
computePassEncoder5.setPipeline(pipeline3);
} catch {}
try {
commandEncoder33.copyBufferToBuffer(buffer0, 24, buffer34, 124, 8);
} catch {}
let commandEncoder40 = device0.createCommandEncoder();
let texture50 = device0.createTexture({
  size: [8, 12, 1],
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture51 = device0.createTexture({size: [8, 12, 30], format: 'r16sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
try {
computePassEncoder5.setBindGroup(3, bindGroup0, new Uint32Array(3686), 236, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer1, 'uint32', 88, 45);
} catch {}
try {
buffer55.unmap();
} catch {}
let bindGroup17 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 6, resource: {buffer: buffer21, size: 144}},
    {binding: 3, resource: textureView17},
    {binding: 58, resource: {buffer: buffer37, offset: 0}},
    {binding: 43, resource: {buffer: buffer35}},
  ],
});
let commandEncoder41 = device0.createCommandEncoder({});
let textureView58 = texture50.createView({baseMipLevel: 0, arrayLayerCount: 1});
try {
renderBundleEncoder0.setBindGroup(1, bindGroup15, new Uint32Array(4308), 57, 1);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer1, 'uint32', 104, 37);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(0, buffer5);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let texture52 = device0.createTexture({size: [16, 24, 22], format: 'rg8sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
try {
computePassEncoder6.setBindGroup(0, bindGroup14, new Uint32Array(1817), 133, 1);
} catch {}
let externalTexture10 = device0.importExternalTexture({source: videoFrame6});
try {
renderPassEncoder1.setVertexBuffer(4, buffer19, 8, 14);
} catch {}
try {
renderPassEncoder6.insertDebugMarker('\u{1fa9b}');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup18 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 11, resource: externalTexture10},
    {binding: 216, resource: textureView43},
    {binding: 183, resource: textureView40},
    {binding: 1, resource: textureView15},
    {binding: 243, resource: textureView47},
    {binding: 4, resource: sampler7},
    {binding: 29, resource: externalTexture8},
    {binding: 0, resource: {buffer: buffer21, size: 1160}},
    {binding: 7, resource: textureView34},
    {binding: 95, resource: {buffer: buffer37}},
    {binding: 13, resource: {buffer: buffer37}},
    {binding: 362, resource: textureView12},
    {binding: 15, resource: {buffer: buffer54, size: 50}},
    {binding: 9, resource: sampler2},
  ],
});
let buffer58 = device0.createBuffer({size: 256, usage: GPUBufferUsage.COPY_DST});
let texture53 = device0.createTexture({size: {width: 16}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let externalTexture11 = device0.importExternalTexture({source: videoFrame3});
try {
renderPassEncoder5.setBindGroup(1, bindGroup1, new Uint32Array(89), 2, 0);
} catch {}
try {
computePassEncoder3.insertDebugMarker('\u6517');
} catch {}
let pipeline5 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule1, targets: [{format: 'rg8sint'}]},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 56,
        attributes: [
          {format: 'uint16x2', offset: 4, shaderLocation: 14},
          {format: 'uint8x4', offset: 16, shaderLocation: 4},
          {format: 'float16x2', offset: 12, shaderLocation: 3},
          {format: 'unorm8x4', offset: 8, shaderLocation: 13},
          {format: 'sint32x4', offset: 0, shaderLocation: 8},
          {format: 'sint8x2', offset: 6, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 12,
        attributes: [
          {format: 'uint32x3', offset: 0, shaderLocation: 0},
          {format: 'uint16x4', offset: 0, shaderLocation: 1},
          {format: 'sint8x2', offset: 0, shaderLocation: 12},
          {format: 'float32x3', offset: 0, shaderLocation: 10},
          {format: 'unorm8x4', offset: 0, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7},
          {format: 'sint16x2', offset: 0, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 132,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 44, shaderLocation: 5}],
      },
      {
        arrayStride: 60,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 12, shaderLocation: 11},
          {format: 'sint8x2', offset: 58, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', cullMode: 'back'},
});
let imageData5 = new ImageData(20, 76);
let buffer59 = device0.createBuffer({
  size: 88,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder42 = device0.createCommandEncoder({});
let texture54 = device0.createTexture({size: [390, 240, 1], format: 'rg8sint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder7.setBindGroup(2, bindGroup15, [0]);
} catch {}
try {
computePassEncoder2.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup9);
} catch {}
let bindGroup19 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 58, resource: {buffer: buffer21, size: 632}},
    {binding: 6, resource: {buffer: buffer37}},
    {binding: 43, resource: {buffer: buffer56}},
    {binding: 3, resource: textureView0},
  ],
});
let texture55 = device0.createTexture({
  size: {width: 780, height: 480, depthOrArrayLayers: 1},
  mipLevelCount: 8,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg8sint'],
});
try {
renderPassEncoder1.setIndexBuffer(buffer9, 'uint16', 56, 43);
} catch {}
try {
renderBundleEncoder11.setBindGroup(3, bindGroup14, [0]);
} catch {}
let textureView59 = texture27.createView({baseMipLevel: 0});
let computePassEncoder16 = commandEncoder12.beginComputePass();
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, depthReadOnly: false});
try {
computePassEncoder11.setBindGroup(3, bindGroup18, new Uint32Array(1901), 548, 0);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: externalTexture3},
    {binding: 0, resource: externalTexture1},
    {binding: 138, resource: textureView7},
  ],
});
let commandEncoder43 = device0.createCommandEncoder({});
let texture56 = device0.createTexture({
  size: [8, 12, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder14.setBindGroup(0, bindGroup4, new Uint32Array(254), 9, 1);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
buffer22.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer58, 52, new Uint32Array(26384).map((_, i) => i * 2), 764, 0);
} catch {}
let bindGroup21 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 43, resource: {buffer: buffer51}},
    {binding: 58, resource: {buffer: buffer21, size: 3560}},
    {binding: 3, resource: textureView17},
    {binding: 6, resource: {buffer: buffer32}},
  ],
});
let texture57 = device0.createTexture({size: [97, 60, 39], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder3.setIndexBuffer(buffer9, 'uint16', 18, 18);
} catch {}
try {
device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(23932)), 495, 0);
} catch {}
let pipeline6 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2}});
document.body.append(img0);
let buffer60 = device0.createBuffer({
  size: 196,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture58 = gpuCanvasContext2.getCurrentTexture();
let textureView60 = texture36.createView({dimension: '2d-array', baseArrayLayer: 0});
try {
renderPassEncoder5.setBindGroup(0, bindGroup18, new Uint32Array(5975), 112, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer52, 'uint32', 0, 2);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup11, [0]);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer43);
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1674 */
  offset: 1674,
  bytesPerRow: 12800,
  buffer: buffer11,
}, {
  texture: texture39,
  mipLevel: 2,
  origin: {x: 48, y: 4, z: 0},
  aspect: 'all',
}, {width: 6, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
  await promise7;
} catch {}
let commandEncoder44 = device0.createCommandEncoder({});
let texture59 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView61 = texture40.createView({baseMipLevel: 0});
try {
computePassEncoder11.setBindGroup(2, bindGroup5, [0]);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup7, new Uint32Array(1463), 58, 1);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer19, 'uint32', 0, 28);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer8, 0);
} catch {}
try {
  await buffer46.mapAsync(GPUMapMode.READ, 0, 20);
} catch {}
await gc();
let buffer61 = device0.createBuffer({size: 164, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture60 = device0.createTexture({
  size: [390, 240, 1],
  sampleCount: 4,
  dimension: '2d',
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView62 = texture44.createView({mipLevelCount: 1});
let sampler10 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 76.87,
  lodMaxClamp: 94.98,
  maxAnisotropy: 7,
});
try {
renderPassEncoder2.setIndexBuffer(buffer1, 'uint32', 120, 8);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup11, [0]);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(3, buffer35, 0);
} catch {}
try {
commandEncoder41.copyBufferToBuffer(buffer11, 744, buffer60, 24, 4);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let autogeneratedBindGroupLayout0 = pipeline5.getBindGroupLayout(0);
let buffer62 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let texture61 = device0.createTexture({size: {width: 16}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST});
let externalTexture12 = device0.importExternalTexture({source: videoFrame3});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder45 = device0.createCommandEncoder({});
try {
computePassEncoder16.setBindGroup(0, bindGroup11, new Uint32Array(902), 254, 1);
} catch {}
let imageData6 = new ImageData(16, 16);
let bindGroup22 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 58, resource: {buffer: buffer21, size: 1536}},
    {binding: 43, resource: {buffer: buffer35}},
    {binding: 6, resource: {buffer: buffer34, size: 52}},
    {binding: 3, resource: textureView3},
  ],
});
let textureView63 = texture50.createView({});
let texture62 = device0.createTexture({
  size: {width: 1560},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView64 = texture42.createView({aspect: 'all'});
try {
renderPassEncoder3.setBindGroup(1, bindGroup12);
} catch {}
try {
device0.queue.writeBuffer(buffer38, 0, new Uint32Array(17285).map((_, i) => i * 5), 372, 0);
} catch {}
let textureView65 = texture31.createView({baseMipLevel: 0});
let texture63 = device0.createTexture({size: [390], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder1.setIndexBuffer(buffer55, 'uint16', 158, 829);
} catch {}
await gc();
let buffer63 = device0.createBuffer({size: 356, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder46 = device0.createCommandEncoder({});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, stencilReadOnly: true});
try {
renderPassEncoder1.setVertexBuffer(0, buffer5, 0, 93);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
let pipeline7 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, constants: {}}});
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt709', transfer: 'smpteSt4281'} });
let buffer64 = device0.createBuffer({size: 192, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let commandEncoder47 = device0.createCommandEncoder({});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], stencilReadOnly: true});
try {
renderPassEncoder6.setIndexBuffer(buffer9, 'uint32', 40, 5);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
let canvas1 = document.createElement('canvas');
let offscreenCanvas2 = new OffscreenCanvas(32, 158);
try {
textureView32.label = '\u{1f758}\u{1f657}\uc92a\u07a9\ue063\u{1f7e8}\u03dc\u09f8\u218e\ub62d\u02cf';
} catch {}
let textureView66 = texture3.createView({dimension: 'cube', aspect: 'all'});
let externalTexture13 = device0.importExternalTexture({source: videoFrame6});
try {
renderPassEncoder5.setIndexBuffer(buffer9, 'uint32', 0, 39);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer62, 0, 0);
} catch {}
try {
buffer57.unmap();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let commandEncoder48 = device0.createCommandEncoder({});
let textureView67 = texture47.createView({});
try {
computePassEncoder1.setBindGroup(3, bindGroup19, [0]);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(4, buffer19, 0, 4);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer60, 'uint32', 20, 44);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(126).fill(86), /* required buffer size: 126 */
{offset: 126}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext3 = canvas1.getContext('webgpu');
let renderPassEncoder7 = commandEncoder45.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  depthSlice: 0,
  clearValue: { r: 6.806, g: 245.7, b: 41.75, a: 518.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderBundleEncoder0.setIndexBuffer(buffer63, 'uint16', 72, 9);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer35);
} catch {}
let arrayBuffer2 = buffer46.getMappedRange(0, 4);
try {
renderBundleEncoder9.pushDebugGroup('\u3510');
} catch {}
try {
device0.queue.writeBuffer(buffer2, 0, new Uint32Array(5717).map((_, i) => i * 3), 1658, 0);
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint']});
try {
computePassEncoder13.setBindGroup(2, bindGroup21, [0]);
} catch {}
let pipeline8 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule1, targets: [{format: 'rg8sint'}]},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 0, shaderLocation: 7},
          {format: 'uint16x2', offset: 0, shaderLocation: 4},
          {format: 'sint8x4', offset: 0, shaderLocation: 8},
          {format: 'sint16x2', offset: 0, shaderLocation: 15},
          {format: 'sint8x2', offset: 0, shaderLocation: 5},
          {format: 'snorm8x4', offset: 0, shaderLocation: 2},
          {format: 'float16x2', offset: 0, shaderLocation: 10},
          {format: 'uint32', offset: 0, shaderLocation: 0},
          {format: 'uint16x2', offset: 0, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 12,
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 12},
          {format: 'snorm16x4', offset: 0, shaderLocation: 3},
          {format: 'sint8x4', offset: 0, shaderLocation: 9},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 56,
        attributes: [
          {format: 'float32x2', offset: 0, shaderLocation: 13},
          {format: 'sint32x2', offset: 12, shaderLocation: 6},
          {format: 'uint8x4', offset: 16, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {cullMode: 'back', unclippedDepth: true},
});
let imageData7 = new ImageData(176, 140);
let bindGroup23 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: externalTexture9},
    {binding: 138, resource: textureView13},
    {binding: 0, resource: externalTexture11},
  ],
});
let buffer65 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let textureView68 = texture50.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder8.setBindGroup(0, bindGroup10, [0]);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup6, [0]);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup5, [0]);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer52, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline1);
} catch {}
try {
buffer51.unmap();
} catch {}
let bindGroup24 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 43, resource: {buffer: buffer51}},
    {binding: 58, resource: {buffer: buffer37}},
    {binding: 3, resource: textureView3},
    {binding: 6, resource: {buffer: buffer20, offset: 0}},
  ],
});
let buffer66 = device0.createBuffer({
  size: 300,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder13.setBindGroup(1, bindGroup11, new Uint32Array(7197), 534, 1);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup6, [0]);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup7, new Uint32Array(4664), 1_740, 1);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView69 = texture33.createView({baseMipLevel: 0});
let texture64 = device0.createTexture({
  size: [390, 24, 1],
  mipLevelCount: 1,
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView70 = texture38.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
renderBundleEncoder19.setBindGroup(3, bindGroup15, new Uint32Array(797), 49, 1);
} catch {}
try {
commandEncoder10.insertDebugMarker('\ua50a');
} catch {}
try {
computePassEncoder10.insertDebugMarker('\u2768');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
let buffer67 = device0.createBuffer({size: 212, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder49 = device0.createCommandEncoder({});
let textureView71 = texture54.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder5.setVertexBuffer(5, buffer59);
} catch {}
let texture65 = device0.createTexture({size: [780, 480, 1], mipLevelCount: 1, format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
let textureView72 = texture12.createView({mipLevelCount: 1});
let externalTexture14 = device0.importExternalTexture({label: '\u{1fea4}\u9c9a\u3fc7\ue918', source: videoFrame3});
try {
renderBundleEncoder8.setBindGroup(3, bindGroup20);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer19, 16);
} catch {}
try {
device0.queue.writeBuffer(buffer67, 16, new Uint32Array(12305).map((_, i) => i * 6), 6535, 0);
} catch {}
try {
computePassEncoder4.setBindGroup(0, bindGroup13, new Uint32Array(312), 37, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup23, new Uint32Array(696), 263, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer8, 0, 8);
} catch {}
try {
renderBundleEncoder0.setBindGroup(3, bindGroup4, [0]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(300).fill(95), /* required buffer size: 300 */
{offset: 300}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData8 = new ImageData(8, 52);
try {
renderBundleEncoder15.setVertexBuffer(1, buffer59, 36);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let gpuCanvasContext4 = offscreenCanvas2.getContext('webgpu');
let bindGroup25 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 58, resource: {buffer: buffer21, size: 904}},
    {binding: 43, resource: {buffer: buffer4}},
    {binding: 6, resource: {buffer: buffer20}},
    {binding: 3, resource: textureView0},
  ],
});
try {
computePassEncoder2.setBindGroup(1, bindGroup22, [0]);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: -182.1, g: 993.3, b: -938.0, a: 996.2, });
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup1);
} catch {}
let texture66 = device0.createTexture({
  size: [780, 48, 1],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setBindGroup(0, bindGroup12);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline8);
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let pipeline9 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3}});
let autogeneratedBindGroupLayout1 = pipeline7.getBindGroupLayout(0);
let buffer68 = device0.createBuffer({size: 160, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let sampler11 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 96.59});
let externalTexture15 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder0.setPipeline(pipeline4);
} catch {}
try {
commandEncoder31.copyTextureToBuffer({
  texture: texture52,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 584 */
  offset: 584,
  bytesPerRow: 31744,
  rowsPerImage: 20,
  buffer: buffer56,
}, {width: 0, height: 8, depthOrArrayLayers: 0});
} catch {}
let buffer69 = device0.createBuffer({size: 228, usage: GPUBufferUsage.INDEX});
try {
computePassEncoder5.setBindGroup(3, bindGroup18);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer53, 'uint32', 0, 9);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer43, 0, 4);
} catch {}
try {
renderBundleEncoder17.setBindGroup(1, bindGroup19, [0]);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer56, 176, new DataView(new Uint8Array(45685).map((_, i) => i).buffer), 8242, 912);
} catch {}
try {
device0.queue.writeBuffer(buffer66, 84, new Float32Array(7745).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.932)), 1362, 12);
} catch {}
let pipeline10 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}});
document.body.prepend(canvas1);
let textureView73 = texture45.createView({dimension: 'cube', format: 'r16sint', arrayLayerCount: 6});
let textureView74 = texture29.createView({});
let sampler12 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 77.71,
  maxAnisotropy: 20,
});
try {
computePassEncoder8.setBindGroup(2, bindGroup3, new Uint32Array(1964), 1_116, 1);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(6, buffer62, 0, 0);
} catch {}
try {
texture40.label = '\u5b16\u0cec\u0fc1\ud7c2\u909a';
} catch {}
let buffer70 = device0.createBuffer({size: 512, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let textureView75 = texture8.createView({dimension: '3d', mipLevelCount: 1, baseArrayLayer: 0});
let buffer71 = device0.createBuffer({size: 76, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder50 = device0.createCommandEncoder({});
let textureView76 = texture30.createView({});
let computePassEncoder17 = commandEncoder15.beginComputePass({timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 351}});
let externalTexture16 = device0.importExternalTexture({source: videoFrame1});
try {
renderBundleEncoder16.setIndexBuffer(buffer1, 'uint32', 4, 27);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(6, buffer43, 0);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
renderBundleEncoder9.popDebugGroup();
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer34, 36, new DataView(new ArrayBuffer(39060)), 1066, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder17.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer69, 'uint32', 12, 72);
} catch {}
try {
commandEncoder36.copyBufferToTexture({
  /* bytesInLastRow: 46 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 846 */
  offset: 846,
  rowsPerImage: 39,
  buffer: buffer11,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let texture67 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView77 = texture61.createView({baseArrayLayer: 0});
try {
renderBundleEncoder0.setBindGroup(2, bindGroup5, [0]);
} catch {}
let commandEncoder51 = device0.createCommandEncoder({});
let textureView78 = texture47.createView({aspect: 'all'});
let texture68 = device0.createTexture({
  size: [390, 240, 1],
  mipLevelCount: 4,
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView79 = texture61.createView({label: '\uf512\ud0d5\ua738\u0909\u07fe'});
let renderPassEncoder8 = commandEncoder7.beginRenderPass({
  label: '\u9c74\u475f\u{1f74d}\u6cfc\uc210\u03e8\u3e4e\u0974\u0581\u872b\u5dde',
  colorAttachments: [{
  view: textureView61,
  depthSlice: 1,
  clearValue: { r: -407.0, g: -798.6, b: 76.58, a: 478.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder11.setBindGroup(0, bindGroup19, new Uint32Array(1177), 21, 1);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup24, [0]);
} catch {}
try {
commandEncoder38.clearBuffer(buffer38);
} catch {}
try {
commandEncoder33.pushDebugGroup('\u2d26');
} catch {}
await gc();
let bindGroup26 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 3, resource: textureView3},
    {binding: 58, resource: {buffer: buffer21, size: 1032}},
    {binding: 6, resource: {buffer: buffer37}},
    {binding: 43, resource: {buffer: buffer64}},
  ],
});
let texture69 = device0.createTexture({
  size: {width: 16},
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let externalTexture17 = device0.importExternalTexture({source: videoFrame5, colorSpace: 'display-p3'});
try {
renderPassEncoder4.setBindGroup(2, bindGroup0, []);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer60, 'uint32', 56, 45);
} catch {}
try {
commandEncoder33.popDebugGroup();
} catch {}
let commandEncoder52 = device0.createCommandEncoder({});
let texture70 = device0.createTexture({
  size: [32],
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder18 = commandEncoder35.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 171, endOfPassWriteIndex: 141}});
try {
renderPassEncoder6.setBindGroup(0, bindGroup21, new Uint32Array(49), 1, 1);
} catch {}
try {
renderBundleEncoder11.setBindGroup(0, bindGroup9, new Uint32Array(2815), 155, 0);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(2, buffer8, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let texture71 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 14},
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder4.setVertexBuffer(0, buffer43, 8, 4);
} catch {}
try {
computePassEncoder9.insertDebugMarker('\u00c5');
} catch {}
let bindGroup27 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 3, resource: textureView0},
    {binding: 58, resource: {buffer: buffer21, offset: 1280, size: 904}},
    {binding: 43, resource: {buffer: buffer37}},
    {binding: 6, resource: {buffer: buffer5}},
  ],
});
let commandEncoder53 = device0.createCommandEncoder({});
let textureView80 = texture69.createView({});
let textureView81 = texture55.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 4});
let externalTexture18 = device0.importExternalTexture({source: videoFrame6});
try {
renderPassEncoder4.setVertexBuffer(5, buffer68, 0);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(0, buffer35);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
renderBundleEncoder15.insertDebugMarker('\u0cf4');
} catch {}
try {
device0.queue.writeBuffer(buffer67, 0, new Float32Array(13188).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.9739)), 682, 0);
} catch {}
document.body.append(canvas1);
let buffer72 = device0.createBuffer({size: 56, usage: GPUBufferUsage.UNIFORM});
let commandEncoder54 = device0.createCommandEncoder({});
let textureView82 = texture67.createView({arrayLayerCount: 1});
try {
commandEncoder49.copyBufferToBuffer(buffer11, 256, buffer10, 48, 44);
} catch {}
let pipeline11 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, constants: {}}});
let offscreenCanvas3 = new OffscreenCanvas(58, 236);
let texture72 = device0.createTexture({
  size: {width: 195, height: 12, depthOrArrayLayers: 1},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView83 = texture65.createView({dimension: '2d-array', aspect: 'all'});
try {
computePassEncoder18.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup16);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer53, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer60, 'uint16', 64, 80);
} catch {}
try {
device0.queue.writeBuffer(buffer56, 1_572, new DataView(new Uint8Array(16422).map((_, i) => i).buffer), 207, 3900);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 12, y: 4 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 42, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 17, depthOrArrayLayers: 0});
} catch {}
let img3 = await imageWithData(69, 17, '#10101010', '#20202020');
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'jedecP22Phosphors', transfer: 'gamma28curve'} });
let autogeneratedBindGroupLayout2 = pipeline9.getBindGroupLayout(0);
let buffer73 = device0.createBuffer({
  size: 52,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let texture73 = device0.createTexture({
  size: [195],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView84 = texture6.createView({dimension: '2d-array', format: 'r16sint', mipLevelCount: 1});
try {
commandEncoder47.copyTextureToBuffer({
  texture: texture67,
  mipLevel: 0,
  origin: {x: 93, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 832 widthInBlocks: 52 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 32 */
  offset: 32,
  bytesPerRow: 20480,
  buffer: buffer22,
}, {width: 52, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer22, 32, new DataView(new ArrayBuffer(8300)), 125, 0);
} catch {}
let pipeline12 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule1,
  constants: {},
  targets: [{
  format: 'rg8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 484, shaderLocation: 11},
          {format: 'uint8x4', offset: 0, shaderLocation: 3},
          {format: 'snorm8x4', offset: 20, shaderLocation: 0},
          {format: 'unorm10-10-10-2', offset: 372, shaderLocation: 1},
          {format: 'unorm16x4', offset: 20, shaderLocation: 5},
          {format: 'snorm8x4', offset: 64, shaderLocation: 13},
          {format: 'unorm8x4', offset: 0, shaderLocation: 10},
          {format: 'sint8x4', offset: 120, shaderLocation: 4},
          {format: 'float16x2', offset: 516, shaderLocation: 6},
          {format: 'sint32', offset: 8, shaderLocation: 14},
          {format: 'sint32x3', offset: 108, shaderLocation: 12},
          {format: 'snorm16x4', offset: 68, shaderLocation: 2},
          {format: 'snorm16x4', offset: 184, shaderLocation: 8},
          {format: 'snorm8x4', offset: 184, shaderLocation: 7},
          {format: 'uint16x4', offset: 52, shaderLocation: 15},
          {format: 'snorm16x4', offset: 696, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list'},
});
let gpuCanvasContext5 = offscreenCanvas3.getContext('webgpu');
try {
  await promise8;
} catch {}
let autogeneratedBindGroupLayout3 = pipeline1.getBindGroupLayout(0);
let bindGroup28 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 0, resource: {buffer: buffer21, size: 1468}},
    {binding: 7, resource: textureView65},
    {binding: 1, resource: textureView49},
    {binding: 216, resource: textureView43},
    {binding: 243, resource: textureView37},
    {binding: 11, resource: externalTexture13},
    {binding: 29, resource: externalTexture13},
    {binding: 13, resource: {buffer: buffer66}},
    {binding: 183, resource: textureView24},
    {binding: 15, resource: {buffer: buffer54, size: 49}},
    {binding: 362, resource: textureView57},
    {binding: 9, resource: sampler10},
    {binding: 4, resource: sampler10},
    {binding: 95, resource: {buffer: buffer56, offset: 256}},
  ],
});
let textureView85 = texture71.createView({arrayLayerCount: 3});
let textureView86 = texture23.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder6.setBindGroup(1, bindGroup18, []);
} catch {}
let arrayBuffer3 = buffer44.getMappedRange(16, 0);
try {
device0.queue.writeBuffer(buffer56, 1_392, new Float32Array(55832).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4429)), 912, 148);
} catch {}
let bindGroup29 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []});
let textureView87 = texture72.createView({});
let renderPassEncoder9 = commandEncoder39.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  depthSlice: 0,
  clearValue: { r: -903.1, g: 892.6, b: 197.6, a: -36.82, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let sampler13 = device0.createSampler({
  label: '\u8f04\u{1fb77}\u{1ff25}\u{1f691}\u0449',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 74.49,
});
try {
renderPassEncoder0.setIndexBuffer(buffer60, 'uint16', 74, 1);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(2, buffer43, 0, 2);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup16, []);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(246).fill(72), /* required buffer size: 246 */
{offset: 246, bytesPerRow: 16}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas3,
  origin: { x: 5, y: 29 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 195, y: 24, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup30 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 138, resource: textureView13},
    {binding: 0, resource: externalTexture3},
    {binding: 1, resource: externalTexture3},
  ],
});
let commandEncoder55 = device0.createCommandEncoder({});
let textureView88 = texture73.createView({baseArrayLayer: 0});
try {
commandEncoder38.copyBufferToBuffer(buffer43, 0, buffer7, 0, 8);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer69, 'uint16', 6, 8);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let computePassEncoder19 = commandEncoder14.beginComputePass();
let externalTexture19 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
let autogeneratedBindGroupLayout4 = pipeline7.getBindGroupLayout(0);
let buffer74 = device0.createBuffer({size: 88, usage: GPUBufferUsage.INDEX});
let texture74 = device0.createTexture({
  size: [780, 480, 10],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg8sint'],
});
try {
computePassEncoder12.setBindGroup(1, bindGroup5, [0]);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup11, new Uint32Array(443), 33, 1);
} catch {}
try {
renderBundleEncoder5.insertDebugMarker('\u{1f745}');
} catch {}
try {
device0.queue.submit([]);
} catch {}
let texture75 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 38},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let renderPassEncoder10 = commandEncoder41.beginRenderPass({
  colorAttachments: [{view: textureView61, depthSlice: 1, loadOp: 'clear', storeOp: 'discard'}],
  timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 108},
  maxDrawCount: 36970143,
});
try {
computePassEncoder9.setBindGroup(3, bindGroup10, new Uint32Array(885), 271, 1);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer19, 'uint16', 2, 15);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline1);
} catch {}
let textureView89 = texture54.createView({dimension: '2d-array', baseMipLevel: 0});
try {
computePassEncoder5.setBindGroup(3, bindGroup17, new Uint32Array(1424), 3, 1);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline3);
} catch {}
try {
buffer32.unmap();
} catch {}
try {
renderPassEncoder2.label = '\u04aa\u0e50\ud3f0\u{1f7aa}\u1f05';
} catch {}
try {
commandEncoder38.copyTextureToBuffer({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 2, y: 4, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1332 */
  offset: 1332,
  bytesPerRow: 49664,
  buffer: buffer56,
}, {width: 3, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder17.insertDebugMarker('\u{1fb3c}');
} catch {}
let buffer75 = device0.createBuffer({size: 340, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder56 = device0.createCommandEncoder({});
let textureView90 = texture72.createView({baseMipLevel: 0, arrayLayerCount: 1});
let texture76 = device0.createTexture({size: [1560, 96, 1], format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
let texture77 = gpuCanvasContext2.getCurrentTexture();
try {
renderPassEncoder3.setBindGroup(3, bindGroup14, [0]);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(0, buffer59, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer58, 16, new Float32Array(9975).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.277)), 2572, 12);
} catch {}
let pipeline13 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 508,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 208, shaderLocation: 8},
          {format: 'uint32x2', offset: 24, shaderLocation: 0},
          {format: 'unorm16x2', offset: 60, shaderLocation: 7},
          {format: 'uint8x4', offset: 228, shaderLocation: 9},
          {format: 'uint32x4', offset: 0, shaderLocation: 1},
          {format: 'snorm16x2', offset: 128, shaderLocation: 3},
          {format: 'snorm16x4', offset: 300, shaderLocation: 4},
          {format: 'snorm16x4', offset: 68, shaderLocation: 2},
          {format: 'unorm8x2', offset: 58, shaderLocation: 14},
          {format: 'uint32x3', offset: 24, shaderLocation: 6},
        ],
      },
      {arrayStride: 4, attributes: [{format: 'snorm8x4', offset: 0, shaderLocation: 12}]},
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'back'},
});
let textureView91 = texture47.createView({dimension: '2d-array'});
try {
computePassEncoder1.setBindGroup(3, bindGroup14, new Uint32Array(992), 433, 1);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup6, new Uint32Array(1392), 350, 1);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer74, 'uint32', 28, 11);
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'iec6196624'} });
let textureView92 = texture41.createView({format: 'r16sint'});
try {
renderPassEncoder6.setVertexBuffer(0, buffer35, 8, 39);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(3, buffer5);
} catch {}
try {
commandEncoder31.copyTextureToBuffer({
  texture: texture67,
  mipLevel: 0,
  origin: {x: 758, y: 6, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 352 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1744 */
  offset: 1744,
  bytesPerRow: 49408,
  buffer: buffer11,
}, {width: 22, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder15.insertDebugMarker('\u5d4f');
} catch {}
let commandEncoder57 = device0.createCommandEncoder({});
let textureView93 = texture45.createView({arrayLayerCount: 1});
try {
computePassEncoder6.setBindGroup(2, bindGroup18, new Uint32Array(3395), 1_489, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer9, 'uint32', 40, 37);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(4, buffer68, 64, 4);
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1492 */
  offset: 1492,
  buffer: buffer11,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer76 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
try {
renderPassEncoder9.setVertexBuffer(0, buffer5, 0, 64);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup13, new Uint32Array(1498), 79, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
texture63.label = '\u2f93\u{1fdb5}\ua6e4\ud7ab\ub2a0';
} catch {}
let commandEncoder58 = device0.createCommandEncoder({});
try {
renderPassEncoder10.setVertexBuffer(3, buffer62, 0);
} catch {}
try {
commandEncoder36.resolveQuerySet(querySet0, 98, 0, buffer71, 0);
} catch {}
let commandEncoder59 = device0.createCommandEncoder({});
let textureView94 = texture33.createView({mipLevelCount: 1});
let renderPassEncoder11 = commandEncoder54.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  depthSlice: 1,
  clearValue: { r: -18.34, g: -399.5, b: -427.2, a: 416.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 249163384,
});
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(140); };
} catch {}
document.body.prepend(canvas1);
let bindGroup31 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer73}}],
});
let textureView95 = texture51.createView({baseArrayLayer: 0, arrayLayerCount: 6});
try {
renderPassEncoder4.setBindGroup(0, bindGroup26, new Uint32Array(13), 0, 1);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(0, buffer59, 0, 0);
} catch {}
try {
buffer71.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer38, 0, new Float16Array(18500).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.699)), 5443, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 1,
  origin: {x: 46, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(35).fill(27), /* required buffer size: 35 */
{offset: 35}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder60 = device0.createCommandEncoder({});
let texture78 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 31},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg8sint'],
});
try {
computePassEncoder7.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer19, 0, 25);
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup3, new Uint32Array(3104), 326, 1);
} catch {}
try {
buffer62.unmap();
} catch {}
let imageData9 = new ImageData(64, 52);
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470m', transfer: 'smpteSt4281'} });
try {
adapter0.label = '\u7416\u{1f709}\u8e8d\u086a\uf4ea\u622d\u0011\u0f20\uda3e\u03cb';
} catch {}
let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], sampleCount: 1, depthReadOnly: true});
try {
computePassEncoder1.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup4, [0]);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(4, buffer5, 0, 21);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(2, buffer68, 0, 24);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder31.insertDebugMarker('\u8655');
} catch {}
let commandEncoder61 = device0.createCommandEncoder({});
try {
renderBundleEncoder20.setIndexBuffer(buffer19, 'uint32', 8, 23);
} catch {}
let commandEncoder62 = device0.createCommandEncoder({});
let textureView96 = texture78.createView({dimension: '3d', baseMipLevel: 0});
let renderPassEncoder12 = commandEncoder52.beginRenderPass({
  colorAttachments: [{
  view: textureView96,
  depthSlice: 14,
  clearValue: { r: 484.2, g: 192.0, b: -887.8, a: -33.41, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 237},
});
let sampler14 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', minFilter: 'nearest', lodMaxClamp: 92.48});
try {
renderPassEncoder3.setBindGroup(1, bindGroup9, []);
} catch {}
let videoFrame11 = videoFrame1.clone();
let textureView97 = texture67.createView({aspect: 'all'});
let textureView98 = texture33.createView({aspect: 'all'});
let externalTexture20 = device0.importExternalTexture({source: videoFrame1});
try {
renderPassEncoder0.setIndexBuffer(buffer69, 'uint32', 44, 3);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup16, new Uint32Array(927), 178, 0);
} catch {}
try {
  await buffer67.mapAsync(GPUMapMode.READ, 56, 20);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 152, new Uint32Array(2761).map((_, i) => i * 5), 1450, 44);
} catch {}
document.body.prepend(canvas1);
let textureView99 = texture65.createView({});
try {
renderPassEncoder6.setVertexBuffer(5, buffer68);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(1, buffer62, 0, 2);
} catch {}
let buffer77 = device0.createBuffer({size: 176, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, mappedAtCreation: false});
let textureView100 = texture67.createView({});
try {
computePassEncoder4.setBindGroup(1, bindGroup15, [0]);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer35, 8, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 92, new Float32Array(1843).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.8940)), 96, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 7, y: 19, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 3, depthOrArrayLayers: 0});
} catch {}
await gc();
let buffer78 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder18.setBindGroup(3, bindGroup9);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer38, 'uint16', 40, 0);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup30, new Uint32Array(596), 209, 0);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(0, buffer71, 0, 10);
} catch {}
try {
device0.queue.writeBuffer(buffer63, 4, new BigInt64Array(622).map((_, i) => BigInt(i - 0)), 206, 0);
} catch {}
let bindGroup32 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer73}}],
});
let textureView101 = texture41.createView({mipLevelCount: 1});
try {
renderPassEncoder0.setVertexBuffer(3, buffer59);
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup7, new Uint32Array(811), 46, 1);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer63, 'uint16', 76, 40);
} catch {}
try {
buffer78.unmap();
} catch {}
let bindGroup33 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 58, resource: {buffer: buffer21, size: 1036}}, {binding: 6, resource: {buffer: buffer60}}],
});
try {
renderPassEncoder6.setStencilReference(0);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer63, 'uint16', 114, 11);
} catch {}
try {
commandEncoder53.copyBufferToTexture({
  /* bytesInLastRow: 84 widthInBlocks: 42 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 850 */
  offset: 850,
  bytesPerRow: 11776,
  buffer: buffer11,
}, {
  texture: texture15,
  mipLevel: 1,
  origin: {x: 31, y: 1, z: 0},
  aspect: 'all',
}, {width: 42, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer78, 0, new Float32Array(9854).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.463)), 239, 0);
} catch {}
let bindGroup34 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 43, resource: {buffer: buffer4}},
    {binding: 58, resource: {buffer: buffer37}},
    {binding: 3, resource: textureView17},
    {binding: 6, resource: {buffer: buffer20, offset: 0}},
  ],
});
let commandEncoder63 = device0.createCommandEncoder();
try {
renderPassEncoder3.setVertexBuffer(4, buffer8, 20);
} catch {}
try {
adapter0.label = '\u{1fb0f}\u{1fed8}\u1334\u08b9\uab64\u{1f788}\u{1fc54}\u{1f712}';
} catch {}
let autogeneratedBindGroupLayout5 = pipeline0.getBindGroupLayout(1);
let sampler15 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 79.10, maxAnisotropy: 1});
try {
renderPassEncoder12.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder10.setBindGroup(3, bindGroup32, new Uint32Array(178), 7, 0);
} catch {}
try {
commandEncoder32.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 0 */
  offset: 0,
  rowsPerImage: 265,
  buffer: buffer8,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup35 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 1, resource: externalTexture1}, {binding: 3, resource: textureView3}],
});
let textureView102 = texture40.createView({baseMipLevel: 0});
let computePassEncoder20 = commandEncoder48.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 356}});
let sampler16 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 73.78,
  maxAnisotropy: 5,
});
try {
renderPassEncoder2.setBindGroup(2, bindGroup7, [0]);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer19, 0, 5);
} catch {}
let bindGroup36 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 6, resource: {buffer: buffer22}},
    {binding: 43, resource: {buffer: buffer51}},
    {binding: 3, resource: textureView0},
    {binding: 58, resource: {buffer: buffer21, size: 800}},
  ],
});
let buffer79 = device0.createBuffer({size: 132, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM, mappedAtCreation: false});
try {
computePassEncoder20.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup13);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer1, 'uint16', 16, 67);
} catch {}
document.body.prepend(img2);
let texture79 = device0.createTexture({
  size: [16, 24, 4],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder12.setBindGroup(1, bindGroup25, new Uint32Array(977), 102, 1);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(2, buffer68, 0);
} catch {}
try {
commandEncoder44.clearBuffer(buffer2, 8, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer75, 8, new Uint32Array(9483).map((_, i) => i * 1), 629, 4);
} catch {}
let buffer80 = device0.createBuffer({
  size: 108,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder64 = device0.createCommandEncoder({});
let textureView103 = texture79.createView({});
try {
renderPassEncoder11.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer65, 'uint32', 8, 2);
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
let imageData10 = new ImageData(72, 8);
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32float', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 11,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 12,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 81, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 86, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 106,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 125,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 141,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 148,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 152,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 166,
      visibility: 0,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 220,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 251,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer81 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder65 = device0.createCommandEncoder({});
let textureView104 = texture50.createView({dimension: '2d-array'});
let externalTexture21 = device0.importExternalTexture({source: videoFrame8});
try {
renderBundleEncoder5.setBindGroup(0, bindGroup35);
} catch {}
try {
renderBundleEncoder5.drawIndexed(5, 0, 1, -1_939_803_733);
} catch {}
let bindGroup37 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture3}, {binding: 3, resource: textureView17}],
});
let buffer82 = device0.createBuffer({
  size: 120,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture80 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 2},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder10.setBindGroup(0, bindGroup36, [0]);
} catch {}
try {
device0.queue.writeBuffer(buffer76, 76, new Float32Array(27144).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.332)), 9499, 0);
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

enable f16;

var<workgroup> vw8: vec2h;

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

struct T6 {
  @size(160) f0: f16,
  f1: array<atomic<u32>>,
}

@id(5373) override override7: bool;

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

struct VertexInput28 {
  @location(9) location_9: f16,
}

struct T2 {
  f0: array<vec2f>,
}

struct VertexInput29 {
  @location(15) location_15: vec4i,
  @location(13) @interpolate(linear, either) location_13: vec2h,
}

override override5: f16 = 12869.2;

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

@group(2) @binding(711) var sam3: sampler;

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

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

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

@group(0) @binding(138) var st6: texture_storage_2d<r32uint, read_write>;

struct T4 {
  @size(352) f0: vec2<bool>,
  @size(64) f1: vec4<bool>,
}

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

override override9: f32;

@group(1) @binding(176) var<storage, read_write> buffer84: array<array<array<VertexInput28, 5>, 1>, 160>;

struct VertexOutput4 {
  @location(4) location_4: f16,
  @location(14) location_14: i32,
  @location(10) location_10: vec2u,
  @location(8) location_8: i32,
  @location(11) location_11: vec4h,
  @location(7) @interpolate(linear) location_7: f16,
  @location(5) @interpolate(flat, center) location_5: vec4u,
  @builtin(position) position: vec4f,
  @location(12) @interpolate(flat, centroid) location_12: vec2u,
  @location(1) location_1: i32,
  @location(9) @interpolate(perspective, sample) location_9: vec2h,
  @location(3) @interpolate(flat, sample) location_3: vec2i,
  @location(13) @interpolate(flat, either) location_13: i32,
}

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

@id(60452) override override6: bool;

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

var<workgroup> vw6: atomic<u32>;

struct VertexInput22 {
  @location(0) @interpolate(flat, sample) location_0: vec4u,
  @location(10) @interpolate(flat, first) location_10: u32,
  @location(13) @interpolate(flat) location_13: u32,
}

var<workgroup> vw7: array<vec2<bool>, 4>;

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

@id(45504) override override8: bool;

struct VertexInput27 {
  @location(6) @interpolate(flat) location_6: vec2h,
}

struct VertexInput30 {
  @location(4) @interpolate(perspective, center) location_4: vec4h,
}

@group(2) @binding(47) var tex6: texture_2d<f32>;

@group(2) @binding(241) var<storage, read_write> buffer86: array<array<array<array<array<array<VertexInput28, 1>, 13>, 1>, 8>, 2>>;

struct VertexInput24 {
  @location(12) @interpolate(linear, first) location_12: f32,
}

struct T5 {
  @size(1536) f0: vec4<bool>,
  @size(384) f1: array<vec2<bool>, 24>,
}

struct VertexInput23 {
  @location(7) @interpolate(flat) location_7: u32,
  @location(2) @interpolate(flat) location_2: u32,
  @location(4) @interpolate(flat, centroid) location_4: vec2i,
}

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

alias vec3b = vec3<bool>;

@group(1) @binding(0) var<storage, read_write> buffer83: array<VertexInput23>;

struct VertexInput26 {
  @location(15) @interpolate(linear, sample) location_15: vec4h,
}

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

/* used global variables: et7, et8, sam3, tex6 */
@vertex
fn vertex5(a0: VertexInput22, @location(14) location_14: vec4i, a2: VertexInput23, a3: VertexInput24, @location(11) location_11: vec2h, @location(9) location_9: vec2h, a6: VertexInput25, @location(3) @interpolate(flat, first) location_3: vec4u, @builtin(instance_index) instance_index: u32, @location(5) location_5: vec2h, a10: VertexInput26, @location(1) @interpolate(linear) location_1: f16, a12: VertexInput27, @location(8) @interpolate(perspective, first) location_8: f16) -> VertexOutput4 {
  var out: VertexOutput4;
  out.location_8 = vec4i(textureGather(520051819 % 4, tex6, sam3, vec2f(unconst_f32(0.00608), unconst_f32(0.3332)), clamp(vec2i(205989543, -688854755), vec2i(-8), vec2i(7))).yxww.wzzz.rgrb.wwwx)[1];
  let vf54: vec4f = textureSampleBaseClampToEdge(et8, sam3, vec2f(unconst_f32(0.6956e-5), unconst_f32(0.4037e-39)));
  out.location_3 *= vec2i(bitcast<i32>(a3.location_12));
  var vf55: vec2h = location_11;
  while bool(out.location_9[1]) {
  out.location_12 -= vec2u(abs(textureDimensions(et7)[0]));
  out.location_8 |= out.location_3[unconst_u32(1574242734)];
  for (var it3=out.location_5[unconst_u32(1125836571)]; it3<(a0.location_10 & 0xfff); it3++) {
  var vf56: u32 = a2.location_7;
  break;
}
  out = VertexOutput4(f16(a0.location_13), bitcast<i32>(a0.location_13), vec2u(a0.location_13), i32(a0.location_13), vec4h(f16(a0.location_13)), f16(a0.location_13), unpack4xU8(a0.location_13), unpack4x8snorm(a0.location_13), vec2u(a0.location_13), bitcast<i32>(a0.location_13), bitcast<vec2h>(a0.location_13), vec2i(bitcast<i32>(a0.location_13)), i32(a0.location_13));
  let ptr20: ptr<function, vec2u> = &out.location_10;
  out.location_7 = vec2h(out.location_10.yx.yx)[1];
  return out;
  _ = et7;
}
  out.position = unpack4x8unorm(location_3[unconst_u32(1294634619)]);
  out = VertexOutput4(f16(a0.location_13), i32(a0.location_13), vec2u(a0.location_13), i32(a0.location_13), vec4h(f16(a0.location_13)), f16(a0.location_13), unpack4xU8(a0.location_13), unpack4x8unorm(a0.location_13), vec2u(a0.location_13), i32(a0.location_13), bitcast<vec2h>(a0.location_13), vec2i(i32(a0.location_13)), i32(a0.location_13));
  out.location_4 = out.location_7;
  out.location_10 = vec2u(a12.location_6.yx);
  out.location_12 = vec2u(a0.location_10);
  return out;
  _ = tex6;
  _ = et8;
  _ = et7;
  _ = sam3;
}

/* zero global variables used */
@vertex
fn vertex6(a0: VertexInput28, @location(12) @interpolate(flat, center) location_12: u32, a2: VertexInput29, a3: VertexInput30) -> VertexOutput5 {
  var out: VertexOutput5;
  var vf57: vec2f = step(vec2f(unconst_f32(0.01713e-1), unconst_f32(-0.07758)), vec2f(unconst_f32(0.01395), unconst_f32(0.4488e-17)));
  let vf58: f16 = determinant(mat3x3h(unconst_f16(657.7), unconst_f16(1764.9), unconst_f16(11391.3), unconst_f16(7314.1), unconst_f16(11537.9), unconst_f16(3050.1), unconst_f16(2642.9), unconst_f16(71.42), unconst_f16(4712.7)));
  return out;
}

/* used global variables: buffer84, buffer86, st6 */
@fragment
fn fragment5() -> @location(200) @interpolate(perspective, either) vec2i {
  var out: vec2i;
  let ptr21: ptr<storage, array<VertexInput28, 5>, read_write> = &buffer84[159][unconst_u32(104075828)];
  textureStore(st6, vec2i(unconst_i32(481266918), unconst_i32(197546800)), vec4u(vec4u(unconst_u32(88221229), unconst_u32(246347021), unconst_u32(1094595735), unconst_u32(262094236))));
  while bool((*&buffer84)[unconst_u32(1125329435)][unconst_u32(451870526)][unconst_u32(255206263)].location_9) {
  let ptr22: ptr<storage, f16, read_write> = &(*&buffer86)[unconst_u32(301394400)][1][unconst_u32(1478187037)][0][12][unconst_u32(1329135521)].location_9;
  let ptr23: ptr<storage, array<VertexInput28, 1>, read_write> = &(*&buffer86)[arrayLength(&(*&buffer86))][1][7][unconst_u32(1138626825)][12];
  while bool(buffer86[u32(buffer86[arrayLength(&buffer86)][1][7][0][12][0].location_9)][unconst_u32(2319867523)][unconst_u32(610593127)][0][12][unconst_u32(212665267)].location_9) {
  let ptr24: ptr<storage, array<array<array<VertexInput28, 1>, 13>, 1>, read_write> = &buffer86[unconst_u32(8469300)][1][unconst_u32(945370215)];
  let ptr25: ptr<storage, VertexInput28, read_write> = &buffer86[arrayLength(&buffer86)][1][7][0][unconst_u32(340249015)][unconst_u32(255795274)];
  return out;
  _ = buffer86;
}
  _ = buffer86;
}
  let ptr26: ptr<storage, f16, read_write> = &buffer84[unconst_u32(414464026)][0][4].location_9;
  let ptr27: ptr<storage, VertexInput28, read_write> = &(*&buffer86)[arrayLength(&(*&buffer86))][unconst_u32(388950301)][unconst_u32(68184366)][0][12][0];
  return out;
  _ = buffer86;
  _ = buffer84;
  _ = st6;
}

/* used global variables: buffer83, buffer84 */
@compute @workgroup_size(1, 1, 1)
fn compute5(@builtin(num_workgroups) num_workgroups: vec3u, @builtin(workgroup_id) workgroup_id: vec3u) {
  buffer83[unconst_u32(1356676135)].location_7 ^= u32(buffer84[unconst_u32(1516344082)][0][4].location_9);
  let ptr28: ptr<workgroup, array<vec2<bool>, 4>> = &vw7;
  let vf59: bool = override7;
  let vf60: f32 = determinant(mat3x3f(f32(override5), f32(override5), f32(override5), f32(override5), f32(override5), f32(override5), f32(override5), f32(override5), f32(override5)));
  vw8 += vec2h(buffer84[unconst_u32(404786200)][unconst_u32(1462778086)][4].location_9);
  _ = override7;
  _ = override5;
  _ = buffer83;
  _ = buffer84;
}`,
});
let bindGroup38 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 138, resource: textureView13},
    {binding: 0, resource: externalTexture6},
    {binding: 1, resource: externalTexture4},
  ],
});
let commandEncoder66 = device0.createCommandEncoder({});
let textureView105 = texture80.createView({});
let texture81 = device0.createTexture({size: [780, 48, 1], mipLevelCount: 2, format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
try {
renderBundleEncoder5.drawIndexed(2, 0, 2, -1_553_004_132);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(1, buffer43, 0, 7);
} catch {}
try {
buffer46.unmap();
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
document.body.append(canvas0);
let sampler17 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 57.41,
  maxAnisotropy: 8,
});
try {
renderBundleEncoder5.drawIndirect(buffer35, 20);
} catch {}
try {
buffer60.unmap();
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let texture82 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 68},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView106 = texture12.createView({mipLevelCount: 1});
try {
computePassEncoder17.setBindGroup(2, bindGroup13);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer55, 'uint32', 7_744, 1_165);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer77);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(5, buffer8, 56, 0);
} catch {}
let commandEncoder68 = device0.createCommandEncoder({});
try {
renderBundleEncoder21.setBindGroup(0, bindGroup10, [0]);
} catch {}
try {
renderBundleEncoder5.drawIndexedIndirect(buffer39, 80);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(0, buffer62, 0);
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\u966e');
} catch {}
try {
device0.queue.writeBuffer(buffer63, 108, new DataView(new Uint8Array(1925).map((_, i) => i).buffer), 688, 32);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 1,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(97).fill(89), /* required buffer size: 97 */
{offset: 97}, {width: 111, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder69 = device0.createCommandEncoder({});
try {
renderBundleEncoder20.setBindGroup(2, bindGroup33);
} catch {}
try {
commandEncoder34.clearBuffer(buffer67);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
let canvas2 = document.createElement('canvas');
let buffer89 = device0.createBuffer({size: 381, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let textureView107 = texture52.createView({dimension: '2d', baseArrayLayer: 5});
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, stencilReadOnly: true});
try {
renderBundleEncoder19.setBindGroup(1, bindGroup5, new Uint32Array(977), 4, 1);
} catch {}
try {
renderBundleEncoder5.draw(290, 0, 96_329_683);
} catch {}
try {
renderBundleEncoder5.drawIndexed(2, 0, 0, 63_099_126);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer65, 'uint16', 6, 6);
} catch {}
let buffer90 = device0.createBuffer({
  size: 477,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView108 = texture47.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder14.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer43, 8, 1);
} catch {}
try {
commandEncoder65.copyTextureToTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 67, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture56,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt470bg', transfer: 'bt2020_10bit'} });
let videoFrame13 = videoFrame10.clone();
let textureView109 = texture15.createView({dimension: '2d-array', aspect: 'all', format: 'r16sint', mipLevelCount: 1});
try {
computePassEncoder15.setBindGroup(0, bindGroup11, [0]);
} catch {}
let gpuCanvasContext6 = canvas2.getContext('webgpu');
document.body.append(canvas0);
try {
globalThis.someLabel = externalTexture12.label;
} catch {}
let buffer91 = device0.createBuffer({size: 12632, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder70 = device0.createCommandEncoder();
let texture83 = gpuCanvasContext1.getCurrentTexture();
let renderPassEncoder13 = commandEncoder32.beginRenderPass({
  label: '\u0305\u0a15\uf144',
  colorAttachments: [{
  view: textureView61,
  depthSlice: 0,
  clearValue: { r: -676.7, g: 267.3, b: -323.1, a: -673.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet0},
});
try {
renderPassEncoder6.setBindGroup(0, bindGroup36, new Uint32Array(106), 31, 1);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer89);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer38, 'uint16', 4, 27);
} catch {}
let pipeline14 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule2, entryPoint: 'fragment1', targets: [{format: 'r16sint'}]},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 0, shaderLocation: 6},
          {format: 'uint8x2', offset: 8, shaderLocation: 14},
          {format: 'uint32x2', offset: 0, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let img4 = await imageWithData(158, 25, '#10101010', '#20202020');
let bindGroup39 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 6, resource: {buffer: buffer37}}, {binding: 58, resource: {buffer: buffer37}}],
});
let textureView110 = texture34.createView({});
try {
computePassEncoder11.setBindGroup(3, bindGroup30, new Uint32Array(1988), 714, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer38, 'uint16', 42, 1);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer55, 'uint32', 1_112, 111);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline14);
} catch {}
let canvas3 = document.createElement('canvas');
let renderBundle0 = renderBundleEncoder5.finish({});
let externalTexture22 = device0.importExternalTexture({source: videoFrame6});
try {
computePassEncoder8.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer9, 'uint16', 24, 3);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer52, 'uint32', 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer76, 8, new Uint32Array(8529).map((_, i) => i * 7), 175, 8);
} catch {}
let imageData11 = new ImageData(48, 12);
let textureView111 = texture78.createView({format: 'rg8sint'});
try {
renderPassEncoder5.setBindGroup(3, bindGroup22, [0]);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(3, buffer59, 16);
} catch {}
try {
commandEncoder64.pushDebugGroup('\u{1f685}');
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer2, 0, new Float32Array(16410).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.256)), 303, 0);
} catch {}
try {
  await promise9;
} catch {}
let buffer92 = device0.createBuffer({size: 160, usage: GPUBufferUsage.VERTEX});
let commandEncoder71 = device0.createCommandEncoder();
try {
renderPassEncoder9.setVertexBuffer(1, buffer68, 116, 2);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(4, buffer19, 28, 8);
} catch {}
try {
commandEncoder36.resolveQuerySet(querySet0, 5, 0, buffer8, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
adapter0.label = '\u{1f990}\uae32\ue375\u93ba';
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer77, 0, 36);
} catch {}
try {
commandEncoder57.resolveQuerySet(querySet0, 3, 0, buffer36, 0);
} catch {}
let imageData12 = new ImageData(24, 8);
let buffer93 = device0.createBuffer({size: 132, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder72 = device0.createCommandEncoder({});
let computePassEncoder21 = commandEncoder55.beginComputePass();
try {
computePassEncoder20.setBindGroup(1, bindGroup0, new Uint32Array(506), 121, 0);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup39, new Uint32Array(2108), 656, 0);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer35, 24, 17);
} catch {}
let arrayBuffer4 = buffer44.getMappedRange(24, 0);
try {
commandEncoder64.popDebugGroup();
} catch {}
let buffer94 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
try {
renderBundleEncoder8.setVertexBuffer(2, buffer35);
} catch {}
try {
commandEncoder72.resolveQuerySet(querySet0, 10, 11, buffer76, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 46, y: 11, z: 0},
  aspect: 'all',
}, new Uint8Array(77).fill(156), /* required buffer size: 77 */
{offset: 77, bytesPerRow: 153}, {width: 22, height: 4, depthOrArrayLayers: 0});
} catch {}
let texture84 = device0.createTexture({
  size: [390, 240, 19],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture85 = device0.createTexture({
  size: [8, 12, 7],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder5.setIndexBuffer(buffer93, 'uint16', 36, 7);
} catch {}
await gc();
let commandEncoder73 = device0.createCommandEncoder({});
let texture86 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 2},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView112 = texture34.createView({aspect: 'all', arrayLayerCount: 1});
try {
renderPassEncoder6.setStencilReference(1486);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer38, 'uint32', 0, 5);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let gpuCanvasContext7 = canvas3.getContext('webgpu');
await gc();
try {
globalThis.someLabel = commandEncoder4.label;
} catch {}
let bindGroup40 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 10, resource: {buffer: buffer34}}]});
let buffer95 = device0.createBuffer({size: 188, usage: GPUBufferUsage.COPY_SRC});
try {
renderBundleEncoder10.setIndexBuffer(buffer38, 'uint16', 42, 4);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup11, new Uint32Array(174), 2, 1);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer19, 'uint32', 32, 17);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(7, buffer59, 0, 12);
} catch {}
let pipeline15 = await device0.createComputePipelineAsync({label: '\uf277\u0aa3', layout: 'auto', compute: {module: shaderModule3, constants: {}}});
let offscreenCanvas4 = new OffscreenCanvas(60, 338);
let texture87 = device0.createTexture({
  size: {width: 16, height: 24, depthOrArrayLayers: 42},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView113 = texture32.createView({dimension: '1d', baseArrayLayer: 0});
try {
renderPassEncoder0.setVertexBuffer(0, buffer43, 4, 21);
} catch {}
try {
commandEncoder70.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 404 */
  offset: 404,
  bytesPerRow: 5120,
  buffer: buffer11,
}, {
  texture: texture56,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {width: 1, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer38, 4, new BigInt64Array(34030).map((_, i) => BigInt(i - 8)), 6512, 0);
} catch {}
let buffer96 = device0.createBuffer({size: 400, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
try {
renderPassEncoder3.setVertexBuffer(2, buffer35);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer1, 'uint32', 8, 24);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(5, buffer19);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer63, 'uint16', 104, 17);
} catch {}
document.body.append(canvas2);
let commandEncoder74 = device0.createCommandEncoder();
try {
renderPassEncoder11.setIndexBuffer(buffer65, 'uint16', 0, 2);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup35);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup35, new Uint32Array(2882), 44, 0);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline14);
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

struct VertexOutput6 {
  @location(8) location_8: f16,
  @location(13) location_13: f32,
  @location(5) @interpolate(flat, either) location_5: f32,
  @builtin(position) position: vec4f,
  @location(6) @interpolate(flat, first) location_6: f16,
  @location(4) location_4: i32,
  @location(1) location_1: vec2h,
  @location(2) @interpolate(flat, center) location_2: i32,
  @location(10) location_10: i32,
  @location(9) location_9: vec4f,
}

override override15: f32;

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

override override20 = -90022044;

struct VertexInput32 {
  @location(13) location_13: f32,
}

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

@id(37735) override override11 = 0.05001e0;

@id(40391) override override12 = -0.6008e-11;

override override18: f16;

struct VertexInput31 {
  @location(4) @interpolate(perspective, center) location_4: vec2h,
  @location(5) @interpolate(flat) location_5: vec2h,
}

@id(61507) override override10 = true;

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

struct VertexInput33 {
  @location(3) @interpolate(flat, center) location_3: vec4u,
}

struct VertexInput35 {
  @location(11) @interpolate(flat, centroid) location_11: u32,
}

@id(23510) override override17 = -828380792;

override override13: f32;

@group(0) @binding(58) var<storage, read_write> buffer99: array<array<array<f16, 3>, 96>>;

@id(43184) override override19 = 0.1538;

struct VertexInput36 {
  @location(10) location_10: vec2h,
}

struct FragmentInput7 {
  @location(3) @interpolate(linear, sample) location_3: vec2f,
  @location(7) @interpolate(flat, sample) location_7: vec2f,
}

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

struct T2 {
  f0: vec2u,
}

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

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

@id(27232) override override16: bool;

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

struct T0 {
  @size(104) f0: array<array<vec4f, 3>, 2>,
}

struct T1 {
  @align(32) @size(704) f0: vec4f,
  @align(32) @size(256) f1: T0,
  @align(32) @size(96) f2: vec2i,
  @size(32) f3: bool,
  @align(32) @size(128) f4: T0,
  @size(96) f5: array<u32, 1>,
}

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

/* zero global variables used */
fn fn0(a0: ptr<function, f16>) -> array<vec4h, 1> {
  var out: array<vec4h, 1>;
  var vf61: f16 = out[unconst_u32(358505797)][unconst_u32(2769330252)];
  (*a0) = f16(override20);
  let vf62: f16 = override18;
  let vf63: vec3f = ldexp(vec3f(unconst_f32(0.08511), unconst_f32(0.06441e2), unconst_f32(0.2193e-14)), vec3i(unconst_i32(201605753), unconst_i32(294243036), unconst_i32(237877818)));
  return out;
  _ = override20;
  _ = override18;
}

struct T4 {
  f0: array<vec2h>,
}

struct FragmentInput9 {
  @location(1) location_1: vec4h,
}

struct VertexInput34 {
  @location(14) @interpolate(linear, first) location_14: vec2f,
}

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

override override14: i32;

/* zero global variables used */
@vertex
fn vertex7(@location(12) location_12: f32, a1: VertexInput31, a2: VertexInput32, a3: VertexInput33, @location(0) location_0: vec4f, @location(7) location_7: u32, a6: VertexInput34, @location(15) @interpolate(flat) location_15: vec4i, @location(8) @interpolate(linear, either) location_8: vec2h, a9: VertexInput35, @location(9) location_9: u32, a11: VertexInput36, @location(6) @interpolate(flat, either) location_6: vec4i) -> VertexOutput6 {
  var out: VertexOutput6;
  _ = fn0(&out.location_8);
  let vf64: u32 = a9.location_11;
  out.location_8 *= f16(vf64);
  fn0(&out.location_6);
  let vf65: f32 = location_0[unconst_u32(30055204)];
  var vf66 = fn0(&out.location_8);
  return out;
  _ = override20;
  _ = override18;
}

/* zero global variables used */
@fragment
fn fragment6(@location(5) location_5: u32, a1: FragmentInput7, @builtin(sample_mask) sample_mask: u32, a3: FragmentInput8, a4: FragmentInput9) -> FragmentOutput3 {
  var out: FragmentOutput3;
  return out;
}

/* used global variables: buffer99 */
@compute @workgroup_size(1, 1, 1)
fn compute6(a0: ComputeInput6) {
  let ptr29: ptr<storage, array<f16, 3>, read_write> = &buffer99[unconst_u32(309593765)][unconst_u32(457073364)];
  buffer99[unconst_u32(669067889)][unconst_u32(2661272868)][unconst_u32(924326631)] *= buffer99[unconst_u32(439496372)][95][2];
  let ptr30: ptr<storage, array<array<f16, 3>, 96>, read_write> = &buffer99[unconst_u32(429784834)];
  storageBarrier();
  workgroupBarrier();
  for (var jj44=0u; jj44<5; jj44++) { buffer99[unconst_u32(753062941)][unconst_u32(956432140)][jj44] = buffer99[unconst_u32(1131083076)][unconst_u32(112248195)][2]; }
  var vf67: vec2u = (vec2u(unconst_u32(424127910), unconst_u32(480718399)) | vec2u(unconst_u32(36627551), unconst_u32(678941131)));
  _ = buffer99;
}`,
});
let commandEncoder75 = device0.createCommandEncoder({});
try {
computePassEncoder13.setBindGroup(0, bindGroup7, [0]);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer53, 'uint16');
} catch {}
try {
renderBundleEncoder3.setBindGroup(3, bindGroup1);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup15, new Uint32Array(380), 47, 1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 24, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext8 = offscreenCanvas4.getContext('webgpu');
let commandEncoder76 = device0.createCommandEncoder();
let sampler18 = device0.createSampler({addressModeW: 'mirror-repeat'});
try {
computePassEncoder20.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup9, new Uint32Array(4795), 689, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer78, 4, new Uint16Array(11327).map((_, i) => i + 10), 654, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas2,
  origin: { x: 3, y: 89 },
  flipY: false,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 5, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img3);
let texture88 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 32},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder7.setBindGroup(1, bindGroup32);
} catch {}
try {
renderBundleEncoder8.drawIndexed(2, 0, 0, 52_783_199);
} catch {}
try {
renderBundleEncoder8.drawIndexedIndirect(buffer55, 1_652);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: canvas2,
  origin: { x: 8, y: 23 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 207, height: 5, depthOrArrayLayers: 0});
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
let texture89 = device0.createTexture({size: [8, 12, 2], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC});
let textureView114 = texture6.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
let renderBundle1 = renderBundleEncoder8.finish({});
let externalTexture23 = device0.importExternalTexture({source: videoFrame9});
try {
computePassEncoder17.setBindGroup(3, bindGroup10, [0]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer71, 28, 8);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new Uint32Array(25106).map((_, i) => i * 3), 3065, 0);
} catch {}
let commandEncoder78 = device0.createCommandEncoder({});
let textureView115 = texture25.createView({baseMipLevel: 2, mipLevelCount: 1});
let textureView116 = texture2.createView({dimension: '2d-array'});
let textureView117 = texture57.createView({});
try {
renderBundleEncoder6.setPipeline(pipeline13);
} catch {}
let imageData13 = new ImageData(108, 28);
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470bg', transfer: 'unspecified'} });
let textureView118 = texture50.createView({});
try {
renderPassEncoder1.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline14);
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 178 */
  offset: 178,
  bytesPerRow: 69632,
  buffer: buffer96,
}, {
  texture: texture55,
  mipLevel: 2,
  origin: {x: 48, y: 20, z: 0},
  aspect: 'all',
}, {width: 5, height: 37, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer58, 28, new Float32Array(2197).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.206)), 227, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise11;
} catch {}
let autogeneratedBindGroupLayout6 = pipeline12.getBindGroupLayout(0);
let bindGroup41 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 10, resource: {buffer: buffer66}}]});
try {
renderPassEncoder4.setBindGroup(3, bindGroup12, new Uint32Array(762), 210, 0);
} catch {}
try {
renderPassEncoder0.setStencilReference(642);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer65, 'uint32', 0, 7);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer35, 0, 23);
} catch {}
let arrayBuffer5 = buffer67.getMappedRange(56, 8);
document.body.append(img2);
let buffer100 = device0.createBuffer({size: 236, usage: GPUBufferUsage.INDEX});
let textureView119 = texture50.createView({dimension: '2d-array'});
try {
buffer2.unmap();
} catch {}
try {
commandEncoder47.resolveQuerySet(querySet0, 275, 0, buffer8, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData7,
  origin: { x: 2, y: 3 },
  flipY: false,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 8, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas2);
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpteRp431', transfer: 'bt709'} });
try {
renderPassEncoder10.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup36, new Uint32Array(1772), 149, 1);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(27); };
} catch {}
let commandEncoder79 = device0.createCommandEncoder({});
try {
computePassEncoder21.setBindGroup(0, bindGroup29);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer60, 'uint32', 32, 25);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer38, 8, new DataView(new Uint8Array(329).map((_, i) => i).buffer), 66, 12);
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470bg', transfer: 'gamma22curve'} });
let textureView120 = texture81.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1});
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer19, 'uint16', 2);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline5);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer91, 3_320, new Float32Array(2).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.05424)));
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas4,
  origin: { x: 4, y: 20 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 78, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 7, depthOrArrayLayers: 0});
} catch {}
let texture90 = device0.createTexture({
  size: [8],
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView121 = texture9.createView({mipLevelCount: 1});
try {
renderBundleEncoder23.setVertexBuffer(0, buffer62, 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer56, 2_164, new BigInt64Array(5947).map((_, i) => BigInt(i - 9)), 1037, 12);
} catch {}
let texture91 = device0.createTexture({size: [32], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView122 = texture55.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder15.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder20.setBindGroup(0, bindGroup12, new Uint32Array(3319), 107, 0);
} catch {}
let pipeline16 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x51cf104},
  fragment: {module: shaderModule6, constants: {}, targets: [{format: 'r16sint'}]},
  vertex: {
    module: shaderModule6,
    entryPoint: 'vertex6',
    buffers: [
      {
        arrayStride: 12,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 13},
          {format: 'uint32x3', offset: 0, shaderLocation: 12},
          {format: 'unorm16x4', offset: 0, shaderLocation: 4},
          {format: 'float16x4', offset: 0, shaderLocation: 9},
          {format: 'sint8x2', offset: 0, shaderLocation: 15},
        ],
      },
    ],
  },
});
await gc();
let texture92 = device0.createTexture({
  label: '\u{1faf1}\u{1f942}\ucadb\uadda\u{1fc16}\u0eb0\u5b6d\u7ad6',
  size: {width: 97, height: 60, depthOrArrayLayers: 88},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup27, [0]);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer63, 'uint32', 20, 33);
} catch {}
try {
buffer66.unmap();
} catch {}
try {
  await promise10;
} catch {}
let imageData14 = new ImageData(8, 24);
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 176,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 557, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let texture93 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView123 = texture8.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
let texture94 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 14},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView124 = texture24.createView({});
let externalTexture24 = device0.importExternalTexture({source: videoFrame0});
try {
device0.queue.writeBuffer(buffer64, 0, new Float32Array(10250).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.289)), 133, 0);
} catch {}
let autogeneratedBindGroupLayout7 = pipeline0.getBindGroupLayout(0);
let commandEncoder80 = device0.createCommandEncoder({label: '\u0e01\u0dd9\u{1fb7c}\u4650\u{1f8fb}\u5b8f\u0b58'});
let textureView125 = texture71.createView({arrayLayerCount: 2});
let externalTexture25 = device0.importExternalTexture({source: videoFrame4});
try {
renderBundleEncoder13.setIndexBuffer(buffer60, 'uint16', 38, 8);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder9.insertDebugMarker('\u34f6');
} catch {}
await gc();
let commandEncoder81 = device0.createCommandEncoder({});
try {
computePassEncoder13.setBindGroup(1, bindGroup9, new Uint32Array(1491), 324, 0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup23, new Uint32Array(7), 0, 0);
} catch {}
let videoFrame17 = new VideoFrame(videoFrame6, {timestamp: 0});
let texture95 = device0.createTexture({
  size: {width: 4, height: 6, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture96 = gpuCanvasContext0.getCurrentTexture();
let textureView126 = texture46.createView({dimension: '2d-array', aspect: 'all'});
let renderPassEncoder14 = commandEncoder73.beginRenderPass({
  colorAttachments: [{
  view: textureView122,
  clearValue: { r: 605.6, g: -167.7, b: 200.4, a: -988.0, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 233805484,
});
try {
computePassEncoder12.setBindGroup(0, bindGroup0, new Uint32Array(2273), 193, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup37, new Uint32Array(1206), 237, 0);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer93, 'uint32', 16, 28);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup35, new Uint32Array(409), 256, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(7, buffer71, 0);
} catch {}
let texture97 = device0.createTexture({
  size: {width: 32, height: 48, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder15 = commandEncoder64.beginRenderPass({
  colorAttachments: [{
  view: textureView114,
  clearValue: { r: -359.6, g: 756.6, b: 959.7, a: 213.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder13.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer38, 'uint32', 8, 18);
} catch {}
let buffer101 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_DST});
try {
renderPassEncoder12.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup0, new Uint32Array(1186), 17, 0);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(1, buffer77);
} catch {}
try {
computePassEncoder2.insertDebugMarker('\ueebf');
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new Float32Array(1275).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.128)), 131, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(53); };
} catch {}
let texture98 = device0.createTexture({
  size: [97, 60, 126],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView127 = texture71.createView({dimension: 'cube', baseArrayLayer: 1, arrayLayerCount: 6});
try {
renderPassEncoder15.setPipeline(pipeline14);
} catch {}
try {
commandEncoder10.copyBufferToBuffer(buffer81, 8, buffer64, 4, 24);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(54); };
} catch {}
document.body.prepend(canvas0);
try {
buffer92.label = '\u08d3\u0537\uf10f';
} catch {}
let buffer102 = device0.createBuffer({size: 116, usage: GPUBufferUsage.INDIRECT});
let texture99 = device0.createTexture({
  size: [4, 6, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView128 = texture16.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder10.setBindGroup(1, bindGroup0, new Uint32Array(2864), 976, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 58, 15);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer82, 0, 2);
} catch {}
try {
commandEncoder61.copyBufferToTexture({
  /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 700 */
  offset: 700,
  bytesPerRow: 41472,
  buffer: buffer11,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
}, {width: 13, height: 10, depthOrArrayLayers: 0});
} catch {}
let bindGroup42 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []});
let sampler19 = device0.createSampler({addressModeW: 'repeat', mipmapFilter: 'nearest'});
try {
renderPassEncoder11.setBindGroup(0, bindGroup35, new Uint32Array(1635), 22, 0);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(0, buffer96, 0, 209);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  toneMapping: {mode: 'extended'},
});
} catch {}
let pipeline17 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2}});
let autogeneratedBindGroupLayout8 = pipeline0.getBindGroupLayout(1);
let commandEncoder82 = device0.createCommandEncoder();
try {
computePassEncoder0.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline14);
} catch {}
let texture100 = device0.createTexture({
  size: [2, 2, 9],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder17.setBindGroup(0, bindGroup42, new Uint32Array(127), 55, 0);
} catch {}
try {
commandEncoder34.copyBufferToBuffer(buffer95, 12, buffer7, 4, 8);
} catch {}
let buffer103 = device0.createBuffer({
  size: 288,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
try {
renderPassEncoder5.setIndexBuffer(buffer69, 'uint16', 34, 5);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer9, 0, 7);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer9, 36, 5);
} catch {}
try {
buffer36.unmap();
} catch {}
try {
commandEncoder59.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 150, y: 10, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 120, y: 24, z: 0},
  aspect: 'all',
},
{width: 90, height: 18, depthOrArrayLayers: 0});
} catch {}
let pipeline18 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x4242e59},
  fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rg8sint', writeMask: GPUColorWrite.BLUE}]},
  vertex: {
    module: shaderModule6,
    entryPoint: 'vertex6',
    constants: {},
    buffers: [
      {
        arrayStride: 44,
        attributes: [
          {format: 'sint32x2', offset: 12, shaderLocation: 15},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 9},
          {format: 'float16x4', offset: 0, shaderLocation: 13},
          {format: 'unorm8x4', offset: 16, shaderLocation: 4},
          {format: 'uint32x2', offset: 4, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list'},
});
let commandEncoder83 = device0.createCommandEncoder();
let texture101 = device0.createTexture({size: [780], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
try {
renderBundleEncoder24.setIndexBuffer(buffer38, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(7, buffer82, 0, 9);
} catch {}
document.body.append(canvas0);
let commandEncoder84 = device0.createCommandEncoder();
let texture102 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 19},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
renderPassEncoder10.setBindGroup(1, bindGroup1, new Uint32Array(702), 191, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer68, 0, 19);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
document.body.append(canvas3);
await gc();
let textureView129 = texture99.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder18.setBindGroup(3, bindGroup37);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup35, new Uint32Array(2738), 737, 0);
} catch {}
try {
renderBundleEncoder4.drawIndexedIndirect(buffer102, 8);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture103 = device0.createTexture({
  size: [1560, 96, 1],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle2 = renderBundleEncoder4.finish({});
try {
renderPassEncoder7.setPipeline(pipeline18);
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
let bindGroup43 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 6, resource: {buffer: buffer81}}, {binding: 58, resource: {buffer: buffer21, size: 824}}],
});
let commandEncoder85 = device0.createCommandEncoder({});
let texture104 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 233},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView130 = texture55.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 1, mipLevelCount: 1});
try {
renderPassEncoder4.setIndexBuffer(buffer9, 'uint32', 28, 33);
} catch {}
try {
renderPassEncoder10.insertDebugMarker('\u01a5');
} catch {}
let commandEncoder86 = device0.createCommandEncoder({});
let texture105 = device0.createTexture({
  size: [97, 60, 1],
  sampleCount: 4,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView131 = texture75.createView({mipLevelCount: 1, baseArrayLayer: 5, arrayLayerCount: 5});
try {
renderPassEncoder6.setBindGroup(3, bindGroup27, [0]);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline5);
} catch {}
try {
buffer92.unmap();
} catch {}
try {
commandEncoder79.resolveQuerySet(querySet0, 31, 10, buffer1, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
document.body.prepend(img0);
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteSt4281', transfer: 'bt2020_12bit'} });
let texture106 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let arrayBuffer6 = buffer67.getMappedRange(64, 0);
try {
device0.queue.writeBuffer(buffer101, 0, new Uint32Array(681).map((_, i) => i * 1), 91, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: img2,
  origin: { x: 1, y: 6 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 116, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let textureView132 = texture39.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
let externalTexture26 = device0.importExternalTexture({source: videoFrame11});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder78.copyBufferToBuffer(buffer103, 12, buffer66, 52, 20);
} catch {}
try {
device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(65232)), 186, 4);
} catch {}
let pipeline19 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}});
let bindGroup44 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 0, resource: externalTexture13},
    {binding: 1, resource: externalTexture3},
    {binding: 138, resource: textureView7},
  ],
});
let textureView133 = texture63.createView({});
let renderPassEncoder16 = commandEncoder31.beginRenderPass({
  colorAttachments: [{
  view: textureView86,
  clearValue: { r: 391.9, g: 986.8, b: 319.2, a: -445.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 240},
});
try {
computePassEncoder6.setBindGroup(2, bindGroup11, [0]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer82, 4, new DataView(new Uint8Array(12375).map((_, i) => i).buffer), 7978, 20);
} catch {}
let autogeneratedBindGroupLayout9 = pipeline1.getBindGroupLayout(0);
let texture107 = device0.createTexture({
  size: [2, 2, 14],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder7.setBindGroup(0, bindGroup22, [0]);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup11, new Uint32Array(678), 44, 1);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup32, new Uint32Array(337), 2, 0);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer55, 'uint32', 6_084, 1_329);
} catch {}
try {
commandEncoder38.copyTextureToTexture({
  texture: texture52,
  mipLevel: 0,
  origin: {x: 2, y: 8, z: 10},
  aspect: 'all',
},
{
  texture: texture54,
  mipLevel: 0,
  origin: {x: 23, y: 34, z: 0},
  aspect: 'all',
},
{width: 7, height: 1, depthOrArrayLayers: 0});
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
try {
  await promise14;
} catch {}
let bindGroup45 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 216, resource: textureView43},
    {binding: 362, resource: textureView57},
    {binding: 7, resource: textureView65},
    {binding: 1, resource: textureView14},
    {binding: 11, resource: externalTexture20},
    {binding: 95, resource: {buffer: buffer56}},
    {binding: 13, resource: {buffer: buffer37}},
    {binding: 15, resource: {buffer: buffer8, offset: 0}},
    {binding: 4, resource: sampler16},
    {binding: 183, resource: textureView124},
    {binding: 0, resource: {buffer: buffer21, size: 1512}},
    {binding: 9, resource: sampler3},
    {binding: 29, resource: externalTexture0},
    {binding: 243, resource: textureView37},
  ],
});
let commandEncoder87 = device0.createCommandEncoder();
try {
computePassEncoder20.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder14.setStencilReference(102);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer1, 'uint32', 0, 65);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline16);
} catch {}
try {
buffer7.unmap();
} catch {}
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 47,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 241,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 290,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 348,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 556,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 711,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let textureView134 = texture69.createView({baseArrayLayer: 0, arrayLayerCount: 1});
try {
renderBundleEncoder2.setPipeline(pipeline16);
} catch {}
try {
computePassEncoder1.insertDebugMarker('\ub18f');
} catch {}
try {
renderBundleEncoder23.insertDebugMarker('\u0d0d');
} catch {}
await gc();
let autogeneratedBindGroupLayout10 = pipeline10.getBindGroupLayout(1);
try {
device0.queue.writeBuffer(buffer38, 4, new Uint32Array(252).map((_, i) => i * 6), 9, 0);
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(9); };
} catch {}
let commandEncoder88 = device0.createCommandEncoder({});
let texture108 = device0.createTexture({
  size: [195, 120, 44],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView135 = texture36.createView({dimension: '2d-array', arrayLayerCount: 1});
let commandEncoder89 = device0.createCommandEncoder({});
let renderPassEncoder17 = commandEncoder26.beginRenderPass({
  colorAttachments: [{
  view: textureView93,
  clearValue: { r: 473.6, g: 907.3, b: -235.7, a: 311.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder9.setBindGroup(2, bindGroup16, new Uint32Array(1475), 19, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer96, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(3, bindGroup29, new Uint32Array(486), 143, 0);
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 60 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1250 */
  offset: 1250,
  bytesPerRow: 40704,
  buffer: buffer11,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {width: 60, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
  await promise15;
} catch {}
let commandEncoder90 = device0.createCommandEncoder({});
let textureView136 = texture71.createView({dimension: 'cube', baseMipLevel: 0});
let texture109 = device0.createTexture({
  size: {width: 32, height: 48, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView137 = texture54.createView({});
let renderPassEncoder18 = commandEncoder88.beginRenderPass({
  colorAttachments: [{view: textureView129, loadOp: 'load', storeOp: 'store'}],
  timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 141},
});
try {
computePassEncoder16.setBindGroup(0, bindGroup6, [0]);
} catch {}
try {
computePassEncoder18.setBindGroup(1, bindGroup24, new Uint32Array(776), 173, 1);
} catch {}
let textureView138 = texture70.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder14.setBindGroup(3, bindGroup42, new Uint32Array(52), 1, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(1, buffer68, 8);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
document.body.prepend(canvas0);
try {
externalTexture5.label = '\ucc35\u8f33\ue279\u1ab1\u0aa9\uec98\u0c26';
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer93, 'uint32', 4, 20);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture82,
  mipLevel: 0,
  origin: {x: 419, y: 6, z: 14},
  aspect: 'all',
}, new Uint8Array(409_892).fill(142), /* required buffer size: 409_892 */
{offset: 144, bytesPerRow: 2514, rowsPerImage: 47}, {width: 310, height: 22, depthOrArrayLayers: 4});
} catch {}
let pipeline20 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule6,
  targets: [{format: 'r16sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 100,
        attributes: [
          {format: 'sint8x4', offset: 24, shaderLocation: 12},
          {format: 'snorm16x2', offset: 36, shaderLocation: 7},
          {format: 'float32x4', offset: 0, shaderLocation: 10},
          {format: 'sint32x4', offset: 4, shaderLocation: 9},
          {format: 'uint8x4', offset: 20, shaderLocation: 1},
          {format: 'float32x2', offset: 8, shaderLocation: 13},
          {format: 'sint32x4', offset: 32, shaderLocation: 15},
          {format: 'uint32x2', offset: 20, shaderLocation: 0},
          {format: 'sint16x2', offset: 24, shaderLocation: 5},
          {format: 'uint16x2', offset: 0, shaderLocation: 4},
          {format: 'unorm16x2', offset: 72, shaderLocation: 2},
          {format: 'sint32x2', offset: 12, shaderLocation: 6},
          {format: 'float32x2', offset: 40, shaderLocation: 11},
          {format: 'unorm8x4', offset: 8, shaderLocation: 3},
          {format: 'sint32', offset: 0, shaderLocation: 8},
          {format: 'uint32x4', offset: 12, shaderLocation: 14},
        ],
      },
    ],
  },
});
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0); };
} catch {}
let shaderModule8 = device0.createShaderModule({
  code: `
requires packed_4x8_integer_dot_product;

enable f16;

struct T3 {
  @size(60) f0: u32,
}

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

struct T0 {
  f0: array<u32>,
}

@group(0) @binding(138) var st9: texture_storage_2d<r32uint, read_write>;

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

/* used global variables: st9 */
fn fn1() {
  var vf70 = fn0();
  textureStore(st9, vec2i(vf70[unconst_u32(779409636)][unconst_u32(1664949393)]), vec4u(vec4u(unconst_u32(872535014), unconst_u32(886026875), unconst_u32(1554307756), unconst_u32(615857499))));
  vf70[unconst_u32(1916931944)][unconst_u32(181257650)] -= bitcast<i32>(cos(vec2h(unconst_f16(9399.2), unconst_f16(22657.0))));
  let vf71: u32 = atomicLoad(&vw9[0]);
  atomicOr(&vw9[unconst_u32(227243673)], unconst_u32(162317398));
  vf70[unconst_u32(366354368)][atomicLoad(&(*&vw9)[u32((vec2i(unconst_i32(64302493), unconst_i32(164098056)) >> vec2u(unconst_u32(1484097364), unconst_u32(40129479))).x)])] = i32(atomicExchange(&(*&vw10), unconst_u32(694249108)));
  let vf72: vec3f = sign(vec3f(unconst_f32(-0.00104e-43), unconst_f32(0.1436e24), unconst_f32(0.3609)));
  {
  var vf73: u32 = atomicExchange(&(*&vw9)[unconst_u32(27327894)], unconst_u32(467934538));
  var vf74 = fn0();
  let vf75: vec3f = acosh(vec3f(unconst_f32(0.08377), unconst_f32(0.02502), unconst_f32(-0.1215)));
  vf73 = (vec2u(unconst_u32(642445795), unconst_u32(321765283)) ^ vec2u(unconst_u32(249643771), unconst_u32(483690803))).r;
  let vf76: ptr<workgroup, atomic<u32>> = &vw10;
}
  vf70[unconst_u32(168221586)][unconst_u32(246754612)] &= vec4i((f16(atomicLoad(&(*&vw10))) % vec4h(unconst_f16(7982.4), unconst_f16(17542.8), unconst_f16(-4059.4), unconst_f16(10872.2))))[2];
  atomicAnd(&vw9[unconst_u32(734985161)], unconst_u32(490350613));
  var vf77 = fn0();
  return;
  _ = st9;
}

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

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

struct VertexInput38 {
  @location(5) @interpolate(perspective) location_5: vec2f,
}

override override21: i32 = 160661106;

struct VertexInput37 {
  @location(12) @interpolate(flat) location_12: i32,
  @location(8) location_8: vec2u,
  @location(1) @interpolate(flat) location_1: u32,
  @location(3) @interpolate(perspective) location_3: f16,
  @location(11) location_11: vec2h,
  @builtin(vertex_index) vertex_index: u32,
  @location(0) location_0: vec4u,
  @location(9) location_9: vec2u,
  @builtin(instance_index) instance_index: u32,
  @location(7) location_7: vec4h,
  @location(4) @interpolate(flat) location_4: i32,
  @location(6) @interpolate(flat, first) location_6: vec2i,
  @location(10) @interpolate(linear, center) location_10: vec4h,
  @location(15) @interpolate(perspective, center) location_15: f16,
  @location(13) @interpolate(flat) location_13: vec2u,
}

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

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

/* zero global variables used */
@must_use 
fn fn4(a0: vec4<bool>) -> vec2i {
  var out: vec2i;
  let vf84: u32 = pack4xU8(vec4u(unconst_u32(297277638), unconst_u32(259446323), unconst_u32(1399474806), unconst_u32(429180770)));
  return out;
}

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

/* zero global variables used */
@must_use 
fn fn3(a0: texture_storage_2d<r32uint, read_write>, a1: array<array<array<vec2f, 1>, 3>, 1>) -> vec2h {
  var out: vec2h;
  var vf83: array<vec2f, 1> = a1[unconst_u32(76708996)][unconst_u32(1017993218)];
  return out;
}

/* zero global variables used */
fn fn0() -> array<array<i32, 1>, 3> {
  var out: array<array<i32, 1>, 3>;
  let vf68: vec4i = min(vec4i(out[2][0]), vec4i(unconst_i32(157750032), unconst_i32(449974239), unconst_i32(128397415), unconst_i32(-359041587)));
  out[unconst_u32(127189776)][unconst_u32(1846819490)] &= bitcast<i32>(reflect(vec3f(unconst_f32(0.07386e-41), unconst_f32(0.2390), unconst_f32(0.2312e-30)), vec3f(unconst_f32(-0.1266e1), unconst_f32(-0.00696), unconst_f32(0.06259e-28)))[1]);
  out[unconst_u32(646167299)][unconst_u32(277810765)] |= vec3i( !vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false))).y;
  let ptr31: ptr<function, array<i32, 1>> = &out[unconst_u32(62256696)];
  let vf69: vec3f = reflect(vec3f(unconst_f32(0.06261), unconst_f32(0.1816), unconst_f32(0.2063)), vec3f(unconst_f32(-0.3308), unconst_f32(0.04972e19), unconst_f32(0.01011e-19)));
  out[2][u32(dot(vec3f(unconst_f32(0.05070e-3), unconst_f32(0.02582), unconst_f32(0.01765)), vec3f(unconst_f32(0.00293), unconst_f32(0.03568e-32), unconst_f32(0.02202e-11))))] ^= i32(pack2x16unorm(vec2f( !vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false)).gr)));
  let ptr32: ptr<function, i32> = &(*ptr31)[0];
  out[unconst_u32(1025354197)][unconst_u32(805046045)] -= i32(countOneBits(pack2x16unorm(vec2f(unconst_f32(0.1602e5), unconst_f32(0.01523e-21)))));
  return out;
}

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

/* used global variables: et10, st9 */
fn fn6() {
  let vf85: u32 = pack2x16float(vec2f(unconst_f32(0.01117), unconst_f32(0.2143e-44)));
  switch u32(select(vec3h(unconst_f16(17446.0), unconst_f16(8387.6), unconst_f16(8088.3)), vec3h(unconst_f16(4549.5), unconst_f16(-16759.7), unconst_f16(4336.4)), unconst_bool(true)).z) { 
  case default {
  var vf86: vec3f = atan2(vec3f(unconst_f32(0.1407e16), unconst_f32(0.1484), unconst_f32(0.4101e27)), fract(vec2f(unconst_f32(0.2387e-5), unconst_f32(0.06268e-29))).ggr);
  vf86 = vf86;
  let vf87: vec4u = textureLoad(st9, vec2i(bitcast<i32>(vf86[unconst_u32(657425670)])));
  _ = st9;
}
  }
  var vf88: vec3h = select(vec3h(unconst_f16(-19965.8), unconst_f16(736.1), unconst_f16(26113.1)), vec3h(textureDimensions(et10).xyx.bgg.ggr), unconst_bool(false));
  var vf89 = fn3(st9, array<array<array<vec2f, 1>, 3>, 1>(array<array<vec2f, 1>, 3>(array<vec2f, 1>(unpack2x16snorm(vf85)), array<vec2f, 1>(unpack2x16float(vf85)), array<vec2f, 1>(vec2f(f32(vf85))))));
  vf88 = vec3h(faceForward(vec2f(unconst_f32(0.2822), unconst_f32(0.07022)), vec2f(unconst_f32(0.1990e-6), unconst_f32(0.1095e-37)), vec2f(unconst_f32(0.00102), unconst_f32(0.1307e-33))).yxy.rbb);
  vf88 = vec3h(asinh(vec2f(unconst_f32(-0.01883), unconst_f32(0.05587))).rrr);
  _ = st9;
  _ = et10;
}

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

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

var<workgroup> vw10: atomic<u32>;

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

/* used global variables: st9 */
fn fn2(a0: ptr<workgroup, array<atomic<u32>, 1>>, a1: ptr<workgroup, atomic<u32>>) -> vec2u {
  var out: vec2u;
  loop {
  out += vec2u(u32(sin(unconst_f16(481.4))));
  textureStore(st9, vec2i(unconst_i32(13151919), unconst_i32(24340647)), vec4u(vec4u(unconst_u32(180428355), unconst_u32(838949435), unconst_u32(325986034), unconst_u32(292179773))));
  break;
  _ = st9;
}
  atomicOr(&(*a0)[unconst_u32(497160241)], unconst_u32(1388439777));
  for (var it4=vec3u(cross(vec3h(unconst_f16(8154.1), unconst_f16(17024.6), unconst_f16(6455.0)), vec3h(unconst_f16(308.5), unconst_f16(2423.5), unconst_f16(10116.8))))[2]; it4<(pack2x16float(vec2f(unconst_f32(0.05409), unconst_f32(0.02753e18))) & 0xfff); it4++) {
  switch pack2x16unorm(vec2f(unconst_f32(0.1200), unconst_f32(0.1004))) { 
  default {
  let vf78: ptr<workgroup, atomic<u32>> = a1;
  let vf79: vec3f = degrees(vec3f(bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.3256), unconst_f32(0.1094), unconst_f32(0.09131), unconst_f32(0.1055e4))))));
  let ptr33: ptr<workgroup, array<atomic<u32>, 1>> = &(*a0);
  atomicCompareExchangeWeak(&(*a1), unconst_u32(509407216), unconst_u32(491414470));
  break;
}
case 217364521, 2952394716, 189877490 {
  out *= vec2u(pack4x8unorm(vec4f(unconst_f32(0.05710e13), unconst_f32(0.3001), unconst_f32(0.1653), unconst_f32(0.4703e17))));
  out ^= vec2u(atomicLoad(&(*a1)));
  var vf80: u32 = pack4xU8Clamp(vec4u(unconst_u32(52897898), unconst_u32(1186932139), unconst_u32(18681141), unconst_u32(9631125)));
}
  }
  let vf81: ptr<workgroup, array<atomic<u32>, 1>> = a0;
}
  let vf82: i32 = override21;
  loop {
  atomicCompareExchangeWeak(&(*a0)[unconst_u32(458800326)], unconst_u32(1468678890), unconst_u32(18553879));
  break;
}
  atomicAdd(&(*a1), unconst_u32(408811501));
  return out;
  _ = override21;
  _ = st9;
}

/* used global variables: st9 */
fn fn5() -> vec4u {
  var out: vec4u;
  let ptr34: ptr<workgroup, atomic<u32>> = &(*&vw9)[unconst_u32(156111521)];
  fn1();
  atomicExchange(&vw10, unconst_u32(989230253));
  atomicCompareExchangeWeak(&vw9[unconst_u32(2452003168)], unconst_u32(148337736), unconst_u32(1079488619));
  return out;
  _ = st9;
}

/* zero global variables used */
@vertex
fn vertex8(a0: VertexInput37, a1: VertexInput38, @location(2) location_2: vec2f) -> @builtin(position) vec4f {
  var out: vec4f;
  let vf90: vec4h = a0.location_7;
  out *= vec4f(f32(a0.location_3));
  var vf91: u32 = a0.location_8[unconst_u32(309184240)];
  let vf92: i32 = a0.location_12;
  _ = fn0();
  fn0();
  out += vec4f(f32(a0.location_10[unconst_u32(241447029)]));
  out *= bitcast<vec4f>(a0.location_6.xyxy);
  switch bitcast<vec2i>((vec2u(unconst_u32(247271241), unconst_u32(1524110376)) ^ vec2u(unconst_u32(132236716), unconst_u32(721936191))).gr)[0] { 
  default: {
  out = vec4f(step(vec2h(unconst_f16(19595.0), unconst_f16(19496.5)), vec2h(unconst_f16(22481.0), unconst_f16(14633.5))).rrgr.rbra.agbb);
  var vf93: vec4u = a0.location_0;
  var vf94 = fn0();
  break;
}
case 432987473: {
  out *= vec4f(a0.location_11.yyyx);
}
  }
  var vf95: vec2u = (vec2u(unconst_u32(1271652623), unconst_u32(225418961)) ^ vec2u(unconst_u32(321889485), unconst_u32(647444184)));
  return out;
}

/* used global variables: st9 */
@compute @workgroup_size(1, 1, 1)
fn compute7(a0: ComputeInput7, a1: ComputeInput8, @builtin(workgroup_id) workgroup_id: vec3u) {
  textureStore(st9, vec2i(unconst_i32(145245795), unconst_i32(333028705)), vec4u(vec4u(unconst_u32(193183847), unconst_u32(273534955), unconst_u32(194059343), unconst_u32(165524152))));
  var vf96 = fn2(&vw9, &(*&vw9)[unconst_u32(40403026)]);
  let ptr35: ptr<workgroup, atomic<u32>> = &vw9[0];
  atomicExchange(&vw10, unconst_u32(558559400));
  let ptr36: ptr<workgroup, atomic<u32>> = &(*&vw9)[0];
  switch a0.local_invocation_id[1] { 
  case default {
  var vf97 = fn4(vec4<bool>(bool(atomicLoad(&(*&vw9)[0]))));
  fn1();
  textureStore(st9, vec2i(unconst_i32(88173932), unconst_i32(273320602)), vec4u(vec4u(unconst_u32(750490941), unconst_u32(2619603389), unconst_u32(825616856), unconst_u32(793929356))));
  var vf98 = fn2(&vw9, &vw10);
  vf97 ^= vec2i(bitcast<i32>(atomicLoad(&vw9[unconst_u32(441216497)])));
  var vf99: u32 = pack4xI8Clamp(vec4i(unconst_i32(389834036), unconst_i32(255797744), unconst_i32(150357581), unconst_i32(273449114)));
  _ = override21;
  _ = st9;
}
  }
  textureStore(st9, vec2i(unconst_i32(910674850), unconst_i32(136520691)), vec4u(vec4u(unconst_u32(107514336), unconst_u32(17636719), unconst_u32(1647632312), unconst_u32(119299317))));
  _ = override21;
  _ = st9;
}`,
});
let bindGroup46 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 3, resource: textureView3},
    {binding: 43, resource: {buffer: buffer80}},
    {binding: 6, resource: {buffer: buffer34}},
    {binding: 58, resource: {buffer: buffer21, offset: 256, size: 1140}},
  ],
});
let commandEncoder91 = device0.createCommandEncoder({});
try {
computePassEncoder21.setBindGroup(1, bindGroup17, new Uint32Array(954), 518, 1);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline2);
} catch {}
let texture110 = device0.createTexture({
  size: {width: 195, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 376, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(978).fill(85), /* required buffer size: 978 */
{offset: 978}, {width: 44, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {
  fullRange: true,
  matrix: 'bt709',
  primaries: 'jedecP22Phosphors',
  transfer: 'bt1361ExtendedColourGamut',
} });
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {binding: 2, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 9, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 11,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 33,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 40,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {binding: 45, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 84,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 148,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 201,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 210,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 211,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 219,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 255,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 264,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 269,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 284,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 386,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let commandEncoder92 = device0.createCommandEncoder();
let texture111 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1181},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView139 = texture66.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder11.setIndexBuffer(buffer55, 'uint16', 1_198, 569);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(3, buffer8, 4);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer69, 'uint32', 0, 7);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.append(canvas3);
let bindGroup47 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []});
try {
computePassEncoder5.setBindGroup(2, bindGroup1);
} catch {}
try {
computePassEncoder3.setBindGroup(3, bindGroup19, new Uint32Array(479), 22, 1);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer63, 'uint16', 18, 40);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline20);
} catch {}
try {
commandEncoder43.resolveQuerySet(querySet0, 41, 8, buffer60, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer91, 1_136, new Uint32Array(3659).map((_, i) => i * 2), 1219, 100);
} catch {}
await gc();
let imageData15 = new ImageData(104, 88);
let bindGroup48 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 13, resource: {buffer: buffer66}},
    {binding: 183, resource: textureView40},
    {binding: 95, resource: {buffer: buffer37}},
    {binding: 216, resource: textureView43},
    {binding: 243, resource: textureView112},
    {binding: 7, resource: textureView34},
    {binding: 362, resource: textureView28},
    {binding: 4, resource: sampler16},
    {binding: 9, resource: sampler3},
    {binding: 29, resource: externalTexture25},
    {binding: 11, resource: externalTexture16},
    {binding: 1, resource: textureView22},
    {binding: 15, resource: {buffer: buffer56}},
    {binding: 0, resource: {buffer: buffer21, size: 1724}},
  ],
});
try {
renderPassEncoder15.setIndexBuffer(buffer60, 'uint32', 64, 2);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(7, buffer77, 36);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let autogeneratedBindGroupLayout11 = pipeline0.getBindGroupLayout(0);
let buffer104 = device0.createBuffer({size: 1288, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 958});
let texture112 = gpuCanvasContext2.getCurrentTexture();
let computePassEncoder22 = commandEncoder69.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 120, endOfPassWriteIndex: 107}});
try {
computePassEncoder14.setBindGroup(3, bindGroup22, [0]);
} catch {}
try {
commandEncoder83.copyBufferToTexture({
  /* bytesInLastRow: 832 widthInBlocks: 416 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1114 */
  offset: 1114,
  bytesPerRow: 11776,
  buffer: buffer11,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 6, y: 77, z: 0},
  aspect: 'all',
}, {width: 416, height: 114, depthOrArrayLayers: 0});
} catch {}
let commandEncoder93 = device0.createCommandEncoder({});
try {
renderPassEncoder13.setBindGroup(1, bindGroup33);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer90, 'uint16', 2, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(2, buffer59, 24, 10);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer60, 'uint32', 12, 40);
} catch {}
try {
renderPassEncoder16.insertDebugMarker('\ub204');
} catch {}
let buffer105 = device0.createBuffer({size: 175, usage: GPUBufferUsage.STORAGE});
let commandEncoder94 = device0.createCommandEncoder({});
try {
computePassEncoder22.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer9, 'uint16', 18, 0);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(0, buffer89, 60, 52);
} catch {}
try {
commandEncoder85.resolveQuerySet(querySet0, 48, 26, buffer70, 0);
} catch {}
await gc();
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpteSt4281', transfer: 'iec6196624'} });
let commandEncoder95 = device0.createCommandEncoder({});
let bindGroup49 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 10, resource: {buffer: buffer105, size: 60}}],
});
let textureView140 = texture102.createView({dimension: '3d', mipLevelCount: 1});
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 8, new Float32Array(1367).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6954)), 608, 0);
} catch {}
let imageData16 = new ImageData(16, 12);
let videoFrame21 = new VideoFrame(videoFrame0, {timestamp: 0});
let buffer106 = device0.createBuffer({
  size: 220,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder96 = device0.createCommandEncoder({});
let sampler20 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 90.36,
});
try {
renderPassEncoder7.setIndexBuffer(buffer90, 'uint16', 40, 114);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup13, new Uint32Array(153), 6, 0);
} catch {}
try {
commandEncoder53.insertDebugMarker('\u0ecc');
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
let commandEncoder97 = device0.createCommandEncoder({});
let texture113 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 42},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setBindGroup(1, bindGroup11, [0]);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer19, 'uint32', 0, 8);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer53, 'uint16', 0, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer62);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
await gc();
let commandEncoder98 = device0.createCommandEncoder({});
let commandBuffer0 = commandEncoder78.finish();
try {
computePassEncoder5.setBindGroup(2, bindGroup17, [0]);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline13);
} catch {}
try {
buffer75.unmap();
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData8,
  origin: { x: 0, y: 2 },
  flipY: false,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 100, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise13;
} catch {}
let buffer107 = device0.createBuffer({
  size: 2968,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder99 = device0.createCommandEncoder({});
let texture114 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView141 = texture80.createView({});
try {
renderPassEncoder1.setBindGroup(3, bindGroup17, new Uint32Array(3), 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer103, 204, new DataView(new ArrayBuffer(60952)), 1329, 0);
} catch {}
let imageData17 = new ImageData(152, 8);
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(38); };
} catch {}
try {
computePassEncoder0.setBindGroup(2, bindGroup24, new Uint32Array(3547), 1_140, 1);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer68, 0, 0);
} catch {}
try {
commandEncoder56.copyBufferToBuffer(buffer50, 0, buffer2, 0, 0);
} catch {}
let bindGroup50 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 58, resource: {buffer: buffer37}},
    {binding: 6, resource: {buffer: buffer80}},
    {binding: 3, resource: textureView17},
    {binding: 43, resource: {buffer: buffer37}},
  ],
});
let textureView142 = texture51.createView({dimension: '2d', baseArrayLayer: 4});
try {
renderPassEncoder17.setBindGroup(0, bindGroup46, new Uint32Array(837), 106, 1);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer60, 'uint32', 4, 12);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(2, buffer82, 12, 0);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline8);
} catch {}
let texture115 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 337},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder11.setBindGroup(2, bindGroup14, new Uint32Array(60), 14, 1);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer71, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup37);
} catch {}
document.body.append(canvas2);
let bindGroup51 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 0, resource: {buffer: buffer103}},
    {binding: 176, resource: {buffer: buffer21, size: 1928}},
    {binding: 557, resource: externalTexture11},
  ],
});
let commandEncoder100 = device0.createCommandEncoder({});
try {
computePassEncoder4.setBindGroup(1, bindGroup33, new Uint32Array(7015), 1_415, 0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup37);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup25, new Uint32Array(433), 96, 1);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let textureView143 = texture82.createView({aspect: 'all', baseMipLevel: 0});
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer91, 4_296, new Uint32Array(13042).map((_, i) => i * 10), 1722, 680);
} catch {}
let pipeline21 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}});
let commandEncoder101 = device0.createCommandEncoder({});
let texture116 = device0.createTexture({
  size: [32, 48, 8],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder18.setVertexBuffer(7, buffer43);
} catch {}
try {
computePassEncoder8.setBindGroup(0, bindGroup35, new Uint32Array(3075), 966, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup15, [0]);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(4, buffer71, 0, 1);
} catch {}
try {
buffer65.unmap();
} catch {}
let bindGroup52 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer5}}],
});
let texture117 = device0.createTexture({size: [8, 12, 2], dimension: '3d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderBundleEncoder6.setBindGroup(0, bindGroup9);
} catch {}
let commandEncoder102 = device0.createCommandEncoder({});
try {
renderBundleEncoder17.setIndexBuffer(buffer52, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(5, buffer8, 0, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer64, 0, new Uint32Array(2933).map((_, i) => i * 1), 1310, 0);
} catch {}
try {
  await promise12;
} catch {}
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'bt709', transfer: 'gamma28curve'} });
let buffer108 = device0.createBuffer({
  size: 24,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder103 = device0.createCommandEncoder({});
let texture118 = device0.createTexture({size: {width: 780}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder9.setBindGroup(1, bindGroup16, new Uint32Array(393), 10, 0);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(7, buffer107, 0, 1_556);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
  await promise16;
} catch {}
let imageData18 = new ImageData(68, 4);
let bindGroup53 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 43, resource: {buffer: buffer64}},
    {binding: 3, resource: textureView17},
    {binding: 58, resource: {buffer: buffer37}},
    {binding: 6, resource: {buffer: buffer32}},
  ],
});
let commandEncoder104 = device0.createCommandEncoder({});
try {
renderPassEncoder5.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(3, buffer43, 4, 2);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer65, 'uint16', 4, 16);
} catch {}
try {
commandEncoder37.copyTextureToTexture({
  texture: texture86,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 49},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture119 = device0.createTexture({
  size: [8, 12, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView144 = texture118.createView({label: '\u477d\u9a6b\u{1fe3c}\uba7b'});
try {
renderPassEncoder4.setBindGroup(0, bindGroup22, new Uint32Array(4270), 2_290, 1);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline20);
} catch {}
let arrayBuffer7 = buffer67.getMappedRange(72, 0);
let buffer109 = device0.createBuffer({size: 60, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder105 = device0.createCommandEncoder();
let texture120 = device0.createTexture({size: [2, 2, 40], mipLevelCount: 2, dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
try {
renderBundleEncoder10.setBindGroup(3, bindGroup40, new Uint32Array(2669), 154, 0);
} catch {}
try {
commandEncoder67.resolveQuerySet(querySet0, 107, 2, buffer6, 0);
} catch {}
let bindGroup54 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 10, resource: {buffer: buffer107, offset: 1280}}],
});
let texture121 = device0.createTexture({
  size: {width: 32, height: 48, depthOrArrayLayers: 8},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder19 = commandEncoder68.beginRenderPass({
  colorAttachments: [{view: textureView129, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet1,
});
try {
renderBundleEncoder24.setIndexBuffer(buffer108, 'uint32', 4, 6);
} catch {}
try {
device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(21280)), 396, 0);
} catch {}
await gc();
let buffer110 = device0.createBuffer({
  size: 244,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder106 = device0.createCommandEncoder({});
let textureView145 = texture121.createView({});
try {
renderPassEncoder2.setVertexBuffer(7, buffer59);
} catch {}
await gc();
try {
commandEncoder106.insertDebugMarker('\u07db');
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 15, resource: {buffer: buffer5}},
    {binding: 125, resource: textureView38},
    {binding: 166, resource: textureView88},
    {binding: 4, resource: {buffer: buffer107}},
    {binding: 251, resource: {buffer: buffer105, size: 28}},
    {binding: 81, resource: externalTexture4},
    {binding: 148, resource: {buffer: buffer8}},
    {binding: 0, resource: {buffer: buffer37}},
    {binding: 12, resource: textureView44},
    {binding: 220, resource: {buffer: buffer94}},
    {binding: 141, resource: {buffer: buffer21, size: 212}},
    {binding: 2, resource: textureView97},
    {binding: 152, resource: textureView87},
    {binding: 1, resource: externalTexture4},
    {binding: 11, resource: textureView26},
    {binding: 86, resource: {buffer: buffer21, size: 2048}},
    {binding: 106, resource: {buffer: buffer21, size: 1256}},
    {binding: 5, resource: {buffer: buffer80, offset: 0}},
    {binding: 6, resource: textureView0},
    {binding: 3, resource: textureView80},
  ],
});
let textureView146 = texture121.createView({});
try {
renderPassEncoder15.setBindGroup(2, bindGroup30);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer9);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup1);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline16);
} catch {}
let bindGroup56 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [
    {binding: 58, resource: {buffer: buffer21, offset: 0, size: 2360}},
    {binding: 6, resource: {buffer: buffer105, size: 60}},
  ],
});
let buffer111 = device0.createBuffer({
  size: 431,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder4.setBindGroup(0, bindGroup18, new Uint32Array(422), 156, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(5, buffer62);
} catch {}
try {
renderPassEncoder12.insertDebugMarker('\u{1f88f}');
} catch {}
let pipeline22 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule1, targets: [{format: 'rg8sint'}]},
  vertex: {
    module: shaderModule7,
    constants: {override18: 1},
    buffers: [
      {
        arrayStride: 324,
        attributes: [
          {format: 'float32x4', offset: 4, shaderLocation: 8},
          {format: 'float16x4', offset: 164, shaderLocation: 13},
          {format: 'sint32x4', offset: 152, shaderLocation: 6},
          {format: 'uint8x4', offset: 108, shaderLocation: 3},
          {format: 'unorm16x2', offset: 16, shaderLocation: 10},
          {format: 'unorm8x2', offset: 126, shaderLocation: 4},
          {format: 'snorm16x4', offset: 92, shaderLocation: 0},
          {format: 'uint32', offset: 104, shaderLocation: 11},
          {format: 'unorm16x4', offset: 40, shaderLocation: 14},
          {format: 'sint16x2', offset: 116, shaderLocation: 15},
          {format: 'uint8x2', offset: 10, shaderLocation: 9},
          {format: 'uint32', offset: 32, shaderLocation: 7},
          {format: 'float16x4', offset: 48, shaderLocation: 5},
          {format: 'float32x2', offset: 8, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
let commandEncoder107 = device0.createCommandEncoder({});
let texture122 = device0.createTexture({
  size: [32, 48, 8],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder9.setBindGroup(0, bindGroup33, new Uint32Array(2051), 291, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer74, 'uint16', 4, 14);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer68, 4, 4);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup43);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline16);
} catch {}
try {
device0.queue.writeBuffer(buffer58, 0, new DataView(new Uint8Array(2423).map((_, i) => i).buffer), 954, 4);
} catch {}
let commandEncoder108 = device0.createCommandEncoder({});
let texture123 = device0.createTexture({
  size: [780],
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder19.beginOcclusionQuery(224);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer59);
} catch {}
try {
renderBundleEncoder11.setBindGroup(0, bindGroup18);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer19, 'uint32', 8, 4);
} catch {}
try {
commandEncoder27.insertDebugMarker('\u40e6');
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(14); };
} catch {}
await gc();
let bindGroup57 = device0.createBindGroup({layout: autogeneratedBindGroupLayout10, entries: [{binding: 10, resource: {buffer: buffer22}}]});
let commandEncoder109 = device0.createCommandEncoder({});
try {
computePassEncoder4.setBindGroup(3, bindGroup50, [0]);
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup15, new Uint32Array(67), 5, 1);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer104, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let bindGroup58 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 58, resource: {buffer: buffer107, size: 592}},
    {binding: 6, resource: {buffer: buffer94}},
    {binding: 43, resource: {buffer: buffer51}},
    {binding: 3, resource: textureView17},
  ],
});
let commandEncoder110 = device0.createCommandEncoder({});
try {
renderBundleEncoder15.setBindGroup(2, bindGroup47, new Uint32Array(1136), 443, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer79, 16, new Float32Array(13802).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.058)), 208, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture69,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(86).fill(116), /* required buffer size: 86 */
{offset: 86, rowsPerImage: 73}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline23 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule4, entryPoint: 'fragment3', targets: [{format: 'rg8sint', writeMask: 0}]},
  vertex: {
    module: shaderModule1,
    constants: {},
    buffers: [
      {
        arrayStride: 8,
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 10},
          {format: 'unorm8x2', offset: 2, shaderLocation: 12},
          {format: 'uint16x4', offset: 0, shaderLocation: 3},
          {format: 'sint16x2', offset: 0, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 24,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 0, shaderLocation: 0},
          {format: 'unorm16x2', offset: 8, shaderLocation: 9},
          {format: 'unorm8x2', offset: 10, shaderLocation: 2},
          {format: 'snorm8x4', offset: 0, shaderLocation: 5},
          {format: 'snorm16x2', offset: 8, shaderLocation: 8},
          {format: 'float32x3', offset: 0, shaderLocation: 6},
          {format: 'unorm8x4', offset: 0, shaderLocation: 14},
          {format: 'uint32x3', offset: 0, shaderLocation: 1},
          {format: 'snorm8x2', offset: 0, shaderLocation: 11},
          {format: 'sint32', offset: 8, shaderLocation: 7},
          {format: 'uint32x3', offset: 0, shaderLocation: 4},
          {format: 'uint8x4', offset: 4, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', cullMode: 'front'},
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer112 = device0.createBuffer({size: 200, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, mappedAtCreation: false});
let texture124 = device0.createTexture({
  size: {width: 780},
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder8.setBindGroup(2, bindGroup31);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup48);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer90, 'uint16', 92, 92);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let canvas4 = document.createElement('canvas');
let bindGroup59 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture9}, {binding: 3, resource: textureView17}],
});
let commandEncoder111 = device0.createCommandEncoder({});
let texture125 = device0.createTexture({
  size: [780, 480, 1],
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder14.setBindGroup(3, bindGroup2, new Uint32Array(778), 38, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer96);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder53.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 660, y: 8, z: 0},
  aspect: 'all',
},
{
  texture: texture81,
  mipLevel: 0,
  origin: {x: 55, y: 4, z: 0},
  aspect: 'all',
},
{width: 146, height: 1, depthOrArrayLayers: 0});
} catch {}
await gc();
try {
renderPassEncoder10.drawIndirect(buffer68, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new Uint32Array(2119).map((_, i) => i * 1), 61, 0);
} catch {}
try {
computePassEncoder4.setBindGroup(1, bindGroup29, []);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer19, 'uint16', 2, 24);
} catch {}
try {
canvas4.getContext('webgl');
} catch {}
let shaderModule9 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

@group(0) @binding(3) var tex8: texture_depth_2d;

var<private> vp5: vec2h = vec2h(18067.8, 31755.2);

struct FragmentInput11 {
  @location(1) location_1: i32,
  @location(5) @interpolate(flat) location_5: vec4u,
  @location(9) @interpolate(perspective, sample) location_9: vec2h,
  @location(3) @interpolate(flat, sample) location_3: vec2i,
  @location(10) location_10: vec2u,
  @location(4) location_4: f16,
  @location(8) location_8: i32,
  @location(7) @interpolate(linear) location_7: f16,
}

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

@group(0) @binding(58) var<storage, read_write> buffer115: array<array<VertexOutput7, 6>>;

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

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

struct FragmentInput10 {
  @location(11) location_11: vec4h,
}

alias vec3b = vec3<bool>;

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

@group(0) @binding(6) var<storage, read_write> buffer113: FragmentInput13;

struct FragmentInput12 {
  @location(12) @interpolate(flat, centroid) location_12: vec2u,
  @location(14) location_14: i32,
}

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

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

struct VertexOutput7 {
  @location(11) @interpolate(linear, either) location_11: vec4h,
  @location(12) location_12: vec2h,
  @location(2) @interpolate(linear, either) location_2: vec2f,
  @location(14) @interpolate(linear, first) location_14: vec2f,
  @location(6) @interpolate(flat, sample) location_6: vec4u,
  @location(4) @interpolate(flat, sample) location_4: vec4u,
  @location(9) @interpolate(perspective, center) location_9: vec2h,
  @location(13) location_13: f16,
  @builtin(position) position: vec4f,
}

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

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

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

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

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

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

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

struct T0 {
  @align(8) @size(8) f0: f32,
  @size(96) f1: array<vec4i, 1>,
}

struct FragmentOutput4 {
  @location(0) @interpolate(flat) location_0: vec4i,
  @builtin(sample_mask) sample_mask: u32,
  @location(4) location_4: vec4i,
  @location(6) @interpolate(flat) location_6: i32,
}

/* used global variables: tex8 */
@vertex
fn vertex9(@location(3) @interpolate(flat) location_3: vec4u) -> VertexOutput7 {
  var out: VertexOutput7;
  let vf100: i32 = (unconst_i32(58496300) >> unconst_u32(702921413));
  out.location_6 -= unpack4xU8(textureNumLevels(tex8));
  switch (vec3u(unconst_u32(294774848), unconst_u32(676599032), unconst_u32(20391420)) ^ vec3u(unconst_u32(136614264), unconst_u32(491687833), unconst_u32(261877405)))[0] { 
  case default, 90837187 {
  let vf101: f16 = asinh(unconst_f16(153.1));
  {
  out.position -= out.location_2.grrr;
  out.position *= vec4f(out.position[unconst_u32(2660475302)]);
}
  out.location_4 = vec4u(u32(out.location_13));
}
  }
  let ptr37: ptr<function, vec2f> = &out.location_2;
  var vf102: vec3u = (vec3u(unconst_u32(548258288), unconst_u32(281913024), unconst_u32(94541432)) ^ vec3u(unconst_u32(421353527), unconst_u32(1661938726), unconst_u32(465314353)));
  return out;
  _ = tex8;
}

/* used global variables: buffer113 */
@fragment
fn fragment7(a0: FragmentInput10, a1: FragmentInput11, @location(13) @interpolate(flat) location_13: i32, a3: FragmentInput12, a4: FragmentInput13, a5: FragmentInput14, a6: FragmentInput15, a7: FragmentInput16) -> FragmentOutput4 {
  var out: FragmentOutput4;
  if bool(vp6[unconst_u32(1230909475)].w) {
  let vf103: vec3i = insertBits(vec3i(cross(vec3h(unconst_f16(4222.2), unconst_f16(199.3), unconst_f16(11740.4)), vec3h(unconst_f16(22941.1), unconst_f16(3022.2), unconst_f16(5542.5))).yyy), vec3i(unconst_i32(99694534), unconst_i32(396629056), unconst_i32(348528273)), unconst_u32(402945542), unconst_u32(3071262448));
  for (var jj86=0u; jj86<3; jj86++) { vp6[jj86] = vec4u(a0.location_11); }
  let ptr38: ptr<private, array<vec4u, 1>> = &vp6;
  let ptr39: ptr<function, u32> = &out.sample_mask;
  let vf104: u32 = a6.sample_index;
  let vf105: i32 = out.location_4[u32(a3.location_14)];
}
  buffer113.position = vec4f(a0.location_11);
  var vf106: vec2u = a3.location_12;
  if bool(a1.location_3[1]) {
  out = FragmentOutput4(vec4i(i32(all(vec2<bool>(unconst_bool(true), unconst_bool(false))))), u32(all(vec2<bool>(unconst_bool(true), unconst_bool(false)))), vec4i(i32(all(vec2<bool>(unconst_bool(true), unconst_bool(false))))), i32(all(vec2<bool>(unconst_bool(true), unconst_bool(false)))));
  out.location_0 ^= vec4i((mat4x2f() * mat3x4f())[unconst_i32(1)].grrr);
  return out;
}
  let ptr40: ptr<function, vec4i> = &out.location_4;
  let ptr41: ptr<function, vec2u> = &vf106;
  return out;
  _ = buffer113;
}

/* used global variables: buffer113, buffer115 */
@compute @workgroup_size(3, 1, 1)
fn compute8(a0: ComputeInput9, @builtin(workgroup_id) workgroup_id: vec3u, a2: ComputeInput10, @builtin(num_workgroups) num_workgroups: vec3u) {
  workgroupBarrier();
  let vf107: f32 = buffer113.position[unconst_u32(243744572)];
  switch i32(step(vec3h(unconst_f16(16185.2), unconst_f16(1822.2), unconst_f16(6434.4)), vec3h(unconst_f16(12018.9), unconst_f16(6845.1), unconst_f16(11524.1)))[0]) { 
  case 121796185: {
  let vf108: ptr<storage, array<array<VertexOutput7, 6>>, read_write> = &buffer115;
  let ptr42: ptr<storage, vec4u, read_write> = &(*vf108)[unconst_u32(512859561)][unconst_u32(1089890518)].location_6;
  let vf109: u32 = buffer115[unconst_u32(250567114)][5].location_4[unconst_u32(1243180229)];
  _ = buffer115;
}
default {
  buffer113.position = vec4f(f32((*&buffer115)[arrayLength(&(*&buffer115))][5].location_9[unconst_u32(202723226)]));
  _ = buffer115;
  _ = buffer113;
}
  }
  var vf110: f16 = (*&buffer115)[unconst_u32(297488736)][unconst_u32(1246402030)].location_9[unconst_u32(786742672)];
  vp5 -= vec2h(vp5[unconst_u32(268963631)]);
  let ptr43: ptr<storage, vec4h, read_write> = &(*&buffer115)[unconst_u32(1433591947)][5].location_11;
  _ = buffer115;
  _ = buffer113;
}`,
});
let commandEncoder112 = device0.createCommandEncoder({});
try {
renderPassEncoder10.drawIndirect(buffer54, 8);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(4, buffer111);
} catch {}
try {
commandEncoder104.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1982 */
  offset: 1982,
  buffer: buffer11,
}, {
  texture: texture61,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline24 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0}});
let bindGroup60 = device0.createBindGroup({layout: autogeneratedBindGroupLayout8, entries: [{binding: 10, resource: {buffer: buffer5}}]});
let buffer116 = device0.createBuffer({size: 1372, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let commandEncoder113 = device0.createCommandEncoder({});
let sampler21 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 47.37,
  compare: 'never',
});
try {
renderPassEncoder10.draw(462, 0, 356_351_064, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline18);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new DataView(new Uint8Array(749).map((_, i) => i).buffer), 36, 4);
} catch {}
let pipeline25 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0}});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder18.setBindGroup(3, bindGroup9, new Uint32Array(1227), 128, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(4, buffer82);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let pipeline26 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule2, targets: [{format: 'r16sint', writeMask: 0}]},
  vertex: {
    module: shaderModule9,
    buffers: [{arrayStride: 28, attributes: [{format: 'uint32x4', offset: 0, shaderLocation: 3}]}],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'front', unclippedDepth: true},
});
let bindGroup61 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer60}}],
});
try {
renderBundleEncoder1.setVertexBuffer(6, buffer111, 0);
} catch {}
try {
buffer82.unmap();
} catch {}
try {
renderPassEncoder19.insertDebugMarker('\u{1fc33}');
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder114 = device0.createCommandEncoder({});
try {
renderPassEncoder10.end();
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(5, buffer96);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: videoFrame18,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 37, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandBuffer1 = commandEncoder41.finish();
try {
computePassEncoder22.setBindGroup(0, bindGroup11, [0]);
} catch {}
try {
computePassEncoder22.setBindGroup(3, bindGroup24, new Uint32Array(2054), 964, 1);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup12);
} catch {}
try {
renderBundleEncoder20.setBindGroup(0, bindGroup47, new Uint32Array(699), 111, 0);
} catch {}
try {
commandEncoder98.copyTextureToTexture({
  texture: texture89,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture108,
  mipLevel: 0,
  origin: {x: 41, y: 8, z: 0},
  aspect: 'all',
},
{width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
await gc();
let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpte240m', transfer: 'bt2020_12bit'} });
try {
renderBundleEncoder2.setPipeline(pipeline14);
} catch {}
try {
buffer103.unmap();
} catch {}
try {
renderPassEncoder11.pushDebugGroup('\u028e');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer34, 104, new DataView(new ArrayBuffer(41836)), 2341, 0);
} catch {}
let texture126 = device0.createTexture({
  size: [32, 48, 8],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView147 = texture108.createView({arrayLayerCount: 1});
try {
computePassEncoder17.setBindGroup(2, bindGroup61, []);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer74, 'uint16', 6, 5);
} catch {}
try {
buffer34.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture18,
  mipLevel: 0,
  origin: {x: 5, y: 4, z: 3},
  aspect: 'all',
}, new Uint8Array(201_847).fill(192), /* required buffer size: 201_847 */
{offset: 15, bytesPerRow: 649, rowsPerImage: 51}, {width: 321, height: 5, depthOrArrayLayers: 7});
} catch {}
let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder15.setIndexBuffer(buffer69, 'uint32', 108, 0);
} catch {}
let buffer117 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let computePassEncoder23 = commandEncoder66.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 381, endOfPassWriteIndex: 281}});
try {
computePassEncoder23.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer93, 'uint16', 2, 16);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(3, buffer43, 0);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(7, buffer35, 0, 6);
} catch {}
try {
commandEncoder102.resolveQuerySet(querySet0, 54, 9, buffer6, 0);
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 203, y: 16, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer118 = device0.createBuffer({
  size: 4580,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder115 = device0.createCommandEncoder({});
try {
renderBundleEncoder18.setVertexBuffer(7, buffer9);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let buffer119 = device0.createBuffer({size: 32, usage: GPUBufferUsage.UNIFORM});
try {
computePassEncoder1.setBindGroup(0, bindGroup32);
} catch {}
try {
computePassEncoder10.setBindGroup(3, bindGroup51, new Uint32Array(48), 0, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup17, [0]);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup35, new Uint32Array(3135), 207, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(1, buffer96);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
renderBundleEncoder21.setBindGroup(2, bindGroup13);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder11.popDebugGroup();
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
let imageData19 = new ImageData(8, 40);
let buffer120 = device0.createBuffer({
  size: 200,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder116 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(0, bindGroup39);
} catch {}
try {
computePassEncoder15.setBindGroup(1, bindGroup8, new Uint32Array(280), 87, 1);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline5);
} catch {}
try {
commandEncoder102.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 734 */
  offset: 734,
  buffer: buffer11,
}, {
  texture: texture45,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer91, 5_556, new Uint32Array(4101).map((_, i) => i * 9), 855, 228);
} catch {}
let bindGroup62 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []});
let commandEncoder117 = device0.createCommandEncoder({});
let texture127 = device0.createTexture({
  size: [97, 60, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView148 = texture118.createView({});
let shaderModule10 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

/* used global variables: sam5, st12, tex10 */
fn fn1() -> vec2u {
  var out: vec2u;
  for (var it5=vec3u(cross(vec3h(unconst_f16(15837.1), unconst_f16(922.6), unconst_f16(-2538.4)), vec3h(textureDimensions(st12).bgr)).brg).y; it5<(u32(textureGather(145195562 % 4, tex10, sam5, vec2f(unconst_f32(0.03195), unconst_f32(0.1793))).w) & 0xfff); it5++) {
  vp8.whole = vec4h(textureLoad(st12, vec3i(unconst_i32(98739735), unconst_i32(551190652), unconst_i32(627311948))).yxzw.graa.brbr);
  _ = st12;
}
  vp7.fract = vp8.fract;
  let vf111: vec2<bool> = (vec2f(unconst_f32(0.1909e7), unconst_f32(0.2574)) != unpack2x16snorm(pack4xI8(vec4i(unconst_i32(-327261159), unconst_i32(230531696), unconst_i32(425966946), unconst_i32(89512941)))));
  out *= bitcast<vec2u>(vp8.whole);
  return out;
  _ = st12;
  _ = tex10;
  _ = sam5;
}

@group(1) @binding(176) var<storage, read_write> buffer122: array<array<array<FragmentInput17, 2>, 50>>;

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

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

override override22 = 0.1719e14;

struct VertexInput45 {
  @location(11) @interpolate(perspective) location_11: f32,
  @location(12) location_12: vec4h,
  @location(1) @interpolate(flat, centroid) location_1: vec4i,
  @builtin(vertex_index) vertex_index: u32,
}

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

@group(2) @binding(556) var st12: texture_storage_3d<r32sint, read>;

/* zero global variables used */
fn fn2(a0: vec2u) -> vec2f {
  var out: vec2f;
  let ptr49: ptr<private, vec4h> = &vp8.whole;
  let ptr50 = &vp8;
  vp7.whole = vp8.fract;
  let ptr51: ptr<private, vec4h> = &vp7.whole;
  return out;
}

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

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

var<workgroup> vw11: vec4i;

struct VertexInput43 {
  @location(2) @interpolate(flat, first) location_2: vec2i,
}

struct VertexInput41 {
  @location(15) location_15: vec2h,
  @location(12) @interpolate(flat) location_12: vec4i,
  @location(1) location_1: vec2f,
  @location(11) location_11: f16,
  @location(7) @interpolate(flat, sample) location_7: vec2i,
  @location(8) @interpolate(perspective, centroid) location_8: vec2f,
}

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

/* used global variables: buffer122 */
fn fn3(a0: f32) -> vec4f {
  var out: vec4f;
  let ptr52: ptr<workgroup, vec4i> = &vw11;
  let vf112: u32 = arrayLength(&(*&buffer122));
  vw12[unconst_u32(1235498291)][unconst_u32(360960907)] = bool(pack4xU8(buffer122[arrayLength(&buffer122)][49][1].location_14));
  for (var ii7=0u; ii7<0x1000; ii7+=0x11) { buffer122[ii7][unconst_u32(1098942449)][unconst_u32(45583344)].location_14 ^= vec4u(atanh(vec4h(unconst_f16(4707.8), unconst_f16(7651.5), unconst_f16(6026.0), unconst_f16(2613.8)))); }
  fn2(vec2u(u32(override22)));
  buffer122[unconst_u32(176739997)][pack4xU8Clamp(buffer122[(*&buffer122)[unconst_u32(174599799)][unconst_u32(98307802)][unconst_u32(21380560)].location_14[3]][49][unconst_u32(776226576)].location_14)][pack4xU8(buffer122[unconst_u32(235156843)][49][unconst_u32(127039063)].location_14)].location_14 = buffer122[unconst_u32(904388758)][49][1].location_14;
  let ptr53: ptr<storage, FragmentInput17, read_write> = &buffer122[arrayLength(&buffer122)][49][unconst_u32(365374182)];
  return out;
  _ = override22;
  _ = buffer122;
}

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

@group(2) @binding(7) var<storage, read_write> buffer123: array<array<array<array<array<f16, 23>, 1>, 2>, 4>>;

struct VertexInput42 {
  @location(6) location_6: vec4f,
  @location(4) @interpolate(perspective) location_4: f16,
  @location(9) @interpolate(flat) location_9: vec4f,
  @location(3) location_3: vec2i,
}

struct VertexInput40 {
  @location(5) @interpolate(linear) location_5: vec4h,
}

/* zero global variables used */
fn fn0(a0: ptr<storage, array<array<VertexOutput8, 26>>, read_write>, a1: texture_3d<i32>) -> array<bool, 1> {
  var out: array<bool, 1>;
  let ptr44: ptr<storage, array<VertexOutput8, 26>, read_write> = &(*a0)[unconst_i32(492379345)];
  let ptr45: ptr<storage, array<array<VertexOutput8, 26>>, read_write> = &(*a0);
  let ptr46: ptr<function, bool> = &out[0];
  (*a0)[unconst_u32(390904018)][pack4xU8(vec4u((*ptr45)[unconst_u32(305783566)][25].position.xyyx))] = (*ptr45)[unconst_i32(76537222)][25];
  for (var jj11=0u; jj11<28; jj11++) { (*a0)[unconst_u32(1808939787)][jj11].position += vec4f(asin(vec2h(unconst_f16(2883.9), unconst_f16(7348.6))).gggg); }
  let ptr47: ptr<storage, array<VertexOutput8, 26>, read_write> = &(*ptr44);
  loop {
  (*a0)[unconst_u32(1516831777)][unconst_u32(893022480)].position = (*a0)[unconst_u32(233207013)][25].position;
  break;
}
  let ptr48: ptr<storage, VertexOutput8, read_write> = &(*ptr45)[unconst_u32(955577496)][unconst_u32(342025124)];
  return out;
}

struct FragmentInput18 {
  @location(5) @interpolate(flat) location_5: vec2h,
  @location(0) @interpolate(linear) location_0: vec4f,
  @location(2) @interpolate(flat, sample) location_2: i32,
  @location(6) location_6: vec4h,
  @location(11) location_11: f32,
}

struct FragmentOutput5 {
  @location(6) @interpolate(perspective, first) location_6: vec2f,
  @location(0) @interpolate(flat) location_0: vec2i,
}

@group(2) @binding(241) var<storage, read_write> buffer124: array<array<VertexOutput8, 26>>;

var<private> vp8 = modf(vec4h(4177.4, 11657.0, 5224.0, 4654.4));

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

/* used global variables: et13, tex10 */
@must_use 
fn fn4(a0: vec4<bool>) -> array<array<vec2u, 1>, 1> {
  var out: array<array<vec2u, 1>, 1>;
  var vf113 = fn2(out[unconst_u32(830391691)][0]);
  vf113 *= vec2f(bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.2108), unconst_f32(0.02767e4)))));
  vp8 = modf(bitcast<vec4h>(out[0][countLeadingZeros(unconst_u32(392813614))]));
  vp8.fract = vec4h(f16(out[unconst_u32(51073278)][0][unconst_u32(550264703)]));
  vp8 = modf(vec4h(f16(countLeadingZeros(unconst_u32(1874883716)))));
  let ptr54: ptr<function, vec2u> = &out[unconst_u32(244182887)][unconst_u32(77719711)];
  var vf114: u32 = out[0][unconst_u32(1756574419)][unconst_u32(3153851)];
  vf113 = unpack2x16snorm(textureNumLevels(tex10));
  switch out[unconst_u32(1393198449)][0][unconst_u32(880094065)] { 
  case 108076507 {
  let vf115: bool = (unconst_bool(true) && bool(out[unconst_u32(709880118)][unconst_u32(6674815)].y));
  break;
}
case 3425548035 {
  var vf116: vec2f = tanh(vec2f(unconst_f32(0.5303), unconst_f32(0.1281)));
  vp8.fract = vec4h(f16((bool(out[0][unconst_u32(2255158991)].y) || unconst_bool(false))));
  vp7.fract = vec4h(f16(smoothstep(unconst_f32(0.04851), unconst_f32(0.5499e17), unconst_f32(0.05618e-2))));
  var vf117: u32 = out[unconst_u32(1755070647)][0][unconst_u32(568215960)];
  let vf118: bool = (unconst_bool(true) || unconst_bool(false));
}
case default, 278363102, 1681980301 {
  out[unconst_u32(533094931)][unconst_u32(45228552)] *= out[unconst_u32(318724963)][0];
  vp8 = modf(vec4h(textureLoad(et13, vec2u(unconst_u32(523186458), unconst_u32(64854585)))));
  vp7.whole = bitcast<vec4h>(out[0][0]);
  if bool(ldexp(vec4f(unconst_f32(0.01281), unconst_f32(0.1022e35), unconst_f32(0.06823), unconst_f32(0.1473e-30)), vec4i(unconst_i32(223541499), unconst_i32(3029713), unconst_i32(683226940), unconst_i32(940667)))[1]) {
  out[unconst_u32(338150028)][unconst_u32(1783038924)] &= vec2u((vec2i(unconst_i32(218617480), unconst_i32(108113107)) == vec2i(unconst_i32(69301972), unconst_i32(627205832))));
  vp8.fract = bitcast<vec4h>(textureDimensions(et13));
  _ = et13;
}
  _ = et13;
}
  }
  return out;
  _ = et13;
  _ = tex10;
}

/* used global variables: et13, tex10 */
fn fn5(a0: array<array<bool, 1>, 24>) -> array<array<f16, 43>, 1> {
  var out: array<array<f16, 43>, 1>;
  vp8 = modf(vec4h(out[0][unconst_u32(688352499)]));
  switch clamp(vec2u(unconst_u32(201586263), unconst_u32(315713783)), vec2u(unconst_u32(658993787), unconst_u32(970347029)), vec2u(unconst_u32(1411602737), unconst_u32(368581101)))[0] { 
  case 626361961, default: {
  vp8 = modf(vec4h(out[0][42]));
  vp7.fract = vec4h(f16(a0[unconst_u32(803034954)][unconst_u32(16274293)]));
  out[unconst_u32(511350287)][unconst_u32(37395913)] = tanh(vec4h(f16(a0[23][0]))).w;
  out[unconst_u32(1136230094)][unconst_u32(277140367)] = f16(a0[23][0]);
  let ptr55: ptr<function, f16> = &out[unconst_u32(107343221)][42];
  var vf119: vec4h = tanh(vec4h(unconst_f16(14623.1), unconst_f16(-24984.2), unconst_f16(5248.0), unconst_f16(4042.1)));
}
  }
  _ = fn4(vec4<bool>(a0[23][0]));
  var vf120: vec2f = floor(vec2f(f32(a0[23][0])));
  let vf121: vec2f = unpack2x16float(unconst_u32(481066857));
  let vf122: vec2i = (vec2i(unconst_i32(83691652), unconst_i32(-31890113)) | bitcast<vec2i>(tan(vec4h(unconst_f16(29569.6), unconst_f16(6036.4), unconst_f16(4551.0), unconst_f16(16068.8)))));
  return out;
  _ = et13;
  _ = tex10;
}

struct VertexInput44 {
  @location(13) @interpolate(linear) location_13: f32,
}

struct VertexOutput10 {
  @location(15) location_15: vec4u,
  @builtin(position) position: vec4f,
  @location(2) @interpolate(flat) location_2: i32,
  @location(0) @interpolate(linear, centroid) location_0: vec4h,
  @location(10) @interpolate(flat, centroid) location_10: vec4i,
  @location(13) location_13: u32,
  @location(12) @interpolate(flat, either) location_12: vec2u,
  @location(3) @interpolate(linear, centroid) location_3: vec4h,
  @location(7) location_7: vec4f,
  @location(6) @interpolate(flat, first) location_6: i32,
}

struct FragmentInput17 {
  @location(14) @interpolate(flat, centroid) location_14: vec4u,
}

var<private> vp7 = modf(vec4h(5711.7, 7542.1, 7855.5, 2186.6));

@group(2) @binding(711) var sam5: sampler;

struct VertexInput39 {
  @location(2) location_2: f32,
}

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

var<workgroup> vw12: array<array<bool, 1>, 1>;

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

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

@group(2) @binding(47) var tex10: texture_2d<f32>;

struct VertexOutput9 {
  @location(0) location_0: vec2i,
  @location(12) location_12: vec2u,
  @location(6) @interpolate(flat) location_6: i32,
  @builtin(position) position: vec4f,
  @location(4) @interpolate(flat, either) location_4: vec2i,
  @location(10) @interpolate(flat, either) location_10: f32,
  @location(5) location_5: vec4i,
  @location(8) location_8: f32,
  @location(11) @interpolate(linear, centroid) location_11: vec2h,
}

/* used global variables: et13, sam5, st12, tex10 */
@vertex
fn vertex10(@location(3) @interpolate(flat) location_3: i32, @location(9) location_9: vec4u, @location(6) location_6: vec2i, a3: VertexInput39, @builtin(vertex_index) vertex_index: u32, @builtin(instance_index) instance_index: u32, a6: VertexInput40, @location(8) @interpolate(linear) location_8: f32) -> VertexOutput8 {
  var out: VertexOutput8;
  var vf123 = fn5(array<array<bool, 1>, 24>(array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6.y)), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6.x)), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6.g)), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6.x)), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6.r)), array<bool, 1>(bool(location_6.g)), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6.r)), array<bool, 1>(bool(location_6.r)), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6[0]))));
  vp7 = modf(vec4h(textureDimensions(st12).grgb.xwww.wxyx));
  let ptr56: ptr<private, vec4h> = &vp8.whole;
  out.position = vec4f(f32( -unconst_i32(484812176)));
  let vf124: f16 = length(unconst_f16(4221.4));
  while bool(textureNumLevels(tex10)) {
  while bool(location_6.g) {
  vp7 = modf(vec4h(f16(pack4x8snorm(vec4f(unconst_f32(0.1578e37), unconst_f32(0.04996e-12), unconst_f32(0.04413e31), unconst_f32(0.00417))))));
  break;
}
}
  let vf125: vec2f = unpack2x16unorm(unconst_u32(353952407));
  fn1();
  return out;
  _ = st12;
  _ = et13;
  _ = sam5;
  _ = tex10;
}

/* used global variables: et13 */
@vertex
fn vertex11(@location(14) location_14: vec2h, @location(0) location_0: vec4f, a2: VertexInput41, @location(5) @interpolate(perspective) location_5: vec4f, a4: VertexInput42, a5: VertexInput43, @location(10) location_10: i32, a7: VertexInput44, @builtin(vertex_index) vertex_index: u32, @builtin(instance_index) instance_index: u32) -> VertexOutput9 {
  var out: VertexOutput9;
  out.location_8 = f32(unconst_f32(0.3659e18));
  return out;
  _ = et13;
}

/* used global variables: et12, et13, sam5, tex10 */
@vertex @must_use
fn vertex12(a0: VertexInput45) -> VertexOutput10 {
  var out: VertexOutput10;
  _ = fn4(vec4<bool>(textureGather(521574961 % 4, tex10, sam5, vec2f(unconst_f32(0.3423e2), unconst_f32(0.07495e-23)), clamp(vec2i(408543955, 368837997), vec2i(-8), vec2i(7))).zzzx.xxyz.wzxw.xxzy));
  for (var it6=pack4x8snorm(out.location_7); it6<(pack4x8unorm(textureSampleBaseClampToEdge(et12, sam5, vec2f(unconst_f32(-0.01654e-9), unconst_f32(0.04638)))) & 0xfff); it6++) {
  out.location_12 -= vec2u(textureSampleBaseClampToEdge(et13, sam5, vec2f(unconst_f32(0.04750e-6), unconst_f32(0.2664e10))).xz.gr.yy);
  var vf126 = fn5(array<array<bool, 1>, 24>(array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[2])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[3])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).a)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[1])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[0])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).g)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[3])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[0])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).y)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).g)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).w)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).a)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).x)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).r)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).w)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[1])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).r)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[3])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).x)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).z)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[2])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[2])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).z)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).w))));
  loop {
  var vf127: f32 = override22;
  var vf128: vec4f = textureLoad(tex10, vec2i(i32(out.location_13)), out.location_2);
  out.location_3 *= vec4h(f16(out.location_13));
  break;
  _ = override22;
  _ = tex10;
}
  _ = override22;
  _ = sam5;
  _ = tex10;
  _ = et13;
}
  out.position *= unpack4x8unorm(out.location_15[unconst_u32(62124966)]);
  loop {
  out.location_13 *= u32(floor(unconst_f16(13832.9)));
  vp8 = modf(vec4h(acos(vp8.whole[1])));
  while bool(abs(vec3u(unconst_u32(803908603), unconst_u32(131094337), unconst_u32(228481392)))[1]) {
  let ptr57: ptr<private, vec4h> = &vp7.fract;
  out.position += vec4f((*ptr57));
  fn5(array<array<bool, 1>, 24>(array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2))));
  return out;
  _ = et13;
  _ = tex10;
}
  out.location_15 |= vec4u(u32((unconst_bool(false) && unconst_bool(true))));
  out.location_13 &= pack2x16snorm(unpack4x8snorm(u32((unconst_i32(107477387) <= unconst_i32(42550974)))).xw);
  out.location_12 *= vec2u(a0.location_1.yz);
  break;
  _ = et13;
  _ = tex10;
}
  _ = sam5;
  out.position += vec4f(a0.location_11);
  return out;
  _ = override22;
  _ = et12;
  _ = sam5;
  _ = tex10;
  _ = et13;
}

/* used global variables: buffer122, buffer123, buffer124 */
@fragment
fn fragment8(a0: FragmentInput17, @location(8) location_8: vec2i, @location(10) location_10: vec2f, @location(4) location_4: vec2u, @location(9) @interpolate(linear, sample) location_9: vec4h, a5: FragmentInput18, @location(15) location_15: vec4u, @builtin(position) position: vec4f, a8: FragmentInput19, @builtin(front_facing) front_facing: bool, a10: FragmentInput20) -> FragmentOutput5 {
  var out: FragmentOutput5;
  if bool(pack2x16float(vec2f(unconst_f32(0.1726e25), unconst_f32(0.1684)))) {
  let ptr58: ptr<storage, array<f16, 23>, read_write> = &buffer123[arrayLength(&buffer123)][unconst_u32(464718955)][1][unconst_u32(254309519)];
  return out;
  _ = buffer123;
}
  let ptr59: ptr<storage, vec4u, read_write> = &buffer122[arrayLength(&buffer122)][49][unconst_u32(1167556732)].location_14;
  for (var jj93=0u; jj93<6; jj93++) { buffer123[unconst_u32(442878489)][jj93][unconst_u32(1063958514)][unconst_u32(411118293)][unconst_u32(875610397)] *= f16((*&buffer124)[unconst_u32(969436973)][25].position.g); }
  let ptr60: ptr<storage, FragmentInput17, read_write> = &buffer122[unconst_u32(12587965)][unconst_u32(95476728)][u32(buffer123[unconst_u32(1472764143)][3][1][unconst_u32(697803034)][22])];
  let ptr61: ptr<storage, vec4f, read_write> = &buffer124[unconst_u32(1119245505)][25].position;
  return out;
  _ = buffer124;
  _ = buffer123;
  _ = buffer122;
}`,
});
let bindGroup63 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 3, resource: textureView0}, {binding: 1, resource: externalTexture7}],
});
let commandEncoder118 = device0.createCommandEncoder({});
let texture128 = device0.createTexture({size: [2, 2, 14], format: 'r16sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder7.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(0, buffer104, 576, 9);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let canvas5 = document.createElement('canvas');
let commandEncoder119 = device0.createCommandEncoder({});
let textureView149 = texture30.createView({baseMipLevel: 0});
try {
computePassEncoder3.setBindGroup(1, bindGroup25, [0]);
} catch {}
try {
renderPassEncoder15.setBindGroup(1, bindGroup4, new Uint32Array(1726), 758, 1);
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(565);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer60, 'uint16', 90, 10);
} catch {}
let videoFrame24 = new VideoFrame(videoFrame13, {timestamp: 0});
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {
      binding: 26,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 30, visibility: 0, buffer: { type: 'storage', minBindingSize: 25, hasDynamicOffset: false }},
    {
      binding: 115,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 141,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
  ],
});
let commandEncoder120 = device0.createCommandEncoder({});
let texture129 = device0.createTexture({
  size: [390],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder6.setPipeline(pipeline13);
} catch {}
try {
commandEncoder108.copyTextureToTexture({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 12, y: 3, z: 0},
  aspect: 'all',
},
{
  texture: texture72,
  mipLevel: 0,
  origin: {x: 25, y: 3, z: 0},
  aspect: 'all',
},
{width: 11, height: 2, depthOrArrayLayers: 0});
} catch {}
let bindGroup64 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 11, resource: textureView29},
    {binding: 148, resource: {buffer: buffer110}},
    {binding: 15, resource: {buffer: buffer70}},
    {binding: 3, resource: textureView134},
    {binding: 220, resource: {buffer: buffer116}},
    {binding: 12, resource: textureView76},
    {binding: 1, resource: externalTexture22},
    {binding: 251, resource: {buffer: buffer81}},
    {binding: 141, resource: {buffer: buffer66}},
    {binding: 81, resource: externalTexture7},
    {binding: 4, resource: {buffer: buffer66, offset: 0}},
    {binding: 166, resource: textureView88},
    {binding: 2, resource: textureView97},
    {binding: 125, resource: textureView38},
    {binding: 152, resource: textureView90},
    {binding: 5, resource: {buffer: buffer34}},
    {binding: 0, resource: {buffer: buffer37, size: 776}},
    {binding: 6, resource: textureView0},
    {binding: 106, resource: {buffer: buffer116}},
    {binding: 86, resource: {buffer: buffer37}},
  ],
});
try {
computePassEncoder20.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, undefined, 0, 1_558_005_675);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer60, 32, new DataView(new Uint8Array(25241).map((_, i) => i).buffer), 1427, 0);
} catch {}
let gpuCanvasContext9 = canvas5.getContext('webgpu');
let texture130 = device0.createTexture({
  size: [195, 12, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder22.setBindGroup(1, bindGroup19, [0]);
} catch {}
let texture131 = device0.createTexture({
  size: [780],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let texture132 = gpuCanvasContext7.getCurrentTexture();
let textureView150 = texture5.createView({arrayLayerCount: 1});
try {
renderPassEncoder18.setIndexBuffer(buffer74, 'uint32', 4, 14);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 3, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(79).fill(53), /* required buffer size: 79 */
{offset: 79, bytesPerRow: 141, rowsPerImage: 110}, {width: 26, height: 3, depthOrArrayLayers: 0});
} catch {}
let pipeline27 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x2ecf8653},
  fragment: {module: shaderModule2, targets: [{format: 'r16sint', writeMask: 0}]},
  vertex: {
    module: shaderModule9,
    buffers: [
      {
        arrayStride: 12,
        stepMode: 'instance',
        attributes: [{format: 'uint16x4', offset: 0, shaderLocation: 3}],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true},
});
let texture133 = device0.createTexture({size: [97, 60, 1], mipLevelCount: 4, format: 'r16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(0, buffer104);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer65, 'uint32', 4, 1);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(0, buffer5, 0, 98);
} catch {}
try {
commandEncoder43.copyBufferToBuffer(buffer11, 1880, buffer65, 4, 0);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer64, 112, new Float32Array(5633).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.7468)), 756, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas1,
  origin: { x: 2, y: 0 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 5, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas5 = new OffscreenCanvas(236, 181);
let commandEncoder121 = device0.createCommandEncoder({});
let renderPassEncoder20 = commandEncoder82.beginRenderPass({
  colorAttachments: [{
  view: textureView74,
  depthSlice: 3,
  clearValue: { r: 808.5, g: 495.6, b: -58.87, a: -246.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet1,
});
try {
renderBundleEncoder23.setPipeline(pipeline8);
} catch {}
try {
commandEncoder111.clearBuffer(buffer34, 16);
} catch {}
try {
device0.queue.writeBuffer(buffer103, 28, new DataView(new ArrayBuffer(52136)), 9229, 12);
} catch {}
document.body.prepend(img1);
let bindGroup65 = device0.createBindGroup({layout: autogeneratedBindGroupLayout10, entries: [{binding: 10, resource: {buffer: buffer66}}]});
let commandEncoder122 = device0.createCommandEncoder({});
let textureView151 = texture3.createView({dimension: '2d', baseArrayLayer: 0});
let buffer127 = device0.createBuffer({size: 179, usage: GPUBufferUsage.STORAGE});
let texture134 = device0.createTexture({
  size: [1560, 96, 1],
  mipLevelCount: 7,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView152 = texture98.createView({});
try {
renderPassEncoder9.setBindGroup(0, bindGroup65, new Uint32Array(4326), 1_191, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(4, buffer111);
} catch {}
let bindGroup66 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 6, resource: {buffer: buffer105, size: 24}},
    {binding: 43, resource: {buffer: buffer37}},
    {binding: 3, resource: textureView17},
    {binding: 58, resource: {buffer: buffer107}},
  ],
});
let texture135 = device0.createTexture({
  size: [16, 24, 4],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder9.setBindGroup(0, bindGroup41);
} catch {}
try {
computePassEncoder4.setBindGroup(0, bindGroup7, new Uint32Array(3224), 128, 1);
} catch {}
try {
computePassEncoder16.end();
} catch {}
try {
renderPassEncoder20.beginOcclusionQuery(717);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup0, new Uint32Array(2143), 190, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer106, 76, new Float32Array(2450).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.260)), 165, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 8, y: 789 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 141, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 5, depthOrArrayLayers: 0});
} catch {}
let bindGroup67 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout9,
  entries: [{binding: 3, resource: textureView17}, {binding: 1, resource: externalTexture5}],
});
let buffer128 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder123 = device0.createCommandEncoder({});
let texture136 = device0.createTexture({size: [4, 6, 1], sampleCount: 1, format: 'rg8sint', usage: GPUTextureUsage.COPY_DST});
let textureView153 = texture36.createView({});
try {
renderPassEncoder9.setBindGroup(3, bindGroup13, new Uint32Array(3320), 198, 0);
} catch {}
try {
commandEncoder65.insertDebugMarker('\uea3d');
} catch {}
let texture137 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16sint'],
});
let sampler22 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 79.50,
});
try {
renderPassEncoder20.setVertexBuffer(3, buffer82, 24);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(5, buffer59, 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer63, 24, new DataView(new Uint8Array(5641).map((_, i) => i).buffer), 58, 0);
} catch {}
let offscreenCanvas6 = new OffscreenCanvas(43, 205);
let buffer129 = device0.createBuffer({size: 8, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let textureView154 = texture69.createView({});
try {
renderPassEncoder20.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer112, 'uint32', 48, 2);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer46, 36, new Float32Array(10314).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6825)), 160, 0);
} catch {}
let buffer130 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let commandEncoder124 = device0.createCommandEncoder();
try {
renderPassEncoder4.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup44);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer74, 'uint32', 44, 0);
} catch {}
try {
commandEncoder116.copyTextureToTexture({
  texture: texture123,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture78,
  mipLevel: 0,
  origin: {x: 190, y: 0, z: 8},
  aspect: 'all',
},
{width: 438, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer63, 116, new BigInt64Array(4850).map((_, i) => BigInt(i - 9)), 711, 0);
} catch {}
let buffer131 = device0.createBuffer({size: 424, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder125 = device0.createCommandEncoder({});
let texture138 = device0.createTexture({
  size: [32, 48, 8],
  sampleCount: 1,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView155 = texture25.createView({baseMipLevel: 1, mipLevelCount: 1});
try {
commandEncoder107.resolveQuerySet(querySet1, 26, 1, buffer71, 0);
} catch {}
let commandEncoder126 = device0.createCommandEncoder({});
let texture139 = device0.createTexture({
  size: {width: 4, height: 6, depthOrArrayLayers: 1},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder9.setBindGroup(2, bindGroup48, new Uint32Array(2060), 92, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer1, 'uint32', 28, 34);
} catch {}
try {
  await shaderModule5.getCompilationInfo();
} catch {}
try {
commandEncoder76.clearBuffer(buffer56);
} catch {}
try {
commandEncoder77.resolveQuerySet(querySet1, 75, 7, buffer63, 0);
} catch {}
let imageData20 = new ImageData(20, 120);
let commandEncoder127 = device0.createCommandEncoder({});
let textureView156 = texture56.createView({dimension: '2d-array'});
try {
renderPassEncoder5.setBlendConstant({ r: 884.2, g: -17.48, b: -375.1, a: -569.8, });
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer93, 'uint16', 2, 42);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder25.setBindGroup(2, bindGroup47, new Uint32Array(1704), 256, 0);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(7, buffer35, 0, 0);
} catch {}
try {
commandEncoder119.resolveQuerySet(querySet0, 259, 0, buffer108, 0);
} catch {}
let imageData21 = new ImageData(72, 40);
try {
bindGroup60.label = '\u005d\u20c1\ucaa6\ubaf0\u026a\u2f09\u18f4\u{1f61e}';
} catch {}
let autogeneratedBindGroupLayout12 = pipeline7.getBindGroupLayout(0);
let bindGroup68 = device0.createBindGroup({layout: autogeneratedBindGroupLayout10, entries: [{binding: 10, resource: {buffer: buffer75}}]});
let commandEncoder128 = device0.createCommandEncoder({});
let texture140 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  sampleCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder1.setBindGroup(1, bindGroup34, new Uint32Array(378), 9, 1);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let textureView157 = texture47.createView({dimension: '2d-array'});
try {
computePassEncoder15.setBindGroup(3, bindGroup44);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup25, [0]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer112, 'uint16', 40, 13);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline14);
} catch {}
try {
computePassEncoder21.insertDebugMarker('\ud810');
} catch {}
try {
device0.queue.writeBuffer(buffer101, 12, new Uint32Array(2633).map((_, i) => i * 3), 8, 0);
} catch {}
let pipeline28 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, entryPoint: 'compute6'}});
try {
computePassEncoder4.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline14);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 116, new Float32Array(4113).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.266)), 183, 4);
} catch {}
let gpuCanvasContext10 = offscreenCanvas5.getContext('webgpu');
let bindGroup69 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 84, resource: {buffer: buffer107}},
    {binding: 6, resource: textureView44},
    {binding: 255, resource: {buffer: buffer37, size: 684}},
    {binding: 201, resource: {buffer: buffer116, offset: 0}},
    {binding: 2, resource: {buffer: buffer82}},
    {binding: 264, resource: textureView36},
    {binding: 269, resource: textureView12},
    {binding: 3, resource: {buffer: buffer60}},
    {binding: 33, resource: textureView26},
    {binding: 386, resource: textureView17},
    {binding: 148, resource: textureView36},
    {binding: 211, resource: {buffer: buffer116}},
    {binding: 0, resource: {buffer: buffer79}},
    {binding: 9, resource: {buffer: buffer37}},
    {binding: 219, resource: textureView3},
    {binding: 40, resource: externalTexture13},
    {binding: 7, resource: textureView2},
    {binding: 5, resource: textureView149},
    {binding: 210, resource: {buffer: buffer21, size: 1612}},
    {binding: 284, resource: textureView155},
    {binding: 45, resource: externalTexture11},
    {binding: 11, resource: {buffer: buffer21, offset: 0, size: 3136}},
    {binding: 117, resource: {buffer: buffer21, size: 2332}},
  ],
});
let buffer132 = device0.createBuffer({size: 384, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let commandBuffer2 = commandEncoder12.finish();
let externalTexture27 = device0.importExternalTexture({source: videoFrame2});
try {
renderPassEncoder20.setBindGroup(0, bindGroup27, [0]);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 44, new Uint32Array(11098).map((_, i) => i * 8), 1318, 0);
} catch {}
let bindGroup70 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 557, resource: externalTexture6},
    {binding: 176, resource: {buffer: buffer107, offset: 256}},
    {binding: 0, resource: {buffer: buffer120, size: 16}},
  ],
});
let buffer133 = device0.createBuffer({
  size: 50,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder129 = device0.createCommandEncoder({});
try {
renderPassEncoder6.setBindGroup(0, bindGroup12, new Uint32Array(3563), 55, 0);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(7, buffer89, 0, 83);
} catch {}
let textureView158 = texture68.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
try {
renderBundleEncoder6.setVertexBuffer(0, buffer132, 0);
} catch {}
try {
commandEncoder47.copyBufferToTexture({
  /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 496 */
  offset: 496,
  bytesPerRow: 9216,
  rowsPerImage: 128,
  buffer: buffer11,
}, {
  texture: texture69,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder8.insertDebugMarker('\u00a3');
} catch {}
try {
device0.queue.writeBuffer(buffer58, 12, new Float32Array(5234).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7711)), 2421, 8);
} catch {}
let commandEncoder130 = device0.createCommandEncoder({});
try {
renderPassEncoder4.setIndexBuffer(buffer107, 'uint32', 2_968);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(0, buffer19);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline20);
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 27, y: 14 },
  flipY: false,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 103, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 28, height: 2, depthOrArrayLayers: 0});
} catch {}
let imageData22 = new ImageData(20, 108);
let bindGroup71 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [{binding: 10, resource: {buffer: buffer127, size: 96}}],
});
let commandEncoder131 = device0.createCommandEncoder({});
let texture141 = device0.createTexture({
  size: {width: 32, height: 48, depthOrArrayLayers: 8},
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture142 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView159 = texture85.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 2});
try {
renderPassEncoder13.setBindGroup(0, bindGroup63);
} catch {}
try {
renderPassEncoder18.draw(535, 0, 155_146_320);
} catch {}
try {
renderPassEncoder18.drawIndexed(2, 0, 0, 21_270_851);
} catch {}
try {
renderPassEncoder18.drawIndexedIndirect(buffer4, 8);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer107, 'uint32', 12, 581);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup47, new Uint32Array(522), 64, 0);
} catch {}
let commandEncoder132 = device0.createCommandEncoder({});
let texture143 = device0.createTexture({
  size: [390, 24, 15],
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView160 = texture9.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder18.drawIndexedIndirect(buffer45, 8);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer53, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(7, buffer5, 0, 130);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView161 = texture141.createView({mipLevelCount: 1});
try {
renderPassEncoder18.drawIndexedIndirect(buffer133, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer71, 0, 10);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer55, 'uint16', 22, 2_451);
} catch {}
try {
device0.queue.writeBuffer(buffer130, 0, new DataView(new Uint8Array(195).map((_, i) => i).buffer), 21, 0);
} catch {}
let pipelineLayout4 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout11, autogeneratedBindGroupLayout6, veryExplicitBindGroupLayout9],
});
let commandEncoder133 = device0.createCommandEncoder({});
let texture144 = device0.createTexture({
  size: {width: 16, height: 24, depthOrArrayLayers: 1},
  sampleCount: 1,
  dimension: '2d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder20.setBindGroup(0, bindGroup52);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup17, [0]);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup56, new Uint32Array(420), 4, 0);
} catch {}
try {
renderPassEncoder18.drawIndexedIndirect(buffer35, 16);
} catch {}
try {
renderPassEncoder18.drawIndirect(buffer37, 108);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(0, buffer118);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
let bindGroup72 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 176, resource: {buffer: buffer107, offset: 0}},
    {binding: 557, resource: externalTexture16},
    {binding: 0, resource: {buffer: buffer70}},
  ],
});
let commandEncoder134 = device0.createCommandEncoder({});
let texture145 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView162 = texture131.createView({dimension: '1d', format: 'r16sint'});
try {
computePassEncoder14.setBindGroup(0, bindGroup29, new Uint32Array(3198), 217, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup35, []);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup59, new Uint32Array(2316), 164, 0);
} catch {}
try {
renderPassEncoder18.end();
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup18, new Uint32Array(2165), 91, 0);
} catch {}
try {
buffer96.unmap();
} catch {}
try {
computePassEncoder23.insertDebugMarker('\ubc9f');
} catch {}
try {
device0.queue.writeBuffer(buffer58, 36, new DataView(new Uint8Array(27604).map((_, i) => i).buffer), 16929, 20);
} catch {}
let pipeline29 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1'}});
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(60); };
} catch {}
try {
  await promise17;
} catch {}
let textureView163 = texture144.createView({dimension: '2d-array'});
let textureView164 = texture62.createView({});
try {
renderPassEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(508), 162, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline14);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST,
  toneMapping: {mode: 'standard'},
});
} catch {}
let texture146 = device0.createTexture({
  size: [8, 12, 3],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder8.setBindGroup(1, bindGroup69, [0, 0]);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup49, new Uint32Array(255), 50, 0);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer19, 'uint16', 16, 15);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 8, new Uint32Array(348).map((_, i) => i * 3), 65, 12);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer134 = device0.createBuffer({size: 45, usage: GPUBufferUsage.MAP_WRITE});
let textureView165 = texture65.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
renderPassEncoder14.setIndexBuffer(buffer93, 'uint32', 0, 13);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup59, []);
} catch {}
try {
device0.queue.writeBuffer(buffer79, 40, new Float32Array(27588).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.217)), 2919, 0);
} catch {}
let texture147 = device0.createTexture({
  size: [780, 480, 5],
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView166 = texture113.createView({});
try {
renderPassEncoder8.setIndexBuffer(buffer65, 'uint16', 0, 5);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer120, 'uint32', 12, 79);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
document.body.prepend(img4);
let buffer135 = device0.createBuffer({size: 480, usage: GPUBufferUsage.INDIRECT});
let textureView167 = texture31.createView({});
try {
renderBundleEncoder9.setBindGroup(3, bindGroup5, new Uint32Array(860), 83, 1);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline16);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let imageData23 = new ImageData(24, 4);
let bindGroup73 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 43, resource: {buffer: buffer116}},
    {binding: 3, resource: textureView3},
    {binding: 58, resource: {buffer: buffer116}},
    {binding: 6, resource: {buffer: buffer116}},
  ],
});
try {
renderPassEncoder3.setIndexBuffer(buffer69, 'uint32', 20, 92);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer107, 'uint32', 188, 331);
} catch {}
let pipeline30 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5, constants: {}}});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 10,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 384,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let texture148 = device0.createTexture({size: [780, 480, 238], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView168 = texture25.createView({mipLevelCount: 1});
try {
renderPassEncoder8.setVertexBuffer(0, buffer104, 0);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
let autogeneratedBindGroupLayout13 = pipeline12.getBindGroupLayout(0);
let texture149 = device0.createTexture({size: [2, 2, 14], format: 'rg8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
renderPassEncoder19.beginOcclusionQuery(129);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline27);
} catch {}
try {
device0.queue.writeBuffer(buffer22, 8, new DataView(new ArrayBuffer(8520)), 519, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture136,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(175).fill(166), /* required buffer size: 175 */
{offset: 175}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup25, new Uint32Array(589), 18, 1);
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [
    {binding: 58, resource: {buffer: buffer21, size: 1936}},
    {binding: 6, resource: {buffer: buffer127, size: 36}},
  ],
});
let buffer136 = device0.createBuffer({
  size: 184,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder135 = device0.createCommandEncoder();
try {
renderPassEncoder2.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer9);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer93, 'uint16', 6, 31);
} catch {}
try {
buffer33.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture104,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(55_639).fill(184), /* required buffer size: 55_639 */
{offset: 199, bytesPerRow: 28, rowsPerImage: 36}, {width: 0, height: 0, depthOrArrayLayers: 56});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageData10,
  origin: { x: 9, y: 3 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer137 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder136 = device0.createCommandEncoder({});
let texture150 = gpuCanvasContext7.getCurrentTexture();
try {
computePassEncoder13.setBindGroup(1, bindGroup71, new Uint32Array(2277), 2, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup23, new Uint32Array(8437), 3_655, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer137, 'uint16', 0, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer71, 0, 2);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(6, buffer118, 0, 441);
} catch {}
try {
  await shaderModule9.getCompilationInfo();
} catch {}
try {
commandEncoder74.copyBufferToTexture({
  /* bytesInLastRow: 392 widthInBlocks: 98 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1580 */
  offset: 1580,
  bytesPerRow: 12800,
  buffer: buffer118,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 110, y: 2, z: 0},
  aspect: 'all',
}, {width: 98, height: 15, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder57.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 71, y: 6, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2258 widthInBlocks: 1129 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1004 */
  offset: 1004,
  bytesPerRow: 12800,
  buffer: buffer56,
}, {width: 1129, height: 12, depthOrArrayLayers: 0});
} catch {}
document.body.append(img2);
let textureView169 = texture145.createView({dimension: '2d-array'});
let texture151 = device0.createTexture({
  size: [195, 120, 1],
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer132);
} catch {}
try {
  await buffer7.mapAsync(GPUMapMode.READ, 8, 0);
} catch {}
try {
commandEncoder114.copyBufferToTexture({
  /* bytesInLastRow: 494 widthInBlocks: 247 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2090 */
  offset: 2090,
  bytesPerRow: 512,
  buffer: buffer118,
}, {
  texture: texture147,
  mipLevel: 0,
  origin: {x: 347, y: 280, z: 0},
  aspect: 'all',
}, {width: 247, height: 36, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.label = '\u0f43\ucda5\u0486\uf7b4';
} catch {}
let bindGroup75 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 0, resource: {buffer: buffer37}},
    {binding: 2, resource: textureView97},
    {binding: 86, resource: {buffer: buffer116}},
    {binding: 152, resource: textureView87},
    {binding: 5, resource: {buffer: buffer133, size: 16}},
    {binding: 125, resource: textureView26},
    {binding: 166, resource: textureView138},
    {binding: 220, resource: {buffer: buffer120}},
    {binding: 141, resource: {buffer: buffer116}},
    {binding: 81, resource: externalTexture22},
    {binding: 11, resource: textureView38},
    {binding: 12, resource: textureView76},
    {binding: 6, resource: textureView17},
    {binding: 1, resource: externalTexture21},
    {binding: 4, resource: {buffer: buffer107}},
    {binding: 3, resource: textureView80},
    {binding: 148, resource: {buffer: buffer130}},
    {binding: 251, resource: {buffer: buffer32}},
    {binding: 15, resource: {buffer: buffer37, size: 312}},
    {binding: 106, resource: {buffer: buffer21, offset: 256, size: 1264}},
  ],
});
let buffer138 = device0.createBuffer({size: 364, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView170 = texture105.createView({baseMipLevel: 0});
let textureView171 = texture65.createView({arrayLayerCount: 1});
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup38, new Uint32Array(1463), 174, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame24,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 64, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline31 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment1',
  targets: [{format: 'r16sint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule8,
    entryPoint: 'vertex8',
    buffers: [
      {
        arrayStride: 340,
        attributes: [
          {format: 'snorm16x2', offset: 16, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 10},
          {format: 'sint32', offset: 16, shaderLocation: 12},
          {format: 'uint32x3', offset: 40, shaderLocation: 9},
          {format: 'sint32x2', offset: 44, shaderLocation: 4},
          {format: 'snorm8x2', offset: 52, shaderLocation: 5},
          {format: 'unorm8x2', offset: 6, shaderLocation: 2},
          {format: 'unorm16x2', offset: 40, shaderLocation: 3},
          {format: 'uint16x2', offset: 64, shaderLocation: 1},
          {format: 'unorm16x4', offset: 4, shaderLocation: 15},
          {format: 'uint8x2', offset: 190, shaderLocation: 8},
          {format: 'sint8x2', offset: 42, shaderLocation: 6},
          {format: 'uint32', offset: 20, shaderLocation: 13},
          {format: 'unorm8x2', offset: 6, shaderLocation: 7},
        ],
      },
      {arrayStride: 16, attributes: [{format: 'uint16x2', offset: 0, shaderLocation: 0}]},
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', cullMode: 'back'},
});
let videoFrame25 = new VideoFrame(videoFrame9, {timestamp: 0});
let buffer139 = device0.createBuffer({size: 304, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
try {
computePassEncoder8.setBindGroup(1, bindGroup3, new Uint32Array(554), 54, 1);
} catch {}
let pipeline32 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5, constants: {}}});
let promise18 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule1,
  targets: [{
  format: 'rg8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule8,
    constants: {},
    buffers: [
      {
        arrayStride: 20,
        attributes: [
          {format: 'sint16x4', offset: 0, shaderLocation: 12},
          {format: 'uint32x2', offset: 4, shaderLocation: 1},
          {format: 'sint16x4', offset: 4, shaderLocation: 4},
          {format: 'float16x4', offset: 0, shaderLocation: 11},
          {format: 'uint32x3', offset: 0, shaderLocation: 8},
          {format: 'unorm16x4', offset: 4, shaderLocation: 7},
          {format: 'unorm16x4', offset: 0, shaderLocation: 5},
          {format: 'uint8x2', offset: 0, shaderLocation: 9},
          {format: 'float32x3', offset: 0, shaderLocation: 10},
          {format: 'uint16x2', offset: 0, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 44,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 8, shaderLocation: 3},
          {format: 'uint16x2', offset: 4, shaderLocation: 0},
          {format: 'sint32x4', offset: 0, shaderLocation: 6},
          {format: 'float32x2', offset: 8, shaderLocation: 2},
        ],
      },
      {
        arrayStride: 60,
        stepMode: 'vertex',
        attributes: [{format: 'float32x3', offset: 8, shaderLocation: 15}],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', unclippedDepth: true},
});
let imageData24 = new ImageData(20, 12);
let texture152 = device0.createTexture({
  size: {width: 32, height: 48, depthOrArrayLayers: 8},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder12.setBindGroup(0, bindGroup14, new Uint32Array(1799), 814, 1);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline31);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(4, buffer68, 0);
} catch {}
try {
  await buffer46.mapAsync(GPUMapMode.READ, 0, 12);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
document.body.prepend(img4);
await gc();
try {
renderBundleEncoder10.setBindGroup(0, bindGroup52, new Uint32Array(909), 10, 0);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(0, buffer139);
} catch {}
let commandEncoder137 = device0.createCommandEncoder({});
try {
renderPassEncoder14.setIndexBuffer(buffer1, 'uint32', 140, 85);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer53, 'uint32', 0, 1);
} catch {}
try {
commandEncoder62.insertDebugMarker('\uf98e');
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture97,
  mipLevel: 0,
  origin: {x: 1, y: 14, z: 0},
  aspect: 'all',
}, new Uint8Array(113).fill(182), /* required buffer size: 113 */
{offset: 113, bytesPerRow: 48}, {width: 6, height: 11, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup76 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: []});
let commandEncoder138 = device0.createCommandEncoder({});
let externalTexture28 = device0.importExternalTexture({source: videoFrame25, colorSpace: 'display-p3'});
try {
computePassEncoder19.setBindGroup(2, bindGroup47);
} catch {}
try {
commandEncoder51.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2164 */
  offset: 2164,
  rowsPerImage: 125,
  buffer: buffer118,
}, {
  texture: texture129,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(1992)), 140, 4);
} catch {}
let buffer140 = device0.createBuffer({size: 112, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, stencilReadOnly: true});
try {
renderBundleEncoder25.setBindGroup(3, bindGroup16);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(3, buffer96, 0);
} catch {}
try {
commandEncoder118.copyBufferToTexture({
  /* bytesInLastRow: 76 widthInBlocks: 38 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 194 */
  offset: 194,
  bytesPerRow: 70144,
  buffer: buffer76,
}, {
  texture: texture15,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, {width: 38, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer11, 292, new BigInt64Array(14202).map((_, i) => BigInt(i - 7)), 2521, 28);
} catch {}
let buffer141 = device0.createBuffer({
  size: 240,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView172 = texture45.createView({baseArrayLayer: 3, arrayLayerCount: 1});
try {
computePassEncoder6.setBindGroup(0, bindGroup76, new Uint32Array(109), 45, 0);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer111, 0);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer131, 'uint32', 280, 4);
} catch {}
let textureView173 = texture144.createView({mipLevelCount: 1});
try {
computePassEncoder11.setBindGroup(2, bindGroup25, [0]);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer136, 'uint32', 8, 3);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline31);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer136, 0, new DataView(new ArrayBuffer(62968)), 1223, 0);
} catch {}
let commandEncoder139 = device0.createCommandEncoder({});
try {
renderPassEncoder1.setPipeline(pipeline14);
} catch {}
try {
buffer46.unmap();
} catch {}
let commandEncoder140 = device0.createCommandEncoder({});
try {
renderPassEncoder13.setBindGroup(3, bindGroup22, new Uint32Array(1431), 314, 1);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup47, new Uint32Array(2056), 15, 0);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(7, buffer136);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer142 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_SRC});
let textureView174 = texture50.createView({baseMipLevel: 0});
try {
renderBundleEncoder14.setBindGroup(3, bindGroup41, new Uint32Array(32), 7, 0);
} catch {}
canvas5.width = 152;
let commandEncoder141 = device0.createCommandEncoder();
let commandBuffer3 = commandEncoder88.finish();
let sampler23 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMinClamp: 29.43});
try {
renderPassEncoder16.setIndexBuffer(buffer19, 'uint16', 12, 42);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer96, 0);
} catch {}
try {
renderBundleEncoder11.setBindGroup(3, bindGroup29, new Uint32Array(129), 42, 0);
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData12,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 130, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
offscreenCanvas1.height = 112;
let commandEncoder142 = device0.createCommandEncoder();
let textureView175 = texture111.createView({mipLevelCount: 1});
let computePassEncoder24 = commandEncoder107.beginComputePass({timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 182}});
try {
computePassEncoder21.setBindGroup(0, bindGroup42, new Uint32Array(437), 25, 0);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup67);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer137, 'uint16', 2, 6);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline8);
} catch {}
try {
commandEncoder61.resolveQuerySet(querySet0, 115, 0, buffer70, 0);
} catch {}
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }},
    {binding: 5, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 32, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 184,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 365,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
  ],
});
let commandEncoder143 = device0.createCommandEncoder({});
try {
computePassEncoder17.setBindGroup(0, bindGroup76);
} catch {}
try {
computePassEncoder18.setBindGroup(2, bindGroup38, new Uint32Array(508), 118, 0);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline9);
} catch {}
try {
commandEncoder43.copyTextureToBuffer({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 844 */
  offset: 844,
  bytesPerRow: 2304,
  buffer: buffer91,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let commandEncoder144 = device0.createCommandEncoder({});
try {
renderPassEncoder12.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer19, 'uint16', 0, 25);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer131, 0, 66);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer118, 'uint16', 1_796, 362);
} catch {}
let gpuCanvasContext11 = offscreenCanvas6.getContext('webgpu');
let textureView176 = texture59.createView({dimension: '2d-array', format: 'rg8sint', mipLevelCount: 1});
try {
computePassEncoder23.setBindGroup(3, bindGroup22, [0]);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(6, buffer131, 156, 159);
} catch {}
await gc();
let buffer143 = device0.createBuffer({
  size: 44,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture153 = device0.createTexture({
  size: [780, 48, 366],
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder13.setBindGroup(0, bindGroup76, new Uint32Array(1135), 622, 0);
} catch {}
try {
renderBundleEncoder27.setBindGroup(2, bindGroup6, new Uint32Array(247), 32, 1);
} catch {}
document.body.prepend(img0);
let commandEncoder145 = device0.createCommandEncoder({label: '\u{1ff6c}\u0b5c\u{1fc20}\u1d4b\ua10c\u{1f9fe}'});
let texture154 = device0.createTexture({
  size: [780],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder25 = commandEncoder110.beginComputePass({timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 123}});
try {
computePassEncoder12.setBindGroup(0, bindGroup6, new Uint32Array(522), 45, 1);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder22.setBindGroup(3, bindGroup23, new Uint32Array(867), 45, 0);
} catch {}
try {
buffer90.unmap();
} catch {}
let bindGroup77 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 184, resource: {buffer: buffer116}},
    {binding: 5, resource: sampler22},
    {binding: 0, resource: {buffer: buffer56}},
    {binding: 32, resource: externalTexture23},
    {binding: 48, resource: textureView17},
    {binding: 1, resource: sampler21},
    {binding: 365, resource: textureView170},
  ],
});
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 264});
let textureView177 = texture27.createView({dimension: '3d'});
try {
renderPassEncoder15.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline14);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: videoFrame17,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup78 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 32, resource: externalTexture8},
    {binding: 1, resource: sampler1},
    {binding: 365, resource: textureView170},
    {binding: 5, resource: sampler4},
    {binding: 0, resource: {buffer: buffer107}},
    {binding: 48, resource: textureView0},
    {binding: 184, resource: {buffer: buffer70}},
  ],
});
let commandEncoder146 = device0.createCommandEncoder({});
try {
computePassEncoder23.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup14, new Uint32Array(1560), 166, 1);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer69, 'uint32', 72, 13);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(1, buffer136, 0, 50);
} catch {}
try {
commandEncoder138.copyTextureToBuffer({
  texture: texture142,
  mipLevel: 0,
  origin: {x: 3, y: 12, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 258 */
  offset: 258,
  bytesPerRow: 768,
  buffer: buffer56,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData21,
  origin: { x: 9, y: 3 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 15, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 7, height: 13, depthOrArrayLayers: 0});
} catch {}
let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpte240m', transfer: 'bt2020_12bit'} });
try {
renderPassEncoder5.setIndexBuffer(buffer93, 'uint32', 4, 20);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline31);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline33 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}});
await gc();
let buffer144 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder147 = device0.createCommandEncoder();
let texture155 = device0.createTexture({
  size: [16, 24, 4],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder10.setBindGroup(0, bindGroup76, new Uint32Array(1612), 159, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer82, 0, 70);
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture119,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 0},
  aspect: 'all',
},
{
  texture: texture61,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder148 = device0.createCommandEncoder({});
let textureView178 = texture54.createView({dimension: '2d-array'});
try {
computePassEncoder12.setBindGroup(1, bindGroup45);
} catch {}
try {
computePassEncoder12.setBindGroup(2, bindGroup13, new Uint32Array(6346), 34, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer91, 924, new Float32Array(1552).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4196)), 398);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 1,
  origin: {x: 3, y: 17, z: 0},
  aspect: 'all',
}, new Uint8Array(19).fill(131), /* required buffer size: 19 */
{offset: 19, bytesPerRow: 164}, {width: 60, height: 82, depthOrArrayLayers: 0});
} catch {}
let sampler24 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.35,
  maxAnisotropy: 20,
});
try {
renderPassEncoder13.setVertexBuffer(1, buffer104, 0, 70);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer107, 'uint16', 1_118, 227);
} catch {}
let bindGroup79 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 3, resource: textureView0}, {binding: 1, resource: externalTexture19}],
});
let buffer145 = device0.createBuffer({size: 128, usage: GPUBufferUsage.INDEX});
let commandEncoder149 = device0.createCommandEncoder({});
let textureView179 = texture49.createView({dimension: '2d-array'});
let texture156 = device0.createTexture({
  size: [195, 12, 1],
  mipLevelCount: 3,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView180 = texture85.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
try {
renderPassEncoder0.setVertexBuffer(0, buffer108);
} catch {}
let pipeline34 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute2'}});
try {
  await promise19;
} catch {}
await gc();
let buffer146 = device0.createBuffer({size: 148, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let textureView181 = texture127.createView({dimension: '2d-array'});
let texture157 = device0.createTexture({
  label: '\u86d3\u{1fbde}\u97dd',
  size: {width: 4, height: 6, depthOrArrayLayers: 32},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder12.setBindGroup(3, bindGroup14, [0]);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline31);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(2, buffer107, 0, 498);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let buffer147 = device0.createBuffer({size: 320, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder150 = device0.createCommandEncoder({});
let texture158 = device0.createTexture({
  size: [32, 48, 1],
  format: 'astc-8x8-unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture159 = device0.createTexture({
  size: [195],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder20.beginOcclusionQuery(835);
} catch {}
try {
renderPassEncoder20.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup36, [0]);
} catch {}
try {
commandEncoder89.copyTextureToTexture({
  texture: texture144,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder109.resolveQuerySet(querySet2, 5, 5, buffer76, 0);
} catch {}
let commandEncoder151 = device0.createCommandEncoder({});
let textureView182 = texture153.createView({arrayLayerCount: 1});
try {
renderPassEncoder16.setPipeline(pipeline20);
} catch {}
let arrayBuffer8 = buffer143.getMappedRange(16);
try {
device0.queue.writeBuffer(buffer76, 0, new Float32Array(30661).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.187)), 7065, 0);
} catch {}
let shaderModule11 = device0.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

enable f16;

struct FragmentInput23 {
  @location(4) location_4: f16,
}

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

@group(0) @binding(58) var<storage, read_write> buffer150: array<array<array<array<array<f16, 12>, 4>, 2>, 3>>;

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

struct FragmentInput25 {
  @location(12) @interpolate(flat, centroid) location_12: vec2u,
}

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

struct FragmentInput21 {
  @location(13) @interpolate(flat, either) location_13: i32,
  @location(7) @interpolate(linear, center) location_7: f16,
  @invariant @builtin(position) position: vec4f,
}

@group(0) @binding(6) var<storage, read_write> buffer148: array<vec4f>;

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

struct T3 {
  f0: array<u32>,
}

struct FragmentInput26 {
  @location(1) location_1: i32,
}

struct T2 {
  f0: array<vec2<bool>>,
}

alias vec3b = vec3<bool>;

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

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

struct T4 {
  f0: array<u32>,
}

struct FragmentInput22 {
  @builtin(sample_index) sample_index: u32,
  @location(10) location_10: vec2u,
  @location(5) @interpolate(flat, center) location_5: vec4u,
}

struct T1 {
  f0: array<vec4f>,
}

@group(0) @binding(43) var<uniform> buffer149: array<vec4u, 1>;

struct FragmentOutput6 {
  @builtin(sample_mask) sample_mask: u32,
  @location(0) @interpolate(flat, center) location_0: i32,
}

struct FragmentInput24 {
  @location(8) location_8: i32,
}

struct T5 {
  f0: array<u32>,
}

var<workgroup> vw13: atomic<u32>;

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

struct T0 {
  @size(104) f0: array<array<array<array<vec4i, 1>, 1>, 6>, 1>,
}

/* used global variables: buffer149 */
@vertex
fn vertex13() -> @builtin(position) vec4f {
  var out: vec4f;
  let vf129: vec4h = floor(vec4h(unconst_f16(19199.0), unconst_f16(2167.3), unconst_f16(598.0), unconst_f16(3139.8)));
  var vf130: vec4h = (vec4h(unconst_f16(41471.3), unconst_f16(-13055.7), unconst_f16(30836.6), unconst_f16(2689.2)) % unconst_f16(8492.1));
  let vf131: u32 = buffer149[0][unconst_u32(196788037)];
  let vf132: vec4<bool> = (vec4h(unconst_f16(1497.4), unconst_f16(58642.9), unconst_f16(7151.0), unconst_f16(5792.3)) > vec4h(unconst_f16(17744.5), unconst_f16(22221.3), unconst_f16(10938.6), unconst_f16(15722.8)));
  return out;
  _ = buffer149;
}

/* used global variables: buffer148 */
@fragment
fn fragment9() -> @location(200) @interpolate(perspective) i32 {
  var out: i32;
  var vf133: vec3h = normalize(vec3h(unconst_f16(14812.0), unconst_f16(9815.9), unconst_f16(4124.2)));
  var vf134: f32 = (*&buffer148)[unconst_u32(302583652)][unconst_u32(491742538)];
  if bool(pack4xI8(bitcast<vec4i>((*&buffer148)[unconst_i32(158046276)].rrbb))) {
  out = i32((*&buffer148)[arrayLength(&(*&buffer148)) - 1][1]);
  buffer148[unconst_u32(166993717)] -= (*&buffer148)[pack4x8snorm(buffer148[unconst_i32(132989551)])];
  buffer148[unconst_u32(842554517)] = vec4f(f32(any(unconst_bool(false))));
  let vf135: u32 = pack2x16float(vec2f(unconst_f32(0.08346), unconst_f32(0.01098)));
  return out;
  _ = buffer148;
}
  vf134 += buffer148[unconst_u32(2415636278)][2];
  buffer148[unconst_u32(231080225)] *= vec4f(exp(vec2h(unconst_f16(6742.3), unconst_f16(18722.2))).rgrr.xxwy);
  let ptr62: ptr<storage, vec4f, read_write> = &(*&buffer148)[u32(buffer148[arrayLength(&buffer148)].a)];
  var vf136: vec4f = mix(vec4f(unconst_f32(-0.04883), unconst_f32(0.1386), unconst_f32(0.00339e-26), unconst_f32(0.1571e-10)), vec4f(unconst_f32(0.06551e7), unconst_f32(0.1455), unconst_f32(0.08652), unconst_f32(0.2784e-34)), (*&buffer148)[arrayLength(&(*&buffer148))]);
  var vf137: vec3f = floor(vec3f(unconst_f32(0.1611), unconst_f32(0.07655), unconst_f32(0.1068e-37)));
  vf134 = buffer148[unconst_u32(1997415291)][unconst_u32(455359402)];
  let vf138: vec3f = floor(vec3f(unconst_f32(0.1764), unconst_f32(0.4967e9), unconst_f32(0.3764)));
  vf134 = f32(all((vec2u(unconst_u32(865431499), unconst_u32(562895858)) != vec2u(unconst_u32(182648567), unconst_u32(736703026)))));
  return out;
  _ = buffer148;
}

/* used global variables: buffer148 */
@fragment
fn fragment10(@location(11) location_11: vec4h, a1: FragmentInput21, @location(14) location_14: i32, @location(9) @interpolate(linear) location_9: vec2h, a4: FragmentInput22, a5: FragmentInput23, a6: FragmentInput24, a7: FragmentInput25, a8: FragmentInput26, @location(3) @interpolate(flat, centroid) location_3: vec2i) -> FragmentOutput6 {
  var out: FragmentOutput6;
  buffer148[unconst_u32(970581037)] -= unpack4x8unorm(a7.location_12[unconst_u32(569743519)]);
  let vf139: vec3h = select(vec3h(unconst_f16(14820.9), unconst_f16(-5140.4), unconst_f16(12614.7)), vec3h(unconst_f16(3997.2), unconst_f16(1341.9), unconst_f16(1553.3)), unconst_bool(true));
  let vf140: vec4u = a4.location_5;
  var vf141: u32 = a4.sample_index;
  return out;
  _ = buffer148;
}

/* used global variables: buffer148, buffer149, buffer150 */
@compute @workgroup_size(4, 1, 1)
fn compute9(a0: ComputeInput11, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(global_invocation_id) global_invocation_id: vec3u, a4: ComputeInput12) {
  let ptr63: ptr<storage, f16, read_write> = &(*&buffer150)[unconst_u32(3298911790)][unconst_u32(314762945)][1][unconst_u32(178023975)][11];
  buffer148[unconst_u32(14337052)] = vec4f(bitcast<f32>(arrayLength(&(*&buffer150))));
  let ptr64: ptr<storage, f16, read_write> = &(*&buffer150)[u32((*&buffer150)[arrayLength(&(*&buffer150))][unconst_u32(634643327)][1][unconst_u32(181017172)][unconst_u32(2503035532)])][2][1][unconst_u32(243242339)][unconst_u32(82657804)];
  let ptr65: ptr<uniform, vec4u> = &(*&buffer149)[u32((*&buffer150)[unconst_i32(474804814)][2][1][3][11])];
  for (var jj48=0u; jj48<5; jj48++) { buffer150[unconst_u32(980817519)][jj48][unconst_u32(529002089)][unconst_u32(17410122)][unconst_u32(18611727)] = vec4h((*ptr65).yyyy).r; }
  let ptr66: ptr<storage, f16, read_write> = &(*&buffer150)[unconst_u32(788813709)][u32(buffer150[unconst_u32(375843179)][unconst_u32(3848579496)][u32(buffer150[unconst_u32(86962486)][unconst_u32(668139833)][unconst_u32(195718206)][3][11])][3][unconst_u32(1591934726)])][1][unconst_u32(265181609)][unconst_u32(626930598)];
  let ptr67: ptr<storage, f16, read_write> = &buffer150[unconst_u32(670469003)][2][1][3][unconst_u32(668771050)];
  atomicCompareExchangeWeak(&vw13, unconst_u32(1827201006), unconst_u32(463310173));
  _ = buffer148;
  _ = buffer149;
  _ = buffer150;
}`,
});
let bindGroup80 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 3, resource: textureView17}, {binding: 1, resource: externalTexture3}],
});
let texture160 = device0.createTexture({
  size: [390],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler25 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.27,
  compare: 'greater',
});
try {
renderPassEncoder0.setIndexBuffer(buffer90, 'uint16', 74, 211);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
commandEncoder102.resolveQuerySet(querySet1, 5, 2, buffer90, 0);
} catch {}
let buffer151 = device0.createBuffer({size: 31568, usage: GPUBufferUsage.INDIRECT});
let texture161 = device0.createTexture({
  size: [16],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView183 = texture110.createView({label: '\u35a4\u0db9\u6d83\u071d\u{1fbec}\u93eb', mipLevelCount: 1});
try {
computePassEncoder2.setBindGroup(0, bindGroup62);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup6, new Uint32Array(64), 0, 1);
} catch {}
try {
renderBundleEncoder18.setBindGroup(3, bindGroup11, new Uint32Array(1004), 25, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer64, 24, new Float32Array(17611).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.5062)), 4955, 4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas2);
let texture162 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  format: 'astc-5x4-unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let arrayBuffer9 = buffer143.getMappedRange(0, 0);
try {
buffer96.unmap();
} catch {}
document.body.prepend(img3);
let buffer152 = device0.createBuffer({size: 40, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let texture163 = device0.createTexture({
  size: [195, 12, 1],
  mipLevelCount: 1,
  format: 'r8snorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture164 = device0.createTexture({size: {width: 4}, mipLevelCount: 1, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_SRC});
let renderPassEncoder21 = commandEncoder148.beginRenderPass({
  colorAttachments: [{
  view: textureView33,
  clearValue: { r: 601.7, g: 238.1, b: -210.6, a: 30.16, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 624318024,
});
try {
computePassEncoder3.setBindGroup(0, bindGroup76);
} catch {}
try {
computePassEncoder4.setBindGroup(3, bindGroup35, new Uint32Array(683), 16, 0);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(5, buffer118, 0, 4);
} catch {}
try {
commandEncoder94.clearBuffer(buffer129);
} catch {}
let pipeline35 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {5_373: 1}}});
let commandEncoder152 = device0.createCommandEncoder({});
let texture165 = device0.createTexture({
  size: [16, 24, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'astc-8x6-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture166 = device0.createTexture({size: {width: 195}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC});
let textureView184 = texture31.createView({mipLevelCount: 1});
try {
computePassEncoder7.setBindGroup(3, bindGroup75, [0, 0]);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(2670), 415, 1);
} catch {}
try {
commandEncoder145.clearBuffer(buffer76);
} catch {}
document.body.append(img1);
let commandEncoder153 = device0.createCommandEncoder({});
let textureView185 = texture161.createView({});
let texture167 = device0.createTexture({
  size: [390, 240, 1],
  mipLevelCount: 3,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView186 = texture127.createView({baseMipLevel: 0});
let externalTexture29 = device0.importExternalTexture({source: videoFrame12});
try {
commandEncoder99.copyTextureToBuffer({
  texture: texture86,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3302 */
  offset: 3302,
  bytesPerRow: 24064,
  buffer: buffer91,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer75, 92, new Uint32Array(5512).map((_, i) => i * 3), 103, 12);
} catch {}
let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteRp431', transfer: 'hlg'} });
let buffer153 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let commandEncoder154 = device0.createCommandEncoder();
let texture168 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1},
  format: 'astc-10x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture169 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder1.setBindGroup(2, bindGroup75, new Uint32Array(1575), 686, 2);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup63);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup74, new Uint32Array(732), 330, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(5, buffer152, 0, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: img1,
  origin: { x: 0, y: 21 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 4, depthOrArrayLayers: 0});
} catch {}
let texture170 = device0.createTexture({
  size: {width: 780, height: 480, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'astc-10x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture171 = gpuCanvasContext3.getCurrentTexture();
let textureView187 = texture170.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder8.drawIndirect(buffer110, 40);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer112, 'uint16', 32, 25);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup9, new Uint32Array(4), 0, 0);
} catch {}
try {
commandEncoder37.copyBufferToTexture({
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 248 */
  offset: 248,
  bytesPerRow: 1280,
  buffer: buffer147,
}, {
  texture: texture55,
  mipLevel: 3,
  origin: {x: 16, y: 5, z: 0},
  aspect: 'all',
}, {width: 9, height: 36, depthOrArrayLayers: 0});
} catch {}
let pipeline36 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {5_373: 1}}});
let buffer154 = device0.createBuffer({
  size: 276,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder155 = device0.createCommandEncoder({});
let texture172 = device0.createTexture({
  size: [780, 48, 1],
  mipLevelCount: 2,
  format: 'astc-12x12-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView188 = texture158.createView({dimension: '2d-array', baseMipLevel: 0});
try {
computePassEncoder6.setBindGroup(3, bindGroup35, new Uint32Array(1893), 94, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer55, 3_780);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer54, 0);
} catch {}
try {
renderBundleEncoder22.setBindGroup(3, bindGroup67, new Uint32Array(6573), 1_577, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer112, 'uint32', 8, 75);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(1, buffer9);
} catch {}
let buffer155 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder156 = device0.createCommandEncoder();
let texture173 = device0.createTexture({
  size: [780, 48, 1],
  mipLevelCount: 3,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder8.drawIndexed(2, 0, 0, 89_869_243);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer53, 'uint16', 2, 1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(5, buffer104, 0, 387);
} catch {}
try {
buffer95.unmap();
} catch {}
let bindGroup81 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout9,
  entries: [{binding: 1, resource: externalTexture13}, {binding: 3, resource: textureView17}],
});
let texture174 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture175 = device0.createTexture({
  size: {width: 32, height: 48, depthOrArrayLayers: 1},
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView189 = texture61.createView({});
try {
computePassEncoder6.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup63);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer110, 36);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline18);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(6, buffer152, 8, 2);
} catch {}
try {
renderBundleEncoder12.insertDebugMarker('\u{1fa4a}');
} catch {}
let bindGroup82 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []});
let commandEncoder157 = device0.createCommandEncoder({});
let texture176 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'astc-10x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture177 = device0.createTexture({
  size: [780, 48, 1],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture30 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'});
try {
computePassEncoder1.setBindGroup(3, bindGroup35);
} catch {}
try {
renderPassEncoder7.draw(72, 0, 59_612_385);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer55, 1_504);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup36, [0]);
} catch {}
try {
commandEncoder150.clearBuffer(buffer58);
} catch {}
try {
device0.queue.writeBuffer(buffer64, 80, new Float32Array(2470).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.517)), 214, 4);
} catch {}
let bindGroup83 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 0, resource: {buffer: buffer75}},
    {binding: 557, resource: externalTexture7},
    {binding: 176, resource: {buffer: buffer107}},
  ],
});
let texture178 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  dimension: '2d',
  format: 'astc-8x8-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder7.drawIndexed(24, 0, 1, 435_406_195);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer151, 2_904);
} catch {}
try {
renderBundleEncoder22.setBindGroup(1, bindGroup36, [0]);
} catch {}
document.body.append(img1);
let autogeneratedBindGroupLayout14 = pipeline9.getBindGroupLayout(0);
let commandEncoder158 = device0.createCommandEncoder();
let texture179 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture180 = device0.createTexture({
  size: [780, 480, 1],
  format: 'astc-6x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView190 = texture138.createView({});
let sampler26 = device0.createSampler({addressModeU: 'mirror-repeat'});
try {
renderPassEncoder7.draw(385, 0, 1_518_322_128);
} catch {}
try {
renderPassEncoder7.drawIndexed(17, 0, 11, -1_876_588_228);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(5, buffer62);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup57);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer1, 'uint16', 68, 23);
} catch {}
try {
device0.queue.writeBuffer(buffer56, 156, new Float32Array(3065).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.274)), 384, 440);
} catch {}
let promise20 = device0.queue.onSubmittedWorkDone();
let texture181 = device0.createTexture({
  size: [1560, 96, 1],
  mipLevelCount: 1,
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture182 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView191 = texture90.createView({baseArrayLayer: 0});
try {
computePassEncoder4.setBindGroup(2, bindGroup14, [0]);
} catch {}
try {
renderPassEncoder7.draw(11, 0, 300_966_473);
} catch {}
try {
renderPassEncoder7.drawIndexed(6, 0, 2, 1_258_959_994);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer89, 40);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, buffer92);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline5);
} catch {}
try {
commandEncoder87.copyBufferToTexture({
  /* bytesInLastRow: 1060 widthInBlocks: 265 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1836 */
  offset: 1836,
  bytesPerRow: 4864,
  rowsPerImage: 254,
  buffer: buffer118,
}, {
  texture: texture181,
  mipLevel: 0,
  origin: {x: 12, y: 19, z: 0},
  aspect: 'all',
}, {width: 265, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder79.copyTextureToTexture({
  texture: texture92,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 12},
  aspect: 'all',
},
{
  texture: texture156,
  mipLevel: 2,
  origin: {x: 10, y: 1, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let imageData25 = new ImageData(16, 24);
let autogeneratedBindGroupLayout15 = pipeline30.getBindGroupLayout(0);
let texture183 = device0.createTexture({
  size: [390, 240, 1],
  format: 'astc-10x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder6.setBindGroup(1, bindGroup65);
} catch {}
try {
renderPassEncoder7.end();
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer120, 'uint16', 10, 13);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline13);
} catch {}
let commandBuffer4 = commandEncoder105.finish();
let texture184 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture185 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 14},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView192 = texture15.createView({
  label: '\u5ff8\u2057\ua242\u0980\uddd7\u{1f87e}\ue699\u7500\u37a5',
  dimension: '2d-array',
  mipLevelCount: 1,
});
try {
renderBundleEncoder27.setIndexBuffer(buffer9, 'uint32', 0, 28);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(4, buffer132);
} catch {}
let bindGroup84 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 10, resource: {buffer: buffer154}}]});
let buffer156 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder159 = device0.createCommandEncoder();
let texture186 = device0.createTexture({
  size: {width: 16, height: 24, depthOrArrayLayers: 5},
  format: 'rgb9e5ufloat',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView193 = texture64.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder17.setIndexBuffer(buffer52, 'uint32', 4, 2);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
let texture187 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  format: 'astc-10x6-unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder0.setBindGroup(1, bindGroup81, new Uint32Array(357), 24, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer156, 0, new Uint16Array(29572).map((_, i) => i + 9), 8554, 4);
} catch {}
let buffer157 = device0.createBuffer({size: 101, usage: GPUBufferUsage.STORAGE});
let commandEncoder160 = device0.createCommandEncoder({});
let texture188 = device0.createTexture({
  size: [780, 480, 1],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'astc-5x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder17.setStencilReference(2505);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(1, buffer43, 0, 3);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer154, 'uint32', 32, 23);
} catch {}
try {
device0.queue.writeBuffer(buffer129, 0, new Float32Array(13657).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.319)), 1329, 0);
} catch {}
let commandEncoder161 = device0.createCommandEncoder({});
let commandBuffer5 = commandEncoder45.finish({});
let texture189 = device0.createTexture({
  size: [390, 240, 1],
  format: 'astc-10x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView194 = texture159.createView({});
try {
renderPassEncoder2.setIndexBuffer(buffer74, 'uint16', 10, 11);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline26);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let promise21 = device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x3be68f99},
  fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint'}]},
  vertex: {
    module: shaderModule6,
    entryPoint: 'vertex6',
    constants: {},
    buffers: [
      {
        arrayStride: 920,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 8, shaderLocation: 13},
          {format: 'uint32x2', offset: 224, shaderLocation: 12},
          {format: 'unorm8x2', offset: 96, shaderLocation: 9},
          {format: 'float32x4', offset: 4, shaderLocation: 4},
          {format: 'sint16x2', offset: 160, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'back', unclippedDepth: true},
});
document.body.append(canvas3);
let commandEncoder162 = device0.createCommandEncoder({});
let texture190 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView195 = texture5.createView({});
let promise22 = device0.queue.onSubmittedWorkDone();
let commandEncoder163 = device0.createCommandEncoder();
let textureView196 = texture49.createView({dimension: '2d-array'});
let textureView197 = texture69.createView({arrayLayerCount: 1});
try {
renderPassEncoder3.setBindGroup(1, bindGroup14, new Uint32Array(3460), 544, 1);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer108, 'uint16', 4, 1);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline18);
} catch {}
try {
commandEncoder49.clearBuffer(buffer76);
} catch {}
let bindGroup85 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 3, resource: textureView3},
    {binding: 6, resource: {buffer: buffer136}},
    {binding: 43, resource: {buffer: buffer106}},
    {binding: 58, resource: {buffer: buffer107}},
  ],
});
let commandEncoder164 = device0.createCommandEncoder({});
let texture191 = device0.createTexture({
  size: [780, 480, 1],
  mipLevelCount: 4,
  format: 'astc-5x4-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder17.setIndexBuffer(buffer107, 'uint32', 124, 478);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup81, new Uint32Array(1640), 154, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let texture192 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'astc-10x8-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture193 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder3.setBindGroup(0, bindGroup76);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer38, 'uint16', 0, 4);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline20);
} catch {}
try {
commandEncoder127.copyTextureToBuffer({
  texture: texture185,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7252 */
  offset: 7252,
  bytesPerRow: 0,
  rowsPerImage: 1738,
  buffer: buffer91,
}, {width: 0, height: 0, depthOrArrayLayers: 2});
} catch {}
try {
commandEncoder143.resolveQuerySet(querySet0, 92, 0, buffer80, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: canvas1,
  origin: { x: 7, y: 13 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 204, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 59, height: 10, depthOrArrayLayers: 0});
} catch {}
let texture194 = device0.createTexture({
  size: {width: 8, height: 600, depthOrArrayLayers: 1},
  format: 'astc-8x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView198 = texture107.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 3});
try {
computePassEncoder21.setBindGroup(1, bindGroup58, [0]);
} catch {}
let texture195 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture196 = device0.createTexture({
  size: [780, 480, 1],
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder6.setIndexBuffer(buffer145, 'uint16', 2, 81);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup37, new Uint32Array(1887), 21, 0);
} catch {}
let bindGroup86 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: []});
let buffer158 = device0.createBuffer({size: 236, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder165 = device0.createCommandEncoder({});
let texture197 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  format: 'rgb9e5ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler27 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 86.30,
  maxAnisotropy: 1,
});
try {
renderPassEncoder4.setIndexBuffer(buffer137, 'uint32', 4, 0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer55, 'uint16', 3_990, 911);
} catch {}
let pipeline37 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule7,
    constants: {override20: 1, override18: 1},
    buffers: [
      {
        arrayStride: 204,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 4, shaderLocation: 11},
          {format: 'sint32x3', offset: 0, shaderLocation: 6},
          {format: 'float32x3', offset: 36, shaderLocation: 8},
          {format: 'float16x2', offset: 28, shaderLocation: 13},
          {format: 'snorm8x4', offset: 4, shaderLocation: 4},
          {format: 'sint32x3', offset: 0, shaderLocation: 15},
          {format: 'snorm8x4', offset: 104, shaderLocation: 5},
          {format: 'float32x3', offset: 16, shaderLocation: 14},
          {format: 'float32x4', offset: 12, shaderLocation: 12},
          {format: 'unorm16x2', offset: 4, shaderLocation: 10},
          {format: 'uint32', offset: 16, shaderLocation: 7},
          {format: 'uint32', offset: 8, shaderLocation: 9},
          {format: 'uint32', offset: 4, shaderLocation: 3},
        ],
      },
      {arrayStride: 428, attributes: [{format: 'snorm16x4', offset: 68, shaderLocation: 0}]},
    ],
  },
  primitive: {cullMode: 'back', unclippedDepth: true},
});
let autogeneratedBindGroupLayout16 = pipeline22.getBindGroupLayout(0);
let commandBuffer6 = commandEncoder7.finish();
let texture198 = device0.createTexture({
  size: [390, 240, 1],
  mipLevelCount: 2,
  format: 'astc-10x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture199 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView199 = texture184.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderBundleEncoder3.setPipeline(pipeline31);
} catch {}
let arrayBuffer10 = buffer143.getMappedRange(8, 0);
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer79, 20, new DataView(new Uint8Array(3790).map((_, i) => i).buffer), 80, 16);
} catch {}
await gc();
let bindGroup87 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 81, resource: externalTexture10},
    {binding: 2, resource: textureView100},
    {binding: 3, resource: textureView197},
    {binding: 251, resource: {buffer: buffer5}},
    {binding: 86, resource: {buffer: buffer116}},
    {binding: 5, resource: {buffer: buffer37, size: 528}},
    {binding: 166, resource: textureView138},
    {binding: 141, resource: {buffer: buffer80}},
    {binding: 15, resource: {buffer: buffer116}},
    {binding: 1, resource: externalTexture26},
    {binding: 11, resource: textureView26},
    {binding: 6, resource: textureView3},
    {binding: 12, resource: textureView186},
    {binding: 148, resource: {buffer: buffer82}},
    {binding: 220, resource: {buffer: buffer21, size: 884}},
    {binding: 4, resource: {buffer: buffer110}},
    {binding: 152, resource: textureView87},
    {binding: 125, resource: textureView151},
    {binding: 106, resource: {buffer: buffer107, offset: 256, size: 2136}},
    {binding: 0, resource: {buffer: buffer116}},
  ],
});
let buffer159 = device0.createBuffer({size: 124, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture200 = device0.createTexture({
  size: [16, 24, 55],
  format: 'r8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture31 = device0.importExternalTexture({source: videoFrame11});
try {
computePassEncoder10.setBindGroup(3, bindGroup31);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer107, 132);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup83);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer55, 'uint16', 38, 333);
} catch {}
try {
renderBundleEncoder26.insertDebugMarker('\u{1fa0e}');
} catch {}
let pipeline38 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x289e374},
  fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint', writeMask: 0}]},
  vertex: {
    module: shaderModule1,
    constants: {},
    buffers: [
      {
        arrayStride: 28,
        attributes: [
          {format: 'sint8x4', offset: 0, shaderLocation: 7},
          {format: 'unorm8x4', offset: 4, shaderLocation: 11},
          {format: 'uint8x2', offset: 0, shaderLocation: 4},
          {format: 'snorm16x4', offset: 8, shaderLocation: 6},
          {format: 'unorm16x4', offset: 4, shaderLocation: 2},
          {format: 'float32x3', offset: 0, shaderLocation: 8},
          {format: 'sint16x4', offset: 0, shaderLocation: 13},
          {format: 'float32x3', offset: 0, shaderLocation: 14},
          {format: 'snorm8x4', offset: 4, shaderLocation: 5},
          {format: 'uint8x4', offset: 4, shaderLocation: 3},
          {format: 'snorm8x4', offset: 0, shaderLocation: 9},
          {format: 'uint32x4', offset: 0, shaderLocation: 15},
          {format: 'sint16x2', offset: 4, shaderLocation: 10},
          {format: 'unorm8x2', offset: 6, shaderLocation: 12},
          {format: 'uint32', offset: 16, shaderLocation: 1},
          {format: 'sint32x3', offset: 16, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let commandEncoder166 = device0.createCommandEncoder();
let texture201 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'astc-10x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView200 = texture55.createView({dimension: '2d-array', baseMipLevel: 2, mipLevelCount: 1});
try {
computePassEncoder3.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup74, new Uint32Array(5798), 853, 0);
} catch {}
await gc();
let bindGroup88 = device0.createBindGroup({
  label: '\u6e96\u5aa4\ua7e2',
  layout: autogeneratedBindGroupLayout15,
  entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer158}}],
});
let texture202 = device0.createTexture({
  size: [1560, 96, 1],
  mipLevelCount: 4,
  format: 'astc-6x6-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView201 = texture178.createView({mipLevelCount: 1});
try {
commandEncoder95.copyTextureToTexture({
  texture: texture89,
  mipLevel: 0,
  origin: {x: 1, y: 8, z: 0},
  aspect: 'all',
},
{
  texture: texture12,
  mipLevel: 2,
  origin: {x: 3, y: 4, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer63, 116, new Uint32Array(10942).map((_, i) => i * 7), 1959, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame11,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 169, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let imageData26 = new ImageData(12, 120);
try {
globalThis.someLabel = commandEncoder71.label;
} catch {}
let texture203 = device0.createTexture({
  size: {width: 780, height: 480, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'astc-10x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder22.setPipeline(pipeline27);
} catch {}
try {
buffer75.unmap();
} catch {}
let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt2020', transfer: 'bt1361ExtendedColourGamut'} });
let texture204 = device0.createTexture({
  size: {width: 16, height: 24, depthOrArrayLayers: 25},
  format: 'depth16unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture205 = device0.createTexture({
  size: {width: 780},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder22 = commandEncoder145.beginRenderPass({
  colorAttachments: [{
  view: textureView130,
  clearValue: { r: -953.6, g: -849.1, b: -286.5, a: 878.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder5.setIndexBuffer(buffer112, 'uint32', 36, 64);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer112, 'uint16', 2, 15);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
document.body.prepend(img0);
let texture206 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 1},
  format: 'astc-4x4-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView202 = texture185.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 6});
try {
computePassEncoder10.setBindGroup(0, bindGroup86, new Uint32Array(208), 1, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline12);
} catch {}
try {
commandEncoder136.copyTextureToBuffer({
  texture: texture165,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 720 */
  offset: 720,
  buffer: buffer91,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise20;
} catch {}
let commandEncoder167 = device0.createCommandEncoder({});
let texture207 = device0.createTexture({
  size: [390, 240, 1],
  mipLevelCount: 2,
  format: 'astc-10x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder18.setBindGroup(2, bindGroup53, new Uint32Array(2196), 684, 1);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer107, 'uint32', 160, 652);
} catch {}
try {
commandEncoder100.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1310 */
  offset: 1310,
  rowsPerImage: 724,
  buffer: buffer11,
}, {
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder143.clearBuffer(buffer140);
} catch {}
try {
device0.queue.writeBuffer(buffer154, 28, new Float32Array(11713).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.534)), 1166, 12);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame26,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 14, y: 13, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let querySet3 = device0.createQuerySet({type: 'timestamp', count: 275});
let textureView203 = texture161.createView({});
let textureView204 = texture1.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
renderPassEncoder13.setBindGroup(2, bindGroup64, new Uint32Array(1771), 82, 2);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline26);
} catch {}
try {
device0.queue.writeBuffer(buffer60, 12, new Float16Array(13329).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.807)), 101, 24);
} catch {}
let pipeline39 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule4, constants: {}, targets: [{format: 'rg8sint', writeMask: GPUColorWrite.RED}]},
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex1',
    buffers: [
      {
        arrayStride: 12,
        attributes: [
          {format: 'uint8x2', offset: 2, shaderLocation: 1},
          {format: 'snorm8x4', offset: 0, shaderLocation: 11},
          {format: 'uint32x3', offset: 0, shaderLocation: 4},
          {format: 'sint32', offset: 0, shaderLocation: 13},
          {format: 'unorm16x2', offset: 0, shaderLocation: 5},
          {format: 'snorm16x4', offset: 0, shaderLocation: 8},
          {format: 'sint32x3', offset: 0, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 64,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x3', offset: 8, shaderLocation: 3},
          {format: 'float32', offset: 4, shaderLocation: 2},
          {format: 'float16x2', offset: 16, shaderLocation: 9},
          {format: 'float32x4', offset: 12, shaderLocation: 14},
          {format: 'uint32', offset: 12, shaderLocation: 15},
          {format: 'float16x2', offset: 12, shaderLocation: 6},
          {format: 'sint8x4', offset: 12, shaderLocation: 7},
          {format: 'unorm8x4', offset: 0, shaderLocation: 12},
          {format: 'sint32x3', offset: 4, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'back', unclippedDepth: true},
});
let bindGroup89 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout6,
  entries: [{binding: 3, resource: textureView0}, {binding: 1, resource: externalTexture5}],
});
let texture208 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgb9e5ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture209 = device0.createTexture({
  size: [780],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView205 = texture207.createView({mipLevelCount: 1});
try {
renderBundleEncoder2.setBindGroup(0, bindGroup84, new Uint32Array(1948), 305, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer52, 'uint16', 14, 3);
} catch {}
let texture210 = device0.createTexture({
  size: {width: 780, height: 480, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'astc-10x10-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder5.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline38);
} catch {}
let buffer160 = device0.createBuffer({size: 192, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder168 = device0.createCommandEncoder({});
let texture211 = device0.createTexture({
  size: [32, 48, 1],
  mipLevelCount: 3,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder4.setBindGroup(0, bindGroup38);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup89);
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture55,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture54,
  mipLevel: 0,
  origin: {x: 28, y: 95, z: 0},
  aspect: 'all',
},
{width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
renderBundleEncoder3.label = '\u01dd\u8325';
} catch {}
let texture212 = device0.createTexture({
  size: [2, 2, 14],
  dimension: '2d',
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.setBindGroup(2, bindGroup66, new Uint32Array(1615), 270, 1);
} catch {}
try {
renderPassEncoder16.setStencilReference(395);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(1, buffer8);
} catch {}
try {
buffer43.unmap();
} catch {}
let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte240m', transfer: 'gamma28curve'} });
let textureView206 = texture212.createView({
  label: '\u0cfa\u0c95\ub60f\u0675\uc981\u03a0\u91fc',
  dimension: 'cube-array',
  baseMipLevel: 0,
  baseArrayLayer: 1,
  arrayLayerCount: 6,
});
let externalTexture32 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'});
try {
computePassEncoder23.setPipeline(pipeline36);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup3, [0]);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(1596), 294, 1);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer112, 'uint16', 14, 8);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(5, buffer8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 11, y: 30, z: 0},
  aspect: 'all',
}, new Uint8Array(122).fill(204), /* required buffer size: 122 */
{offset: 122}, {width: 101, height: 1, depthOrArrayLayers: 0});
} catch {}
let img5 = await imageWithData(3, 19, '#10101010', '#20202020');
let texture213 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 76},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler28 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 72.50});
try {
renderPassEncoder12.setScissorRect(193, 7, 290, 2);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer96, 0);
} catch {}
try {
buffer38.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: videoFrame24,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 122, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(22); };
} catch {}
let buffer161 = device0.createBuffer({size: 72, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let texture214 = device0.createTexture({
  size: [195, 120, 17],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let externalTexture33 = device0.importExternalTexture({source: videoFrame2});
try {
renderPassEncoder3.setBindGroup(2, bindGroup77, new Uint32Array(3860), 26, 0);
} catch {}
try {
commandEncoder10.copyTextureToTexture({
  texture: texture164,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture62,
  mipLevel: 0,
  origin: {x: 98, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer2, 4, new Float32Array(8821).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.534)), 791, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder169 = device0.createCommandEncoder({});
let textureView207 = texture213.createView({format: 'rgba16sint'});
try {
computePassEncoder11.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder2.pushDebugGroup('\u745e');
} catch {}
let buffer162 = device0.createBuffer({size: 384, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder170 = device0.createCommandEncoder({});
let textureView208 = texture214.createView({baseMipLevel: 0});
let textureView209 = texture21.createView({baseMipLevel: 0, baseArrayLayer: 0});
try {
renderPassEncoder17.setIndexBuffer(buffer1, 'uint16', 46, 81);
} catch {}
let bindGroup90 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 2, resource: textureView100},
    {binding: 141, resource: {buffer: buffer136}},
    {binding: 251, resource: {buffer: buffer45}},
    {binding: 4, resource: {buffer: buffer116}},
    {binding: 166, resource: textureView88},
    {binding: 15, resource: {buffer: buffer116}},
    {binding: 1, resource: externalTexture19},
    {binding: 152, resource: textureView90},
    {binding: 0, resource: {buffer: buffer107, offset: 0, size: 940}},
    {binding: 148, resource: {buffer: buffer35}},
    {binding: 3, resource: textureView154},
    {binding: 220, resource: {buffer: buffer120}},
    {binding: 125, resource: textureView29},
    {binding: 81, resource: externalTexture22},
    {binding: 86, resource: {buffer: buffer37}},
    {binding: 11, resource: textureView38},
    {binding: 6, resource: textureView3},
    {binding: 106, resource: {buffer: buffer107}},
    {binding: 5, resource: {buffer: buffer116}},
    {binding: 12, resource: textureView186},
  ],
});
let commandEncoder171 = device0.createCommandEncoder({});
try {
renderPassEncoder11.setIndexBuffer(buffer108, 'uint32', 4, 1);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(1, buffer71, 0, 3);
} catch {}
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 14,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let buffer163 = device0.createBuffer({size: 228, usage: GPUBufferUsage.COPY_DST});
let commandEncoder172 = device0.createCommandEncoder();
let commandBuffer7 = commandEncoder163.finish();
let texture215 = device0.createTexture({
  size: [780, 480, 1],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder3.setBindGroup(1, bindGroup88);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer136, 'uint16', 60, 4);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
renderBundleEncoder0.insertDebugMarker('\ubc44');
} catch {}
await gc();
let commandEncoder173 = device0.createCommandEncoder({});
let textureView210 = texture212.createView({dimension: 'cube-array', arrayLayerCount: 6});
try {
renderBundleEncoder1.setIndexBuffer(buffer93, 'uint32', 32, 25);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline26);
} catch {}
try {
  await promise22;
} catch {}
let commandEncoder174 = device0.createCommandEncoder({});
try {
commandEncoder38.insertDebugMarker('\u06bc');
} catch {}
let promise23 = device0.queue.onSubmittedWorkDone();
try {
  await promise23;
} catch {}
let bindGroup91 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 43, resource: {buffer: buffer158}},
    {binding: 6, resource: {buffer: buffer110}},
    {binding: 58, resource: {buffer: buffer107}},
    {binding: 3, resource: textureView0},
  ],
});
let texture216 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder15.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer90, 'uint16', 6, 234);
} catch {}
let autogeneratedBindGroupLayout17 = pipeline3.getBindGroupLayout(0);
let texture217 = device0.createTexture({size: [8], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderBundleEncoder1.setBindGroup(0, bindGroup49, new Uint32Array(25), 11, 0);
} catch {}
let pipeline40 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule6,
  constants: {},
  targets: [{
  format: 'r16sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule9,
    constants: {},
    buffers: [
      {
        arrayStride: 12,
        stepMode: 'instance',
        attributes: [{format: 'uint8x2', offset: 0, shaderLocation: 3}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
let buffer164 = device0.createBuffer({size: 148, usage: GPUBufferUsage.QUERY_RESOLVE});
let textureView211 = texture182.createView({mipLevelCount: 1});
try {
computePassEncoder3.setBindGroup(0, bindGroup56, new Uint32Array(120), 5, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline20);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture9.label = '\u{1fb7a}\u11d9\u014c';
} catch {}
let shaderModule12 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires pointer_composite_access;

enable f16;

@group(0) @binding(58) var<storage, read_write> buffer167: array<array<array<array<array<array<array<f16, 1>, 3>, 1>, 16>, 1>, 1>, 6>;

var<private> vp11: array<array<i32, 1>, 27> = array<array<i32, 1>, 27>(array(i32(306384506)), array<i32, 1>(), array(i32(425600027)), array<i32, 1>(), array(i32(189241111)), array(i32(613836695)), array<i32, 1>(i32(243277045)), array(i32(259924265)), array(i32(300242831)), array(i32(31819780)), array<i32, 1>(), array<i32, 1>(i32(1022644442)), array(i32(543973360)), array<i32, 1>(i32(672953362)), array(i32(448591984)), array(i32(202704976)), array(i32(551320201)), array<i32, 1>(i32(-202918266)), array<i32, 1>(), array(i32(-1842400409)), array(i32(129822122)), array<i32, 1>(), array<i32, 1>(), array<i32, 1>(), array(i32(17800868)), array<i32, 1>(), array<i32, 1>(i32(89215586)));

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

struct T3 {
  f0: array<T2>,
}

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

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

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

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

var<private> vp12 = modf(vec4f(0.2640e3, -0.1765, 0.2056, 0.1388));

@group(1) @binding(3) var<storage, read_write> buffer168: array<array<array<u32, 1648>, 1>>;

struct T0 {
  @size(104) f0: vec2i,
}

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

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

@group(1) @binding(115) var st14: texture_storage_2d_array<r32sint, write>;

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

struct T4 {
  f0: array<f32, 26>,
}

@group(0) @binding(43) var<uniform> buffer166: array<vec4i, 6>;

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

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

@group(2) @binding(138) var st15: texture_storage_2d<r32uint, read_write>;

@group(1) @binding(10) var<storage, read> buffer170: array<array<array<f16, 5>, 6>>;

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

var<private> vp10: array<f32, 1> = array(f32(0.02945e-6));

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

var<private> vp9: vec4u = vec4u(103201143, 1420125475, 461396148, 282816634);

/* used global variables: buffer166 */
@vertex @must_use
fn vertex14(@builtin(instance_index) instance_index: u32) -> @builtin(position) vec4f {
  var out: vec4f;
  for (var jj87=0u; jj87<3; jj87++) { vp10[jj87] *= bitcast<vec4f>(buffer166[5])[3]; }
  out += vec4f(bitcast<f32>(vp11[26][unconst_u32(136875352)]));
  let ptr68: ptr<private, vec4u> = &vp9;
  return out;
  _ = buffer166;
}

/* used global variables: buffer168, et15 */
@fragment
fn fragment11(@builtin(position) position: vec4f, a1: FragmentInput27, a2: FragmentInput28) -> @location(200) @interpolate(linear, sample) i32 {
  var out: i32;
  vp10[unconst_u32(99905190)] = bitcast<f32>(textureDimensions(et15).x);
  let ptr69: ptr<storage, u32, read_write> = &(*&buffer168)[arrayLength(&(*&buffer168))][0][1647];
  vp12.whole = unpack4x8unorm((*&buffer168)[arrayLength(&(*&buffer168))][0][1647]);
  let vf142: mat4x3f = (unconst_f32(0.8598e-1) * mat4x3f(unconst_f32(0.2608), unconst_f32(0.07464e31), unconst_f32(0.07892), unconst_f32(0.1136e9), unconst_f32(0.00560e33), unconst_f32(0.1388), unconst_f32(0.03617), unconst_f32(0.3922), unconst_f32(0.4709), unconst_f32(0.1029e11), unconst_f32(0.5366), unconst_f32(0.01415)));
  return out;
  _ = et15;
  _ = buffer168;
}

/* used global variables: buffer167, buffer168, st14, st15 */
@compute @workgroup_size(3, 1, 1)
fn compute10() {
  let ptr70: ptr<storage, f16, read_write> = &(*&buffer167)[unconst_u32(1139005338)][unconst_u32(387260768)][0][unconst_u32(53966115)][0][2][unconst_u32(100578843)];
  var vf143: vec4h = tanh(vec4h(unconst_f16(17862.8), unconst_f16(19441.9), unconst_f16(31034.3), unconst_f16(10930.1)));
  switch i32((*&buffer167)[unconst_u32(110991078)][0][unconst_u32(1318037802)][unconst_u32(348845946)][unconst_u32(461547965)][2][unconst_u32(1746344140)]) { 
  default: {
  let ptr71: ptr<storage, array<array<array<array<f16, 1>, 3>, 1>, 16>, read_write> = &buffer167[unconst_u32(101464342)][unconst_u32(220293226)][0];
  textureBarrier();
  buffer167[5][unconst_u32(189585770)][unconst_u32(97322354)][unconst_u32(1234143498)][unconst_u32(20633679)][unconst_u32(547721150)][unconst_u32(426389953)] = buffer167[5][unconst_u32(567369462)][0][15][0][2][0];
  let ptr72: ptr<storage, f16, read_write> = &buffer167[unconst_u32(463683007)][0][0][unconst_u32(57115250)][0][2][unconst_u32(541391999)];
  textureStore(st14, vec2i(unconst_i32(475989772), unconst_i32(84672903)), unconst_i32(141780332), vec4i(vec4i(unconst_i32(-646246507), unconst_i32(824903189), unconst_i32(22659480), unconst_i32(-115862765))));
  return;
  _ = st14;
  _ = buffer167;
}
case 529017198 {
  for (var jj43=0u; jj43<29; jj43++) { for (var jj56=0u; jj56<3; jj56++) { vp11[jj43][jj56] &= i32((*&buffer167)[5][0][0][unconst_u32(431480068)][unconst_u32(154786779)][unconst_u32(445277139)][0]); } }
  _ = buffer167;
}
  }
  var vf144: vec4h = sqrt(vec4h(unconst_f16(1456.6), unconst_f16(-21743.8), unconst_f16(829.4), unconst_f16(5695.5)));
  vf143 -= vec4h(buffer167[unconst_u32(265893568)][0][unconst_u32(1061344706)][unconst_u32(25673393)][0][2][0]);
  textureStore(st15, vec2i(unconst_i32(143188840), unconst_i32(638011858)), vec4u(vec4u(unconst_u32(1489363220), unconst_u32(225786917), unconst_u32(266926613), unconst_u32(215008414))));
  vp12 = modf(unpack4x8unorm((*&buffer168)[unconst_u32(4566049)][0][1647]));
  _ = st15;
  _ = buffer167;
  _ = buffer168;
  _ = st14;
}

/* used global variables: buffer167, buffer168, buffer170, st14, st15 */
@compute @workgroup_size(5, 1, 1)
fn compute11(@builtin(local_invocation_id) local_invocation_id: vec3u, a1: ComputeInput13, a2: ComputeInput14) {
  let ptr73: ptr<storage, array<f16, 1>, read_write> = &buffer167[5][unconst_u32(974541747)][unconst_u32(2072427982)][unconst_u32(3089607778)][0][2];
  let ptr74: ptr<storage, array<u32, 1648>, read_write> = &(*&buffer168)[arrayLength(&(*&buffer168))][0];
  textureStore(st15, vec2i(unconst_i32(-1292983303), unconst_i32(162344957)), vec4u(vec4u(unconst_u32(982815440), unconst_u32(599425360), unconst_u32(271619146), unconst_u32(25972289))));
  let ptr75: ptr<storage, f16, read> = &buffer170[arrayLength(&buffer170)][5][4];
  let ptr76: ptr<storage, array<f16, 5>, read> = &buffer170[arrayLength(&buffer170)][5];
  let ptr77: ptr<storage, array<f16, 1>, read_write> = &buffer167[5][0][unconst_u32(661736042)][unconst_u32(922773692)][0][unconst_u32(2151693175)];
  let ptr78: ptr<storage, f16, read_write> = &buffer167[unconst_u32(790962177)][0][0][15][unconst_u32(94312991)][2][unconst_u32(1236082833)];
  textureStore(st14, vec2i(unconst_i32(53434941), unconst_i32(251567993)), unconst_i32(94508328), vec4i(vec4i(unconst_i32(-99097030), unconst_i32(414866547), unconst_i32(678789207), unconst_i32(-747292677))));
  let ptr79: ptr<storage, f16, read> = &(*&buffer170)[u32((*&buffer167)[unconst_u32(853333726)][0][0][unconst_u32(123202568)][0][2][0])][5][unconst_u32(1245073883)];
  vp9 |= unpack4xU8(u32(vp11[unconst_u32(468324213)][unconst_u32(1078100549)]));
  _ = st15;
  _ = buffer168;
  _ = buffer170;
  _ = buffer167;
  _ = st14;
}`,
});
let bindGroup92 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 1, resource: externalTexture19}, {binding: 3, resource: textureView0}],
});
let commandEncoder175 = device0.createCommandEncoder();
let texture218 = device0.createTexture({
  size: {width: 390},
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder20.setBindGroup(0, bindGroup4, new Uint32Array(2483), 37, 1);
} catch {}
try {
commandEncoder165.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2500 */
  offset: 2500,
  bytesPerRow: 13312,
  buffer: buffer118,
}, {
  texture: texture155,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder2.popDebugGroup();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let buffer172 = device0.createBuffer({
  size: 28,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder176 = device0.createCommandEncoder({});
try {
renderPassEncoder4.setVertexBuffer(6, buffer160, 0, 34);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup31, new Uint32Array(998), 111, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame17,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 345, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470bg', transfer: 'bt1361ExtendedColourGamut'} });
let commandEncoder177 = device0.createCommandEncoder({});
let textureView212 = texture209.createView({});
let renderPassEncoder23 = commandEncoder43.beginRenderPass({
  colorAttachments: [{
  view: textureView146,
  depthSlice: 7,
  clearValue: { r: 619.4, g: -187.4, b: 835.9, a: 318.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder17.setBindGroup(2, bindGroup79, new Uint32Array(2121), 906, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer65, 'uint16', 4, 2);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer100, 'uint32', 8, 20);
} catch {}
try {
commandEncoder27.copyTextureToTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture122,
  mipLevel: 0,
  origin: {x: 17, y: 12, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(31); };
} catch {}
document.body.prepend(img0);
let buffer173 = device0.createBuffer({size: 328, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let commandEncoder178 = device0.createCommandEncoder({});
try {
renderPassEncoder13.setBindGroup(0, bindGroup89, new Uint32Array(2557), 187, 0);
} catch {}
try {
renderPassEncoder13.drawIndexed(3, 50, 0, -1_831_499_130, 182_710_488);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, buffer139, 0);
} catch {}
let promise24 = device0.queue.onSubmittedWorkDone();
await gc();
let imageData27 = new ImageData(16, 124);
let texture219 = device0.createTexture({
  size: {width: 390},
  sampleCount: 1,
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder13.drawIndexedIndirect(buffer45, 0);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer54, 0);
} catch {}
try {
renderBundleEncoder28.setBindGroup(0, bindGroup18);
} catch {}
try {
buffer139.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer156, 4, new Float32Array(3123).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.283)), 18, 0);
} catch {}
await gc();
let commandEncoder179 = device0.createCommandEncoder({});
let textureView213 = texture206.createView({});
try {
renderPassEncoder13.draw(202, 297_335_434, 322_410_367, 1_630_723_502);
} catch {}
try {
renderPassEncoder13.drawIndexed(4, 18, 0, 208_321_095, 113_693_811);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer143, 0);
} catch {}
let canvas6 = document.createElement('canvas');
let buffer174 = device0.createBuffer({
  label: '\uc5d3\u065a\u{1f806}\u6238\u8ad8\u04af\u3567',
  size: 164,
  usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder180 = device0.createCommandEncoder();
let renderPassEncoder24 = commandEncoder28.beginRenderPass({
  colorAttachments: [{
  view: textureView130,
  clearValue: { r: 478.9, g: 224.5, b: 934.2, a: -574.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
});
try {
renderPassEncoder13.drawIndirect(buffer77, 0);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer128, 'uint16', 0, 9);
} catch {}
try {
commandEncoder168.insertDebugMarker('\u9374');
} catch {}
try {
device0.queue.writeBuffer(buffer46, 0, new Uint32Array(3085).map((_, i) => i * 10), 151, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer175 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC});
let texture220 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView214 = texture54.createView({aspect: 'all'});
try {
computePassEncoder10.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder13.draw(12, 1_264_832_625, 1_016_939_961, 780_235_615);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(3, buffer172);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
document.body.append(canvas4);
try {
renderPassEncoder21.setBindGroup(0, bindGroup32, new Uint32Array(3643), 361, 0);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline13);
} catch {}
try {
  await buffer140.mapAsync(GPUMapMode.READ, 0, 12);
} catch {}
let pipeline41 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x4f62fc9},
  fragment: {
  module: shaderModule6,
  constants: {},
  targets: [{format: 'r16sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 28,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 0, shaderLocation: 14},
          {format: 'snorm16x2', offset: 0, shaderLocation: 2},
          {format: 'sint8x4', offset: 0, shaderLocation: 6},
          {format: 'float32', offset: 12, shaderLocation: 7},
          {format: 'sint32', offset: 0, shaderLocation: 9},
          {format: 'snorm8x2', offset: 18, shaderLocation: 11},
          {format: 'sint32x3', offset: 4, shaderLocation: 12},
          {format: 'unorm16x2', offset: 4, shaderLocation: 3},
          {format: 'uint32x3', offset: 0, shaderLocation: 1},
          {format: 'sint32', offset: 4, shaderLocation: 15},
          {format: 'snorm16x4', offset: 0, shaderLocation: 13},
          {format: 'sint8x4', offset: 4, shaderLocation: 8},
          {format: 'snorm16x4', offset: 0, shaderLocation: 10},
          {format: 'uint16x2', offset: 0, shaderLocation: 0},
          {format: 'sint32x2', offset: 4, shaderLocation: 5},
          {format: 'uint32x3', offset: 0, shaderLocation: 4},
        ],
      },
    ],
  },
});
let gpuCanvasContext12 = canvas6.getContext('webgpu');
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(49); };
} catch {}
let autogeneratedBindGroupLayout18 = pipeline22.getBindGroupLayout(0);
let buffer176 = device0.createBuffer({
  size: 4,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder181 = device0.createCommandEncoder({});
try {
renderPassEncoder13.draw(42, 151_995_937, 3_145_665_174, 18_944_870);
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup64, new Uint32Array(2073), 612, 2);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(0, buffer154, 0);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let autogeneratedBindGroupLayout19 = pipeline36.getBindGroupLayout(0);
let bindGroup93 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 3, resource: textureView17},
    {binding: 6, resource: {buffer: buffer5}},
    {binding: 43, resource: {buffer: buffer80}},
    {binding: 58, resource: {buffer: buffer116}},
  ],
});
let textureView215 = texture169.createView({mipLevelCount: 1});
try {
computePassEncoder21.setBindGroup(0, bindGroup29);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup49);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline22);
} catch {}
try {
commandEncoder101.insertDebugMarker('\u0d8d');
} catch {}
try {
  await promise24;
} catch {}
let imageData28 = new ImageData(4, 56);
let commandEncoder182 = device0.createCommandEncoder({label: '\uee11\u094c'});
let texture221 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 2},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView216 = texture127.createView({dimension: '2d-array', baseArrayLayer: 0});
try {
renderPassEncoder13.draw(166, 520_473_871, 15_162_527, 132_701_701);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(1, buffer160, 0, 75);
} catch {}
try {
renderBundleEncoder13.setBindGroup(2, bindGroup42);
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(64); };
} catch {}
let img6 = await imageWithData(10, 10, '#10101010', '#20202020');
let sampler29 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 6.573,
  compare: 'less',
  maxAnisotropy: 1,
});
let externalTexture34 = device0.importExternalTexture({source: videoFrame23});
try {
renderPassEncoder13.draw(215, 1_326_796_488, 6_728_321, 221_747_716);
} catch {}
try {
renderPassEncoder13.drawIndexed(3, 529, 0, 377_696_254, 1_447_959_403);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(0, buffer43, 4, 0);
} catch {}
try {
buffer43.unmap();
} catch {}
let pipeline42 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x20ba5e63},
  fragment: {module: shaderModule1, targets: [{format: 'rg8sint'}]},
  vertex: {
    module: shaderModule1,
    constants: {override0: 1},
    buffers: [
      {
        arrayStride: 64,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 8, shaderLocation: 11},
          {format: 'float32x4', offset: 4, shaderLocation: 2},
          {format: 'float32x4', offset: 8, shaderLocation: 8},
          {format: 'snorm8x2', offset: 10, shaderLocation: 12},
          {format: 'uint32', offset: 0, shaderLocation: 3},
          {format: 'unorm16x2', offset: 4, shaderLocation: 6},
          {format: 'uint16x4', offset: 8, shaderLocation: 1},
          {format: 'snorm8x4', offset: 12, shaderLocation: 5},
          {format: 'sint32x2', offset: 8, shaderLocation: 10},
          {format: 'uint32x2', offset: 28, shaderLocation: 15},
          {format: 'sint32', offset: 8, shaderLocation: 0},
          {format: 'float16x2', offset: 8, shaderLocation: 14},
          {format: 'sint8x4', offset: 4, shaderLocation: 13},
          {format: 'float32x3', offset: 0, shaderLocation: 9},
          {format: 'sint16x4', offset: 12, shaderLocation: 7},
          {format: 'uint16x2', offset: 0, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-list'},
});
document.body.append(canvas3);
let bindGroup94 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 557, resource: externalTexture19},
    {binding: 176, resource: {buffer: buffer107}},
    {binding: 0, resource: {buffer: buffer70}},
  ],
});
try {
computePassEncoder6.setBindGroup(0, bindGroup74, new Uint32Array(1981), 446, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup9, new Uint32Array(110), 1, 0);
} catch {}
try {
renderPassEncoder13.drawIndexed(3, 139, 0, 19_626_077, 512_054_424);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC, alphaMode: 'premultiplied'});
} catch {}
let buffer177 = device0.createBuffer({size: 8, usage: GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
try {
renderPassEncoder2.setBindGroup(1, bindGroup78, new Uint32Array(294), 71, 0);
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(794);
} catch {}
try {
renderPassEncoder13.draw(40, 1_785_616_377, 307_516_417, 715_166_655);
} catch {}
try {
renderPassEncoder13.drawIndexed(3, 160, 2, 6_560_020, 459_869_301);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer136, 4);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer136, 'uint16', 4, 13);
} catch {}
try {
buffer118.unmap();
} catch {}
try {
commandEncoder112.insertDebugMarker('\uaef3');
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
let buffer178 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder183 = device0.createCommandEncoder({});
let texture222 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 231},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder13.draw(51, 737_964_412, 3_057_501_638, 316_249_803);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer55, 9_540);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(1, buffer5, 88);
} catch {}
try {
renderPassEncoder12.insertDebugMarker('\u5d5f');
} catch {}
let bindGroup95 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []});
let externalTexture35 = device0.importExternalTexture({source: videoFrame12});
try {
renderPassEncoder23.setBindGroup(2, bindGroup48, new Uint32Array(137), 20, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer136, 'uint32', 24, 19);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer112, 'uint32', 160, 9);
} catch {}
try {
adapter0.label = '\u{1f8e0}\u0cb9\u{1ff89}\u36a6\u7d77\u0352\ua260\u{1ffc5}\u{1f77a}';
} catch {}
let buffer179 = device0.createBuffer({
  size: 336,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView217 = texture213.createView({format: 'rgba16sint'});
try {
computePassEncoder20.setBindGroup(0, bindGroup88, new Uint32Array(164), 0, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup3, new Uint32Array(303), 41, 1);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer102, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer68, 0, 109);
} catch {}
try {
commandEncoder86.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1656 */
  offset: 1656,
  bytesPerRow: 4864,
  buffer: buffer11,
}, {
  texture: texture181,
  mipLevel: 0,
  origin: {x: 203, y: 14, z: 0},
  aspect: 'all',
}, {width: 16, height: 28, depthOrArrayLayers: 0});
} catch {}
document.body.append(img6);
let bindGroup96 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 15, resource: {buffer: buffer111, size: 320}},
    {binding: 220, resource: {buffer: buffer157, size: 4}},
    {binding: 81, resource: externalTexture30},
    {binding: 141, resource: {buffer: buffer20, offset: 0}},
    {binding: 86, resource: {buffer: buffer37}},
    {binding: 0, resource: {buffer: buffer107, offset: 512}},
    {binding: 166, resource: textureView88},
    {binding: 2, resource: textureView82},
    {binding: 125, resource: textureView153},
    {binding: 3, resource: textureView134},
    {binding: 4, resource: {buffer: buffer120, size: 89}},
    {binding: 251, resource: {buffer: buffer37}},
    {binding: 6, resource: textureView3},
    {binding: 5, resource: {buffer: buffer116}},
    {binding: 148, resource: {buffer: buffer66}},
    {binding: 1, resource: externalTexture33},
    {binding: 12, resource: textureView205},
    {binding: 11, resource: textureView151},
    {binding: 106, resource: {buffer: buffer116, offset: 0}},
    {binding: 152, resource: textureView90},
  ],
});
let buffer180 = device0.createBuffer({size: 48, usage: GPUBufferUsage.UNIFORM});
let textureView218 = texture105.createView({});
let textureView219 = texture198.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder8.setPipeline(pipeline34);
} catch {}
try {
renderPassEncoder13.draw(90, 737_719_947, 314_347_918, 418_819_613);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer33, 68);
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.submit([commandBuffer7]);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 24, new DataView(new ArrayBuffer(43616)), 1844, 8);
} catch {}
let buffer181 = device0.createBuffer({size: 104, usage: GPUBufferUsage.INDIRECT});
try {
renderPassEncoder21.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder13.draw(15, 331_089_451, 298_347_044, 96_276_681);
} catch {}
try {
renderPassEncoder13.drawIndexed(5, 194, 0, 605_727_864, 322_688_601);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer59, 20);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: img6,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 123, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture223 = device0.createTexture({size: [4, 6, 1], format: 'r16sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING});
let textureView220 = texture195.createView({aspect: 'all', baseMipLevel: 0});
try {
computePassEncoder14.setBindGroup(3, bindGroup62);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder184 = device0.createCommandEncoder();
let texture224 = device0.createTexture({
  size: [195, 120, 270],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder14.setBindGroup(2, bindGroup81, new Uint32Array(2253), 923, 0);
} catch {}
try {
renderPassEncoder13.drawIndexed(5, 26, 2, 310_384_736, 920_991_901);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer102, 48);
} catch {}
try {
gpuCanvasContext11.unconfigure();
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(62); };
} catch {}
let bindGroup97 = device0.createBindGroup({layout: autogeneratedBindGroupLayout10, entries: [{binding: 10, resource: {buffer: buffer5}}]});
let commandEncoder185 = device0.createCommandEncoder({});
let texture225 = device0.createTexture({
  label: '\u{1fcd8}\ue003',
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture226 = device0.createTexture({
  size: [8, 12, 1],
  mipLevelCount: 1,
  sampleCount: 4,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder13.drawIndexedIndirect(buffer45, 16);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer65, 'uint32', 4, 1);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline42);
} catch {}
try {
commandEncoder178.copyTextureToBuffer({
  texture: texture23,
  mipLevel: 2,
  origin: {x: 12, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 852 */
  offset: 852,
  bytesPerRow: 1280,
  rowsPerImage: 7,
  buffer: buffer91,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let textureView221 = texture225.createView({});
let texture227 = device0.createTexture({
  size: {width: 4, height: 6, depthOrArrayLayers: 1},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder13.drawIndirect(buffer178, 0);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline38);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 8, new DataView(new ArrayBuffer(1032)), 123, 52);
} catch {}
let texture228 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView222 = texture149.createView({aspect: 'all', arrayLayerCount: 3});
try {
computePassEncoder21.setBindGroup(0, bindGroup47, []);
} catch {}
try {
renderPassEncoder13.drawIndexed(2, 45, 1, -1_089_266_969, 898_492_150);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer55, 2_696);
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u0622');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 97, height: 60, depthOrArrayLayers: 1}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 3, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder186 = device0.createCommandEncoder({});
let textureView223 = texture228.createView({});
let texture229 = device0.createTexture({
  size: [195, 12, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let texture230 = gpuCanvasContext2.getCurrentTexture();
let textureView224 = texture129.createView({baseMipLevel: 0});
try {
renderPassEncoder13.drawIndexedIndirect(buffer59, 0);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer151, 804);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(0, buffer9, 32);
} catch {}
let pipeline43 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule8, entryPoint: 'compute7', constants: {}}});
let commandEncoder187 = device0.createCommandEncoder({});
let textureView225 = texture209.createView({});
try {
renderPassEncoder21.setBindGroup(2, bindGroup39, new Uint32Array(279), 12, 0);
} catch {}
try {
renderPassEncoder13.draw(130, 571_737_458, 1_466_094_024, 2_081_533_416);
} catch {}
try {
renderPassEncoder13.drawIndexed(2, 188, 0, -1_635_125_725, 598_336_777);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer4, 20);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer35, 16);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(5, buffer136, 0, 10);
} catch {}
try {
renderBundleEncoder22.setBindGroup(3, bindGroup14, [0]);
} catch {}
let promise25 = shaderModule1.getCompilationInfo();
let pipeline44 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
let imageData29 = new ImageData(12, 24);
let commandEncoder188 = device0.createCommandEncoder({});
let textureView226 = texture122.createView({mipLevelCount: 1});
let sampler30 = device0.createSampler({
  label: '\u0de1\u9999\u5b3d\u{1ff1d}\ua53f',
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  compare: 'always',
  maxAnisotropy: 1,
});
try {
computePassEncoder10.setBindGroup(2, bindGroup12, new Uint32Array(253), 63, 0);
} catch {}
try {
renderPassEncoder20.setBindGroup(1, bindGroup95, new Uint32Array(2138), 536, 0);
} catch {}
try {
renderPassEncoder13.draw(31, 1_830_054_584, 1_858_748_354, 80_228_639);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer77, 4);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer74, 'uint32', 44, 0);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer112, 'uint32', 72, 15);
} catch {}
try {
commandEncoder76.resolveQuerySet(querySet0, 25, 0, buffer65, 0);
} catch {}
let autogeneratedBindGroupLayout20 = pipeline42.getBindGroupLayout(0);
let texture231 = device0.createTexture({size: [4], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let externalTexture36 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder20.setBindGroup(0, bindGroup92, new Uint32Array(505), 126, 0);
} catch {}
try {
renderPassEncoder13.drawIndexed(2, 340, 1, 120_078_627, 236_160_155);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer110, 16);
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup76);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup2, new Uint32Array(1363), 154, 0);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer176, 'uint32', 0, 0);
} catch {}
try {
buffer64.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
renderPassEncoder13.draw(14, 191_639_915, 412_040_676, 351_573_546);
} catch {}
try {
renderPassEncoder13.drawIndexed(2, 305, 0, 15_663_123, 1_223_975_775);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer45, 0);
} catch {}
try {
commandEncoder86.copyBufferToBuffer(buffer60, 84, buffer11, 488, 56);
} catch {}
try {
device0.queue.writeBuffer(buffer56, 12, new Uint16Array(13572).map((_, i) => i + 7), 1776, 532);
} catch {}
try {
device0.queue.label = '\u{1f643}\ub4d5\u46d1\ua07c\ufff9';
} catch {}
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 145,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
try {
renderPassEncoder13.drawIndexed(2, 199, 0, 237_993_180, 195_093_477);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer39, 44);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline27);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup49);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer9, 'uint32', 32, 0);
} catch {}
let offscreenCanvas7 = new OffscreenCanvas(14, 151);
let commandEncoder189 = device0.createCommandEncoder({});
let texture232 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 2},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let texture233 = gpuCanvasContext6.getCurrentTexture();
let textureView227 = texture167.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder13.draw(23, 629_600_755, 614_046_536, 1_258_368_836);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup94, new Uint32Array(2499), 423, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer154, 'uint16', 4, 37);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(6, buffer96, 0);
} catch {}
try {
buffer112.unmap();
} catch {}
try {
commandEncoder60.clearBuffer(buffer120);
} catch {}
try {
device0.queue.writeBuffer(buffer66, 60, new Float64Array(2408).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/2404)), 203, 8);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup95, new Uint32Array(1650), 330, 0);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer39, 56);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer151, 692);
} catch {}
try {
buffer54.unmap();
} catch {}
try {
commandEncoder164.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1102 */
  offset: 1102,
  bytesPerRow: 38656,
  buffer: buffer118,
}, {
  texture: texture102,
  mipLevel: 1,
  origin: {x: 43, y: 4, z: 2},
  aspect: 'all',
}, {width: 1, height: 8, depthOrArrayLayers: 0});
} catch {}
let commandEncoder190 = device0.createCommandEncoder({});
let texture234 = device0.createTexture({
  size: [780, 480, 1],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder13.drawIndirect(buffer172, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer129, 0, new Float16Array(13607).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.097)), 3057, 0);
} catch {}
let commandEncoder191 = device0.createCommandEncoder();
try {
computePassEncoder2.setBindGroup(0, bindGroup8, [0]);
} catch {}
try {
renderPassEncoder13.drawIndexed(3, 101, 0, 843_611_294, 418_986_860);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer117, 8);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer19);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder173.copyBufferToBuffer(buffer141, 32, buffer75, 120, 36);
} catch {}
try {
renderBundleEncoder12.insertDebugMarker('\ua00b');
} catch {}
let commandEncoder192 = device0.createCommandEncoder({});
try {
renderPassEncoder17.setBindGroup(2, bindGroup61);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer77, 152);
} catch {}
try {
computePassEncoder0.insertDebugMarker('\u8009');
} catch {}
let imageData30 = new ImageData(28, 32);
try {
renderPassEncoder13.draw(98, 870_406_090, 76_114_635, 53_069_537);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer103, 20);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(0, buffer154, 8, 2);
} catch {}
try {
commandEncoder144.copyBufferToBuffer(buffer8, 4, buffer138, 8, 0);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await promise25;
} catch {}
let commandEncoder193 = device0.createCommandEncoder({});
let texture235 = device0.createTexture({
  size: [195, 120, 1],
  mipLevelCount: 1,
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView228 = texture140.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder1.setBindGroup(0, bindGroup42, new Uint32Array(441), 76, 0);
} catch {}
try {
renderPassEncoder13.draw(224, 569_076_760, 465_611_757, 1_608_468_681);
} catch {}
try {
renderPassEncoder13.drawIndexed(3, 313, 0, 415_085_255, 613_355_830);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer144, 8);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer128, 'uint16', 0, 0);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline38);
} catch {}
try {
commandEncoder178.copyBufferToBuffer(buffer179, 16, buffer58, 20, 36);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture182,
  mipLevel: 3,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(46).fill(30), /* required buffer size: 46 */
{offset: 46, bytesPerRow: 19}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext12.unconfigure();
} catch {}
let bindGroup98 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 43, resource: {buffer: buffer80}},
    {binding: 3, resource: textureView3},
    {binding: 58, resource: {buffer: buffer37}},
    {binding: 6, resource: {buffer: buffer105, size: 24}},
  ],
});
let texture236 = gpuCanvasContext2.getCurrentTexture();
try {
renderPassEncoder13.draw(22, 169_496_123, 185_032_177, 85_673_160);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer55, 1_128);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline5);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 97, height: 60, depthOrArrayLayers: 1}
*/
{
  source: imageData12,
  origin: { x: 7, y: 1 },
  flipY: true,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext13 = offscreenCanvas7.getContext('webgpu');
try {
renderPassEncoder13.drawIndirect(buffer172, 0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup21, new Uint32Array(561), 64, 1);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer137, 'uint32', 0, 4);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(7, buffer82, 0, 18);
} catch {}
let buffer182 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder194 = device0.createCommandEncoder({});
let texture237 = device0.createTexture({size: [8], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder12.setBindGroup(0, bindGroup80);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer93, 4);
} catch {}
try {
commandEncoder161.copyTextureToTexture({
  texture: texture138,
  mipLevel: 0,
  origin: {x: 8, y: 7, z: 0},
  aspect: 'all',
},
{
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer163, 36, new Float32Array(12762).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6002)), 885, 8);
} catch {}
let bindGroup99 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 141, resource: {buffer: buffer35}},
    {binding: 3, resource: textureView80},
    {binding: 4, resource: {buffer: buffer66}},
    {binding: 5, resource: {buffer: buffer73, size: 16}},
    {binding: 15, resource: {buffer: buffer5}},
    {binding: 6, resource: textureView17},
    {binding: 12, resource: textureView32},
    {binding: 2, resource: textureView97},
    {binding: 125, resource: textureView151},
    {binding: 106, resource: {buffer: buffer116}},
    {binding: 166, resource: textureView138},
    {binding: 81, resource: externalTexture20},
    {binding: 251, resource: {buffer: buffer34}},
    {binding: 0, resource: {buffer: buffer21, size: 972}},
    {binding: 11, resource: textureView151},
    {binding: 1, resource: externalTexture12},
    {binding: 220, resource: {buffer: buffer110}},
    {binding: 152, resource: textureView87},
    {binding: 86, resource: {buffer: buffer21, size: 1836}},
    {binding: 148, resource: {buffer: buffer108}},
  ],
});
let texture238 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder13.drawIndexed(3, 44, 1, -1_943_170_070, 558_763_703);
} catch {}
let commandEncoder195 = device0.createCommandEncoder({});
let texture239 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 798},
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView229 = texture152.createView({mipLevelCount: 1});
try {
renderPassEncoder13.draw(1_000, 474_687_180, 2_167_415_024, 632_690_041);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer112, 8);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer69, 'uint32', 140, 6);
} catch {}
try {
buffer89.unmap();
} catch {}
try {
renderBundleEncoder22.insertDebugMarker('\u7709');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData13,
  origin: { x: 2, y: 5 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 148, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 3, depthOrArrayLayers: 0});
} catch {}
let bindGroup100 = device0.createBindGroup({layout: autogeneratedBindGroupLayout19, entries: []});
try {
renderPassEncoder13.drawIndexed(2, 316, 1, -2_092_909_914, 85_898_536);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup42, new Uint32Array(1884), 205, 0);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
commandEncoder92.copyBufferToTexture({
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1244 */
  offset: 1244,
  bytesPerRow: 14848,
  buffer: buffer11,
}, {
  texture: texture182,
  mipLevel: 1,
  origin: {x: 4, y: 1, z: 0},
  aspect: 'all',
}, {width: 9, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture7.label;
} catch {}
let commandEncoder196 = device0.createCommandEncoder({});
let externalTexture37 = device0.importExternalTexture({source: videoFrame16});
try {
renderPassEncoder13.draw(132, 65_500_393, 1_208_469_028, 41_450_675);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(6, buffer104, 0, 90);
} catch {}
let commandEncoder197 = device0.createCommandEncoder({});
let textureView230 = texture154.createView({});
try {
renderPassEncoder19.setIndexBuffer(buffer100, 'uint32', 64, 11);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer55, 'uint16', 24, 7_635);
} catch {}
try {
commandEncoder44.copyTextureToTexture({
  texture: texture114,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture157,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup101 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []});
let commandEncoder198 = device0.createCommandEncoder({});
let texture240 = device0.createTexture({
  size: {width: 16},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture38 = device0.importExternalTexture({source: videoFrame27, colorSpace: 'srgb'});
try {
renderPassEncoder13.drawIndexed(2, 126, 0, 431_177_790, 665_197_780);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer65, 'uint16', 2, 4);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer131, 'uint16', 62, 5);
} catch {}
try {
commandEncoder129.clearBuffer(buffer154);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 0, new Uint32Array(15775).map((_, i) => i * 9), 1641, 0);
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(193); };
} catch {}
let buffer183 = device0.createBuffer({size: 136, usage: GPUBufferUsage.INDEX});
let computePassEncoder26 = commandEncoder161.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 349, endOfPassWriteIndex: 166}});
try {
computePassEncoder26.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder13.draw(124, 152_478_059, 422_591_375, 909_758_509);
} catch {}
try {
renderPassEncoder13.drawIndexed(2, 12, 0, 112_296_876, 702_435_695);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer4, 32);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer178, 20);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, buffer106, 0, 33);
} catch {}
try {
device0.queue.writeBuffer(buffer103, 60, new DataView(new ArrayBuffer(3042)), 351, 4);
} catch {}
document.body.append(img4);
try {
renderPassEncoder13.drawIndexed(2, 19, 1, 25_422_864, 424_799_178);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer102, 24);
} catch {}
try {
renderBundleEncoder2.setBindGroup(3, bindGroup68);
} catch {}
let pipeline45 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule11, constants: {}}});
let texture241 = gpuCanvasContext5.getCurrentTexture();
try {
computePassEncoder23.setBindGroup(0, bindGroup100, new Uint32Array(666), 43, 0);
} catch {}
try {
renderPassEncoder13.draw(371, 817_906_635, 811_469_991, 18_446_659);
} catch {}
let bindGroup102 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [
    {binding: 348, resource: {buffer: buffer35}},
    {binding: 47, resource: textureView100},
    {binding: 241, resource: {buffer: buffer111, size: 416}},
    {binding: 711, resource: sampler18},
    {binding: 7, resource: {buffer: buffer34, offset: 0}},
    {binding: 3, resource: sampler29},
    {binding: 556, resource: textureView24},
    {binding: 290, resource: {buffer: buffer127, offset: 0, size: 12}},
    {binding: 10, resource: textureView26},
    {binding: 6, resource: textureView62},
  ],
});
let commandEncoder199 = device0.createCommandEncoder({label: '\u{1f778}\u{1f750}\u{1f93f}\u0593\ue7dc\u002d\u{1fd4a}\ud86e\u{1f6e7}'});
try {
computePassEncoder26.setBindGroup(3, bindGroup68);
} catch {}
try {
renderPassEncoder13.draw(255, 919_899_051, 975_337_982, 143_754_165);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(0, buffer176, 0, 2);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let arrayBuffer11 = buffer140.getMappedRange(0, 4);
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer82, 0, new DataView(new Uint8Array(12173).map((_, i) => i).buffer), 236, 0);
} catch {}
let texture242 = gpuCanvasContext3.getCurrentTexture();
try {
renderPassEncoder13.draw(7, 392_271_142, 1_006_625_995, 239_105_988);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer3, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(4, buffer111, 20, 59);
} catch {}
let arrayBuffer12 = buffer140.getMappedRange(8, 0);
try {
commandEncoder94.copyTextureToBuffer({
  texture: texture197,
  mipLevel: 0,
  origin: {x: 62, y: 6, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 304 widthInBlocks: 76 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 944 */
  offset: 944,
  bytesPerRow: 40960,
  rowsPerImage: 35,
  buffer: buffer11,
}, {width: 76, height: 7, depthOrArrayLayers: 0});
} catch {}
let textureView231 = texture72.createView({});
try {
computePassEncoder14.setBindGroup(1, bindGroup97, new Uint32Array(7836), 65, 0);
} catch {}
try {
renderPassEncoder20.beginOcclusionQuery(481);
} catch {}
try {
renderPassEncoder9.setBlendConstant({ r: -741.6, g: -757.0, b: 541.3, a: -778.6, });
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer107, 408);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer43, 12);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer9, 'uint16', 12, 10);
} catch {}
try {
commandEncoder80.copyBufferToBuffer(buffer155, 0, buffer154, 16, 0);
} catch {}
let buffer184 = device0.createBuffer({label: '\u5da4\u0c5c\u0e79\u2aa8\u5c8d\u0936\u6131\ue53e', size: 320, usage: GPUBufferUsage.COPY_DST});
let texture243 = device0.createTexture({
  size: {width: 390},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView232 = texture136.createView({dimension: '2d-array', format: 'rg8sint'});
try {
renderPassEncoder13.drawIndexedIndirect(buffer181, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer106, 'uint16', 30, 5);
} catch {}
try {
renderBundleEncoder26.setBindGroup(0, bindGroup51, new Uint32Array(1871), 3, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 12, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 62, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture244 = device0.createTexture({
  size: [390, 24, 1],
  mipLevelCount: 2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView233 = texture210.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder13.drawIndexed(7, 324, 0, 6_288_010, 1_180_038_497);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer59, 8);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer33, 36);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: canvas6,
  origin: { x: 43, y: 18 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 95, y: 12, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 42, height: 6, depthOrArrayLayers: 0});
} catch {}
let pipeline46 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment1',
  constants: {},
  targets: [{format: 'r16sint', writeMask: 0}],
},
  vertex: {
    module: shaderModule7,
    constants: {override18: 1},
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 0, shaderLocation: 10},
          {format: 'unorm16x2', offset: 0, shaderLocation: 4},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 8},
          {format: 'sint16x2', offset: 0, shaderLocation: 15},
          {format: 'unorm8x4', offset: 0, shaderLocation: 12},
          {format: 'sint16x2', offset: 0, shaderLocation: 6},
          {format: 'uint32', offset: 0, shaderLocation: 7},
          {format: 'snorm8x2', offset: 0, shaderLocation: 0},
          {format: 'float16x2', offset: 0, shaderLocation: 5},
          {format: 'uint8x4', offset: 0, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'snorm16x2', offset: 212, shaderLocation: 13},
          {format: 'uint16x2', offset: 12, shaderLocation: 3},
          {format: 'snorm8x2', offset: 616, shaderLocation: 14},
          {format: 'uint16x2', offset: 48, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', unclippedDepth: true},
});
try {
globalThis.someLabel = texture243.label;
} catch {}
let externalTexture39 = device0.importExternalTexture({source: videoFrame12});
try {
renderPassEncoder9.setBindGroup(0, bindGroup89, []);
} catch {}
try {
renderPassEncoder13.draw(151, 433_097_386, 1_169_194_166, 107_320_338);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer45, 0);
} catch {}
await gc();
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {binding: 2, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 9, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 11,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 33,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 40,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {binding: 45, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 84,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 148,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 201,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 210,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 211,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 219,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 255,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 264,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 269,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 284,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 386,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let texture245 = device0.createTexture({
  size: [2, 2, 14],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView234 = texture200.createView({dimension: '2d', baseArrayLayer: 9});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], stencilReadOnly: false});
try {
computePassEncoder4.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder13.draw(499, 1_573_883_190, 20_520_345, 333_481_313);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer104, 64);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline8);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder102.copyTextureToTexture({
  texture: texture208,
  mipLevel: 0,
  origin: {x: 413, y: 11, z: 0},
  aspect: 'all',
},
{
  texture: texture208,
  mipLevel: 0,
  origin: {x: 294, y: 2, z: 0},
  aspect: 'all',
},
{width: 234, height: 10, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder15.insertDebugMarker('\u62f2');
} catch {}
try {
device0.queue.writeBuffer(buffer34, 56, new DataView(new ArrayBuffer(35048)), 2258, 4);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
document.body.prepend(img0);
let textureView235 = texture90.createView({});
try {
renderPassEncoder20.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.draw(14, 33_281_357, 474_709_205, 34_535_074);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer102, 12);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer154, 'uint32', 32, 41);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup1, new Uint32Array(1573), 22, 0);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(1, buffer128, 0);
} catch {}
try {
commandEncoder49.copyBufferToTexture({
  /* bytesInLastRow: 256 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2768 */
  offset: 2768,
  bytesPerRow: 1024,
  buffer: buffer118,
}, {
  texture: texture210,
  mipLevel: 0,
  origin: {x: 80, y: 190, z: 0},
  aspect: 'all',
}, {width: 160, height: 60, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder141.resolveQuerySet(querySet1, 54, 1, buffer164, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer82, 48, new BigInt64Array(22556).map((_, i) => BigInt(i - 9)), 294, 0);
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
let commandEncoder200 = device0.createCommandEncoder();
let computePassEncoder27 = commandEncoder200.beginComputePass();
try {
computePassEncoder27.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder20.setBindGroup(1, bindGroup44);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup74, new Uint32Array(918), 28, 0);
} catch {}
try {
renderPassEncoder13.draw(182, 626_803_479, 707_221_462, 95_034_335);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer112, 52);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline40);
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup37);
} catch {}
try {
device0.queue.writeBuffer(buffer65, 8, new DataView(new Uint8Array(7215).map((_, i) => i).buffer), 300, 4);
} catch {}
let buffer185 = device0.createBuffer({size: 11752, usage: GPUBufferUsage.VERTEX});
let commandEncoder201 = device0.createCommandEncoder({});
let externalTexture40 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'display-p3'});
try {
renderPassEncoder9.drawIndexed(2, 0, 2, 282_271_899);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer102, 28);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer137, 'uint16', 2, 3);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(6, buffer143, 12, 4);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup37);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer128, 'uint16', 0, 2);
} catch {}
try {
commandEncoder97.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1792 */
  offset: 1792,
  bytesPerRow: 10496,
  buffer: buffer118,
}, {
  texture: texture28,
  mipLevel: 0,
  origin: {x: 132, y: 0, z: 0},
  aspect: 'all',
}, {width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer137, 4, new Float32Array(6174).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.563)), 1121, 0);
} catch {}
let imageData31 = new ImageData(72, 4);
let commandEncoder202 = device0.createCommandEncoder({});
let texture246 = device0.createTexture({
  size: [2, 2, 14],
  mipLevelCount: 1,
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView236 = texture170.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder13.drawIndexedIndirect(buffer136, 20);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline16);
} catch {}
let autogeneratedBindGroupLayout21 = pipeline13.getBindGroupLayout(0);
let sampler31 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 68.59,
  compare: 'greater',
  maxAnisotropy: 5,
});
try {
renderPassEncoder9.end();
} catch {}
try {
renderPassEncoder13.draw(86, 311_367_275, 621_183_293, 588_432_733);
} catch {}
try {
renderPassEncoder13.drawIndexed(2, 61, 0, 101_291_593, 1_012_709_740);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer62, 0, 1);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer107, 'uint32', 408, 59);
} catch {}
let canvas7 = document.createElement('canvas');
let imageBitmap1 = await createImageBitmap(videoFrame23);
try {
computePassEncoder1.setBindGroup(2, bindGroup17, new Uint32Array(153), 16, 1);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup89);
} catch {}
try {
renderPassEncoder13.draw(42, 1_151_863_789, 963_543_556, 188_067_451);
} catch {}
try {
adapter0.label = '\u{1fe32}\u0e96\u{1ffdf}\u1e52\ubb5e\u42df\ua50f\u6230\u055b';
} catch {}
let bindGroup103 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 176, resource: {buffer: buffer21, size: 2428}},
    {binding: 557, resource: externalTexture9},
    {binding: 0, resource: {buffer: buffer35, offset: 0}},
  ],
});
let commandEncoder203 = device0.createCommandEncoder({});
let textureView237 = texture239.createView({label: '\uf455\u631e\u6a77\uba74\u4a8c\ufac2\u90c7\ud154\ue5da\u1023', baseArrayLayer: 0});
let texture247 = device0.createTexture({
  size: {width: 780, height: 480, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView238 = texture204.createView({aspect: 'depth-only', baseArrayLayer: 12, arrayLayerCount: 2});
let renderPassEncoder25 = commandEncoder104.beginRenderPass({
  colorAttachments: [{view: textureView126, loadOp: 'load', storeOp: 'discard'}],
  timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 12, endOfPassWriteIndex: 172},
  maxDrawCount: 23606588,
});
try {
renderPassEncoder13.drawIndexedIndirect(buffer133, 0);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer93, 104);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(5, buffer59, 0);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(3, buffer176, 0, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture134,
  mipLevel: 4,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(64).fill(224), /* required buffer size: 64 */
{offset: 64}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext10.unconfigure();
} catch {}
let bindGroup104 = device0.createBindGroup({layout: autogeneratedBindGroupLayout16, entries: [{binding: 1, resource: externalTexture19}]});
let commandEncoder204 = device0.createCommandEncoder();
let textureView239 = texture145.createView({dimension: '2d'});
let renderPassEncoder26 = commandEncoder53.beginRenderPass({
  colorAttachments: [{
  view: textureView111,
  depthSlice: 30,
  clearValue: { r: 478.6, g: 87.22, b: -913.5, a: -825.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
  timestampWrites: {querySet: querySet0},
});
try {
renderPassEncoder13.drawIndexed(2, 4, 2, 420_641_647, 1_048_739_006);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer73, 4);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer107, 'uint16', 196, 199);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer128, 'uint16', 0, 4);
} catch {}
offscreenCanvas5.height = 407;
let bindGroup105 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 3, resource: textureView17},
    {binding: 6, resource: {buffer: buffer158}},
    {binding: 58, resource: {buffer: buffer21, size: 1648}},
    {binding: 43, resource: {buffer: buffer64}},
  ],
});
let commandEncoder205 = device0.createCommandEncoder({});
let textureView240 = texture73.createView({});
let renderPassEncoder27 = commandEncoder195.beginRenderPass({
  label: '\u44ef\u70f0\u041a\u2485\u04d8\ucfab\u2d74\u{1f607}',
  colorAttachments: [{
  view: textureView126,
  clearValue: { r: 10.13, g: 461.8, b: -68.31, a: -437.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet2,
  timestampWrites: {querySet: querySet3, endOfPassWriteIndex: 97},
  maxDrawCount: 115845954,
});
try {
computePassEncoder18.setBindGroup(2, bindGroup10, [0]);
} catch {}
try {
renderPassEncoder26.beginOcclusionQuery(820);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer103, 16);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup32, new Uint32Array(5299), 268, 0);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline5);
} catch {}
try {
commandEncoder174.insertDebugMarker('\u063b');
} catch {}
let textureView241 = texture46.createView({label: '\u001f\u4008\u3b8d\u01b7\u3325\u048a\u1ab6\u{1f742}\u{1fa8d}\u7240'});
try {
computePassEncoder6.setBindGroup(3, bindGroup23, new Uint32Array(267), 129, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup104, new Uint32Array(838), 165, 0);
} catch {}
try {
renderPassEncoder13.draw(52, 766_426_167, 417_179_854, 277_200_487);
} catch {}
try {
renderPassEncoder13.drawIndexed(2, 427, 1, -2_063_035_585, 485_759_214);
} catch {}
try {
renderPassEncoder13.drawIndexedIndirect(buffer89, 12);
} catch {}
try {
renderPassEncoder13.drawIndirect(buffer110, 16);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline46);
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup4, [0]);
} catch {}
let commandEncoder206 = device0.createCommandEncoder({});
let texture248 = device0.createTexture({
  size: [32, 48, 8],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder0.setBindGroup(2, bindGroup92);
} catch {}
try {
renderPassEncoder13.end();
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(6, buffer185, 0);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup92);
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture215,
  mipLevel: 0,
  origin: {x: 162, y: 47, z: 0},
  aspect: 'all',
}, new Uint8Array(228).fill(135), /* required buffer size: 228 */
{offset: 228, bytesPerRow: 96}, {width: 44, height: 102, depthOrArrayLayers: 0});
} catch {}
let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte170m', transfer: 'log'} });
let bindGroup106 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 6, resource: {buffer: buffer103}},
    {binding: 3, resource: textureView0},
    {binding: 58, resource: {buffer: buffer21, size: 600}},
    {binding: 43, resource: {buffer: buffer174}},
  ],
});
let buffer186 = device0.createBuffer({size: 426, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandBuffer8 = commandEncoder32.finish();
let texture249 = device0.createTexture({
  size: [195, 12, 1],
  sampleCount: 4,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture250 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let texture251 = gpuCanvasContext1.getCurrentTexture();
let textureView242 = texture71.createView({baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 3});
let externalTexture41 = device0.importExternalTexture({source: videoFrame10});
try {
renderPassEncoder5.setIndexBuffer(buffer145, 'uint32', 24, 18);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer90, 'uint32', 260, 21);
} catch {}
try {
device0.queue.writeBuffer(buffer179, 32, new Uint32Array(4480).map((_, i) => i * 5), 3032, 8);
} catch {}
try {
  await promise26;
} catch {}
let commandEncoder207 = device0.createCommandEncoder({});
let commandBuffer9 = commandEncoder39.finish();
let texture252 = device0.createTexture({
  size: {width: 195, height: 120, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView243 = texture26.createView({});
try {
renderPassEncoder6.setBindGroup(2, bindGroup82);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
device0.queue.writeBuffer(buffer80, 0, new Float32Array(1857).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4047)), 1147, 0);
} catch {}
let bindGroup107 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []});
try {
computePassEncoder2.setBindGroup(2, bindGroup99, [256, 0]);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer139, 0, 23);
} catch {}
try {
computePassEncoder13.insertDebugMarker('\u{1fac7}');
} catch {}
let promise27 = device0.queue.onSubmittedWorkDone();
try {
  await promise27;
} catch {}
let videoFrame32 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'jedecP22Phosphors', transfer: 'iec61966-2-1'} });
let commandEncoder208 = device0.createCommandEncoder({});
let textureView244 = texture249.createView({baseArrayLayer: 0});
try {
renderBundleEncoder21.setBindGroup(2, bindGroup38);
} catch {}
let texture253 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
try {
renderPassEncoder19.setBindGroup(1, bindGroup4, new Uint32Array(527), 103, 1);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer100, 'uint32', 52, 32);
} catch {}
let autogeneratedBindGroupLayout22 = pipeline30.getBindGroupLayout(0);
try {
renderBundleEncoder20.setBindGroup(0, bindGroup82);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline39);
} catch {}
try {
renderBundleEncoder25.insertDebugMarker('\u05bf');
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer76, 4, new Float32Array(2328).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.333)), 41, 0);
} catch {}
try {
if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(92); };
} catch {}
let sampler32 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'linear', maxAnisotropy: 1});
try {
renderPassEncoder15.setBindGroup(1, bindGroup41);
} catch {}
try {
device0.queue.writeBuffer(buffer137, 12, new Uint32Array(823).map((_, i) => i * 5), 57, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData8,
  origin: { x: 1, y: 7 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 17, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 23, depthOrArrayLayers: 0});
} catch {}
let buffer187 = device0.createBuffer({size: 1088, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder13.setBindGroup(1, bindGroup43, new Uint32Array(546), 78, 0);
} catch {}
try {
commandEncoder139.resolveQuerySet(querySet1, 160, 8, buffer70, 0);
} catch {}
let commandEncoder209 = device0.createCommandEncoder({});
let textureView245 = texture228.createView({});
try {
renderBundleEncoder22.setBindGroup(1, bindGroup102, [0]);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer131, 'uint16', 190, 102);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(0, buffer139, 0, 18);
} catch {}
let imageData32 = new ImageData(4, 80);
let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }},
    {binding: 5, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 32, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 184,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 365,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
  ],
});
let commandEncoder210 = device0.createCommandEncoder({});
let texture254 = device0.createTexture({
  label: '\u094a\u{1fbbc}\u15db\u{1f92d}\u11d7\udd22\u4623\u{1fc4e}\u0d26\u33ad',
  size: {width: 195},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder9.setBindGroup(3, bindGroup19, [0]);
} catch {}
try {
computePassEncoder14.setBindGroup(1, bindGroup103, new Uint32Array(3472), 387, 0);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer144, 'uint16', 38, 4);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(2, buffer118, 148);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture209,
  mipLevel: 0,
  origin: {x: 170, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(72).fill(129), /* required buffer size: 72 */
{offset: 72}, {width: 45, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise28 = device0.queue.onSubmittedWorkDone();
try {
  await promise28;
} catch {}
await gc();
let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} });
let textureView246 = texture75.createView({dimension: '2d', baseArrayLayer: 27, arrayLayerCount: 1});
try {
renderPassEncoder19.setBindGroup(1, bindGroup95);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer107, 'uint32', 4, 1_288);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder25.setBindGroup(0, bindGroup16, []);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture255 = device0.createTexture({
  size: [780, 48, 1],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture42 = device0.importExternalTexture({source: videoFrame25});
try {
renderBundleEncoder20.setPipeline(pipeline14);
} catch {}
try {
commandEncoder204.copyBufferToBuffer(buffer117, 0, buffer7, 0, 8);
} catch {}
let bindGroup108 = device0.createBindGroup({layout: autogeneratedBindGroupLayout21, entries: [{binding: 1, resource: externalTexture38}]});
let texture256 = device0.createTexture({
  size: {width: 97},
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder9.setBindGroup(1, bindGroup85, new Uint32Array(318), 74, 1);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup104, new Uint32Array(659), 101, 0);
} catch {}
let pipeline47 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule9, constants: {}}});
let autogeneratedBindGroupLayout23 = pipeline5.getBindGroupLayout(0);
let bindGroup109 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout22,
  entries: [
    {binding: 6, resource: {buffer: buffer157, size: 28}},
    {binding: 58, resource: {buffer: buffer21, offset: 1280, size: 1008}},
  ],
});
let textureView247 = texture198.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder22.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder11.setBindGroup(3, bindGroup12);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline38);
} catch {}
let gpuCanvasContext14 = canvas7.getContext('webgpu');
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {binding: 7, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 11,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 14, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 33,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 39,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 212,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let bindGroup110 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 0, resource: {buffer: buffer116}},
    {binding: 220, resource: {buffer: buffer20, offset: 0}},
    {binding: 125, resource: textureView241},
    {binding: 81, resource: externalTexture33},
    {binding: 251, resource: {buffer: buffer174}},
    {binding: 152, resource: textureView87},
    {binding: 11, resource: textureView239},
    {binding: 2, resource: textureView82},
    {binding: 1, resource: externalTexture27},
    {binding: 86, resource: {buffer: buffer37, size: 916}},
    {binding: 166, resource: textureView138},
    {binding: 5, resource: {buffer: buffer111, size: 364}},
    {binding: 15, resource: {buffer: buffer21, size: 416}},
    {binding: 4, resource: {buffer: buffer106}},
    {binding: 141, resource: {buffer: buffer174}},
    {binding: 106, resource: {buffer: buffer116}},
    {binding: 12, resource: textureView186},
    {binding: 3, resource: textureView134},
    {binding: 148, resource: {buffer: buffer146}},
    {binding: 6, resource: textureView3},
  ],
});
let buffer188 = device0.createBuffer({size: 466, usage: GPUBufferUsage.INDEX});
let texture257 = device0.createTexture({
  size: [16, 24, 1],
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView248 = texture202.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 2});
try {
commandEncoder194.copyTextureToBuffer({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1804 */
  offset: 1804,
  bytesPerRow: 54016,
  rowsPerImage: 263,
  buffer: buffer91,
}, {width: 1, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder197.pushDebugGroup('\u1e14');
} catch {}
try {
commandEncoder197.popDebugGroup();
} catch {}
try {
renderPassEncoder20.label = '\u0a76\u3c3a\u6def\u14d5';
} catch {}
let buffer189 = device0.createBuffer({size: 28, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder211 = device0.createCommandEncoder({});
let textureView249 = texture105.createView({format: 'rg8sint', arrayLayerCount: 1});
try {
renderBundleEncoder14.setIndexBuffer(buffer145, 'uint16', 28, 12);
} catch {}
offscreenCanvas1.width = 98;
let textureView250 = texture255.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder22.setBindGroup(2, bindGroup40, new Uint32Array(3550), 787, 0);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(159);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer1, 'uint32', 0, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer76, 76, new Float64Array(1276).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/1276)), 157, 0);
} catch {}
let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 162,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 371,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let buffer190 = device0.createBuffer({size: 196, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder212 = device0.createCommandEncoder({});
try {
renderPassEncoder17.setBindGroup(2, bindGroup0, new Uint32Array(145), 138, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline27);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup59);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline27);
} catch {}
try {
buffer183.unmap();
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let buffer191 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let texture258 = device0.createTexture({
  size: {width: 97},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView251 = texture127.createView({});
try {
renderPassEncoder26.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline42);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, buffer62, 0, 7);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(5, buffer19, 0, 97);
} catch {}
let canvas8 = document.createElement('canvas');
let buffer192 = device0.createBuffer({size: 31, usage: GPUBufferUsage.COPY_DST});
let texture259 = device0.createTexture({
  size: {width: 16, height: 24, depthOrArrayLayers: 166},
  mipLevelCount: 1,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setBindGroup(0, bindGroup102, new Uint32Array(348), 7, 1);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer106, 'uint16', 8, 22);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer55, 'uint16', 346, 2_535);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline42);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(48); };
} catch {}
let autogeneratedBindGroupLayout24 = pipeline39.getBindGroupLayout(0);
let commandEncoder213 = device0.createCommandEncoder({});
let textureView252 = texture66.createView({});
let computePassEncoder28 = commandEncoder167.beginComputePass();
try {
computePassEncoder28.setPipeline(pipeline34);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup21, [0]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 2, y: 21 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 2, depthOrArrayLayers: 0});
} catch {}
let buffer193 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let externalTexture43 = device0.importExternalTexture({source: videoFrame22, colorSpace: 'display-p3'});
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(16); };
} catch {}
let videoFrame34 = new VideoFrame(videoFrame22, {timestamp: 0});
try {
computePassEncoder27.setBindGroup(3, bindGroup101, new Uint32Array(618), 35, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, buffer107, 0, 45);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer55, 'uint16', 1_264, 3_589);
} catch {}
try {
device0.queue.submit([commandBuffer8]);
} catch {}
try {
device0.queue.writeBuffer(buffer154, 20, new Float16Array(25342).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.9348)), 59, 4);
} catch {}
let buffer194 = device0.createBuffer({size: 320, usage: GPUBufferUsage.INDIRECT});
let texture260 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 218},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder2.setBindGroup(3, bindGroup56);
} catch {}
try {
buffer160.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer103, 68, new DataView(new ArrayBuffer(20836)), 826, 0);
} catch {}
try {
computePassEncoder9.insertDebugMarker('\u6758');
} catch {}
try {
device0.queue.writeBuffer(buffer192, 0, new Float16Array(4761).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.4251)), 3057, 4);
} catch {}
let videoFrame35 = new VideoFrame(img4, {timestamp: 0});
let bindGroup111 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 43, resource: {buffer: buffer80}},
    {binding: 3, resource: textureView0},
    {binding: 6, resource: {buffer: buffer136}},
    {binding: 58, resource: {buffer: buffer107}},
  ],
});
let sampler33 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.49,
  maxAnisotropy: 14,
});
try {
buffer39.unmap();
} catch {}
let textureView253 = texture71.createView({dimension: '2d', baseArrayLayer: 1});
let renderPassEncoder28 = commandEncoder90.beginRenderPass({
  colorAttachments: [{
  view: textureView145,
  depthSlice: 3,
  clearValue: { r: 10.07, g: -342.9, b: -315.1, a: -152.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
});
try {
computePassEncoder25.setBindGroup(2, bindGroup38, []);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(5, buffer77, 12, 84);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(5, buffer118, 0, 1_477);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer153, 0, new Uint16Array(10586).map((_, i) => i + 1), 2148, 0);
} catch {}
let bindGroup112 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 81, resource: externalTexture17},
    {binding: 166, resource: textureView88},
    {binding: 3, resource: textureView154},
    {binding: 148, resource: {buffer: buffer179}},
    {binding: 125, resource: textureView250},
    {binding: 106, resource: {buffer: buffer107}},
    {binding: 141, resource: {buffer: buffer5}},
    {binding: 1, resource: externalTexture8},
    {binding: 5, resource: {buffer: buffer75, offset: 0}},
    {binding: 12, resource: textureView186},
    {binding: 6, resource: textureView0},
    {binding: 15, resource: {buffer: buffer5, offset: 0}},
    {binding: 0, resource: {buffer: buffer37}},
    {binding: 11, resource: textureView151},
    {binding: 2, resource: textureView97},
    {binding: 251, resource: {buffer: buffer35, size: 20}},
    {binding: 86, resource: {buffer: buffer37}},
    {binding: 4, resource: {buffer: buffer51, offset: 0}},
    {binding: 152, resource: textureView90},
    {binding: 220, resource: {buffer: buffer60}},
  ],
});
let buffer195 = device0.createBuffer({size: 398, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder214 = device0.createCommandEncoder({});
let texture261 = device0.createTexture({size: [1560, 96, 1], mipLevelCount: 4, format: 'r16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let externalTexture44 = device0.importExternalTexture({source: videoFrame20});
try {
computePassEncoder22.setBindGroup(2, bindGroup39, new Uint32Array(2298), 786, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup104);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer131, 'uint16', 184, 56);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline16);
} catch {}
try {
commandEncoder146.copyTextureToBuffer({
  texture: texture213,
  mipLevel: 0,
  origin: {x: 21, y: 9, z: 3},
  aspect: 'all',
}, {
  /* bytesInLastRow: 128 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2808 */
  offset: 2808,
  bytesPerRow: 56832,
  rowsPerImage: 269,
  buffer: buffer91,
}, {width: 16, height: 0, depthOrArrayLayers: 1});
} catch {}
let promise29 = device0.queue.onSubmittedWorkDone();
try {
  await promise29;
} catch {}
let commandEncoder215 = device0.createCommandEncoder({});
let textureView254 = texture210.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder5.setBindGroup(0, bindGroup29, []);
} catch {}
try {
renderPassEncoder25.insertDebugMarker('\uf503');
} catch {}
let imageData33 = new ImageData(4, 60);
let textureView255 = texture82.createView({format: 'rgba16uint'});
let texture262 = device0.createTexture({
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture45 = device0.importExternalTexture({source: videoFrame13});
try {
computePassEncoder23.setBindGroup(3, bindGroup11, [0]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer58, 32, new Float32Array(10847).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.7711)), 6, 0);
} catch {}
let canvas9 = document.createElement('canvas');
let commandEncoder216 = device0.createCommandEncoder({});
try {
buffer132.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 97, height: 60, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 29, y: 5 },
  flipY: false,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 18, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 9, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout25 = pipeline41.getBindGroupLayout(1);
let texture263 = gpuCanvasContext3.getCurrentTexture();
let externalTexture46 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
renderPassEncoder4.setBindGroup(1, bindGroup53, new Uint32Array(7569), 1_526, 1);
} catch {}
try {
commandEncoder203.resolveQuerySet(querySet1, 217, 0, buffer178, 0);
} catch {}
let renderPassEncoder29 = commandEncoder164.beginRenderPass({
  colorAttachments: [{
  view: textureView145,
  depthSlice: 6,
  clearValue: { r: -821.7, g: 314.7, b: -64.70, a: 462.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let externalTexture47 = device0.importExternalTexture({source: videoFrame11});
try {
computePassEncoder5.setBindGroup(2, bindGroup25, [0]);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup89);
} catch {}
try {
renderPassEncoder11.drawIndexed(2, 0, 0, 113_544_639, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer62, 0, 2);
} catch {}
try {
buffer53.unmap();
} catch {}
try {
commandEncoder146.resolveQuerySet(querySet2, 79, 0, buffer108, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer103, 64, new DataView(new ArrayBuffer(5111)), 54, 0);
} catch {}
let videoFrame36 = new VideoFrame(imageBitmap0, {timestamp: 0});
try {
computePassEncoder4.setBindGroup(1, bindGroup40);
} catch {}
try {
renderPassEncoder11.draw(10, 0, 384_884_883);
} catch {}
try {
renderPassEncoder11.drawIndexed(2, 0, 0, 548_523_735);
} catch {}
try {
device0.queue.writeBuffer(buffer184, 28, new Float32Array(11107).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.201)), 2488, 44);
} catch {}
let externalTexture48 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'});
try {
computePassEncoder15.setBindGroup(3, bindGroup7, new Uint32Array(933), 224, 1);
} catch {}
try {
renderPassEncoder11.draw(283, 0, 203_766_668);
} catch {}
try {
renderPassEncoder11.drawIndexed(2, 0, 0, 18_843_804);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer117, 8);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer110, 56);
} catch {}
try {
commandEncoder177.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 24 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 810 */
  offset: 810,
  bytesPerRow: 11520,
  buffer: buffer118,
}, {
  texture: texture205,
  mipLevel: 0,
  origin: {x: 207, y: 0, z: 0},
  aspect: 'all',
}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer101, 12, new Uint32Array(127).map((_, i) => i * 6), 1, 0);
} catch {}
let autogeneratedBindGroupLayout26 = pipeline17.getBindGroupLayout(0);
let bindGroup113 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []});
let texture264 = device0.createTexture({
  label: '\u03fd\u09bf\u1c60\u54a2\u039a\u{1fdaa}\u4a39\u{1f696}\u03b7\uf53d',
  size: {width: 390, height: 24, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder27.setBindGroup(0, bindGroup79);
} catch {}
try {
computePassEncoder7.setBindGroup(0, bindGroup43, new Uint32Array(717), 166, 0);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup89);
} catch {}
try {
renderPassEncoder11.draw(268, 0, 370_189_414);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer22, 16);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer109, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer108, 'uint16', 6, 1);
} catch {}
try {
buffer152.unmap();
} catch {}
try {
renderPassEncoder21.insertDebugMarker('\u{1f94c}');
} catch {}
document.body.prepend(canvas4);
try {
renderPassEncoder5.setBindGroup(3, bindGroup79);
} catch {}
try {
renderPassEncoder11.drawIndexed(2, 0, 0, 279_826_889);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer39, 48);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(6, buffer5, 0, 15);
} catch {}
try {
commandEncoder189.resolveQuerySet(querySet1, 111, 0, buffer50, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
await gc();
let texture265 = device0.createTexture({
  size: [780, 480, 1],
  sampleCount: 4,
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder24.beginOcclusionQuery(183);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(0, buffer143);
} catch {}
try {
commandEncoder188.copyTextureToBuffer({
  texture: texture167,
  mipLevel: 2,
  origin: {x: 19, y: 6, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 632 */
  offset: 632,
  bytesPerRow: 37888,
  buffer: buffer187,
}, {width: 8, height: 2, depthOrArrayLayers: 0});
} catch {}
let texture266 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView256 = texture89.createView({format: 'r16sint'});
let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], sampleCount: 1});
let externalTexture49 = device0.importExternalTexture({source: videoFrame28});
try {
renderPassEncoder6.setBindGroup(2, bindGroup91, new Uint32Array(451), 78, 1);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder11.drawIndexed(2, 0, 0, -2_096_072_786);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline37);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(6, buffer141, 4);
} catch {}
let pipeline48 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x21e3a74},
  fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint', writeMask: 0}]},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex4',
    constants: {},
    buffers: [
      {
        arrayStride: 28,
        attributes: [
          {format: 'sint32', offset: 4, shaderLocation: 5},
          {format: 'sint8x4', offset: 0, shaderLocation: 6},
          {format: 'float16x2', offset: 0, shaderLocation: 13},
          {format: 'sint8x4', offset: 0, shaderLocation: 8},
          {format: 'uint16x4', offset: 0, shaderLocation: 4},
          {format: 'uint32x2', offset: 0, shaderLocation: 0},
          {format: 'sint8x4', offset: 4, shaderLocation: 12},
          {format: 'float32x2', offset: 8, shaderLocation: 11},
          {format: 'sint32x4', offset: 4, shaderLocation: 15},
          {format: 'uint16x4', offset: 0, shaderLocation: 1},
          {format: 'uint8x2', offset: 0, shaderLocation: 14},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10},
          {format: 'unorm8x4', offset: 0, shaderLocation: 3},
          {format: 'sint32x4', offset: 0, shaderLocation: 9},
          {format: 'unorm8x4', offset: 12, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 8,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x4', offset: 0, shaderLocation: 2}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', unclippedDepth: true},
});
let commandEncoder217 = device0.createCommandEncoder({});
let texture267 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 14},
  format: 'r32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture268 = device0.createTexture({size: [4, 6, 1], dimension: '3d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST});
let textureView257 = texture161.createView({});
try {
renderPassEncoder11.drawIndexed(2, 0, 0, 9_989_666);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer35, 0);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer188, 'uint16', 38, 8);
} catch {}
try {
device0.queue.writeBuffer(buffer91, 932, new Float16Array(1946).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.451)), 485, 900);
} catch {}
let promise30 = device0.queue.onSubmittedWorkDone();
let commandEncoder218 = device0.createCommandEncoder({});
let texture269 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 20},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder15.setBindGroup(2, bindGroup109, new Uint32Array(48), 2, 0);
} catch {}
try {
renderPassEncoder11.draw(154, 0, 457_633_345);
} catch {}
try {
renderPassEncoder11.drawIndexed(2, 0, 0, 350_187_616);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(3, buffer43, 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer163, 76, new Uint32Array(19509).map((_, i) => i * 8), 2370, 16);
} catch {}
let gpuCanvasContext15 = canvas9.getContext('webgpu');
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(69); };
} catch {}
let bindGroup114 = device0.createBindGroup({layout: autogeneratedBindGroupLayout16, entries: [{binding: 1, resource: externalTexture18}]});
try {
computePassEncoder12.setBindGroup(0, bindGroup98, [0]);
} catch {}
try {
renderPassEncoder11.draw(150, 0, 113_858_270);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup67, []);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup34, new Uint32Array(2359), 168, 1);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline48);
} catch {}
try {
renderBundleEncoder16.pushDebugGroup('\u2344');
} catch {}
try {
device0.queue.writeBuffer(buffer60, 8, new BigInt64Array(81).map((_, i) => BigInt(i - 1)), 8, 8);
} catch {}
let promise31 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule2, targets: [{format: 'r16sint'}]},
  vertex: {
    module: shaderModule8,
    entryPoint: 'vertex8',
    buffers: [
      {
        arrayStride: 40,
        attributes: [
          {format: 'uint32x2', offset: 4, shaderLocation: 0},
          {format: 'float16x4', offset: 0, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 10},
          {format: 'uint8x2', offset: 0, shaderLocation: 8},
          {format: 'unorm8x4', offset: 8, shaderLocation: 11},
          {format: 'unorm16x4', offset: 8, shaderLocation: 5},
          {format: 'sint8x2', offset: 14, shaderLocation: 6},
          {format: 'snorm16x4', offset: 0, shaderLocation: 7},
          {format: 'snorm16x2', offset: 16, shaderLocation: 3},
          {format: 'uint8x4', offset: 0, shaderLocation: 1},
          {format: 'sint32x2', offset: 0, shaderLocation: 12},
          {format: 'uint16x2', offset: 0, shaderLocation: 9},
          {format: 'float32x2', offset: 0, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 56,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint32x2', offset: 0, shaderLocation: 4},
          {format: 'uint32x3', offset: 0, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let gpuCanvasContext16 = canvas8.getContext('webgpu');
let imageData34 = new ImageData(16, 32);
let commandEncoder219 = device0.createCommandEncoder();
let texture270 = gpuCanvasContext0.getCurrentTexture();
try {
renderPassEncoder11.drawIndexed(2, 0, 0, -1_568_952_390, 0);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer54, 0);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(2, buffer71, 0, 14);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline12);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 996 */
  offset: 996,
  bytesPerRow: 24832,
  buffer: buffer11,
}, {
  texture: texture84,
  mipLevel: 0,
  origin: {x: 14, y: 11, z: 6},
  aspect: 'all',
}, {width: 18, height: 22, depthOrArrayLayers: 0});
} catch {}
let shaderModule13 = device0.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

requires packed_4x8_integer_dot_product;

var<private> vp13: vec2u = vec2u(422418387, 707025412);

@group(1) @binding(384) var<storage, read> buffer198: array<array<array<array<array<VertexInput47, 5>, 1>, 20>, 1>>;

struct T3 {
  @align(16) @size(224) f0: array<array<atomic<u32>, 1>, 16>,
  @align(16) @size(176) f1: atomic<u32>,
}

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

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

struct FragmentInput29 {
  @location(13) location_13: f32,
  @location(10) location_10: i32,
}

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

struct VertexInput47 {
  @location(7) @interpolate(flat, first) location_7: i32,
}

struct T14 {
  f0: array<T1>,
}

struct VertexInput46 {
  @location(6) location_6: vec2f,
  @builtin(instance_index) instance_index: u32,
  @location(14) location_14: vec4h,
  @location(11) location_11: vec2i,
}

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

@id(59839) override override24: u32;

struct T12 {
  f0: array<u32>,
}

struct T11 {
  @align(16) @size(16) f0: vec2h,
  @align(16) @size(384) f1: i32,
}

struct T5 {
  @size(16) f0: f32,
  f1: array<T1>,
}

struct VertexInput49 {
  @location(2) location_2: f16,
  @location(15) location_15: vec2i,
  @location(0) location_0: vec2h,
  @location(13) location_13: vec2i,
}

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

struct T8 {
  @align(32) f0: array<T1>,
}

override override23: u32 = (106985133 % 103) + 1;

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

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

struct VertexInput48 {
  @location(12) @interpolate(linear, centroid) location_12: vec4h,
}

alias vec3b = vec3<bool>;

struct T2 {
  @align(32) f0: array<atomic<u32>>,
}

struct FragmentOutput7 {
  @location(4) @interpolate(flat) location_4: vec4i,
  @location(2) location_2: vec4u,
  @location(6) location_6: vec2u,
  @location(0) location_0: vec4i,
}

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

struct T1 {
  f0: atomic<u32>,
}

@group(0) @binding(147) var st19: texture_storage_1d<r32sint, read_write>;

@group(0) @binding(6) var<storage, read_write> buffer196: array<array<VertexInput46, 10>>;

struct T6 {
  @align(64) @size(320) f0: f16,
}

struct T13 {
  @size(64) f0: T1,
  f1: array<array<f16, 1>>,
}

@id(33987) override override25: u32 = (424942892 % 103) + 1;

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

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

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

struct T4 {
  @size(56) f0: vec4h,
}

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

/* used global variables: buffer198 */
@vertex
fn vertex15(@location(10) location_10: vec4h, a1: VertexInput46, a2: VertexInput47, @location(1) location_1: u32, @builtin(vertex_index) vertex_index: u32, @location(3) location_3: f32, @location(5) @interpolate(flat) location_5: i32, a7: VertexInput48, a8: VertexInput49, @location(4) @interpolate(flat) location_4: i32, a10: VertexInput50, @location(9) @interpolate(flat) location_9: vec2u) -> @builtin(position) vec4f {
  var out: vec4f;
  out = vec4f(f32((*&buffer198)[unconst_u32(16998908)][unconst_u32(174058672)][19][unconst_u32(335447313)][unconst_u32(22977049)].location_7));
  out = vec4f(bitcast<f32>((*&buffer198)[arrayLength(&(*&buffer198))][0][unconst_u32(30703179)][0][4].location_7));
  let ptr80: ptr<storage, array<array<VertexInput47, 5>, 1>, read> = &(*&buffer198)[arrayLength(&(*&buffer198))][unconst_u32(1362880946)][19];
  return out;
  _ = buffer198;
}

/* used global variables: buffer196, buffer197, buffer198, st19 */
@fragment
fn fragment12(@location(6) location_6: f16, @location(4) location_4: i32, a2: FragmentInput29) -> FragmentOutput7 {
  var out: FragmentOutput7;
  vp13 *= vec2u(u32(buffer197[arrayLength(&buffer197)][1][u32((*&buffer197)[unconst_u32(221441958)][unconst_u32(16913016)][unconst_u32(4294967295)][0][unconst_u32(1095109747)][unconst_u32(1044998955)][u32(buffer197[arrayLength(&buffer197)][1][5][unconst_u32(115726339)][u32((*&buffer197)[unconst_u32(178381616)][1][5][0][0][unconst_u32(558396908)][unconst_u32(1242861192)][unconst_u32(906268044)][unconst_u32(815176823)][unconst_u32(2882149905)][0][0])][u32((*&buffer197)[unconst_u32(653722584)][1][unconst_u32(723419293)][unconst_u32(176224133)][0][unconst_u32(3362034615)][unconst_u32(90401192)][22][0][u32(buffer197[unconst_u32(150927811)][u32(buffer197[arrayLength(&buffer197)][1][5][0][0][0][0][22][0][unconst_u32(634153486)][0][unconst_u32(907247963)])][unconst_u32(979410764)][0][u32(buffer197[unconst_u32(358888613)][1][5][unconst_u32(226452645)][0][0][u32(buffer197[arrayLength(&buffer197)][1][unconst_u32(288759037)][0][0][0][unconst_u32(107226809)][unconst_u32(191507140)][0][unconst_u32(101340814)][unconst_u32(567504054)][unconst_u32(760178596)])][22][0][unconst_u32(318031492)][0][0])][0][unconst_u32(92608026)][22][unconst_u32(19617505)][unconst_u32(566767196)][0][0])][unconst_u32(578825088)][0])][unconst_u32(63316019)][unconst_u32(336776553)][unconst_u32(688822951)][0][unconst_u32(7255640)][unconst_u32(509650520)])][22][0][unconst_u32(1357500325)][0][0])][unconst_u32(1184867996)][unconst_u32(2272168514)][0][0][22][unconst_u32(899929861)][unconst_u32(189225928)][0][unconst_u32(900167119)]));
  let ptr81: ptr<storage, array<f16, 1>, read_write> = &(*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(11386923)][unconst_u32(1219713681)][unconst_u32(1217232330)][0][0][unconst_u32(505649393)][unconst_u32(314542860)][0][0][unconst_u32(26221625)];
  buffer196[unconst_u32(287460475)][unconst_u32(398359397)].instance_index = u32(buffer197[arrayLength(&buffer197)][1][5][0][unconst_u32(89697359)][unconst_u32(1203258525)][0][22][u32((*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(2384329616)][unconst_u32(446624327)][unconst_u32(956069112)][0][0][0][22][unconst_u32(1083921589)][unconst_u32(1301027256)][0][0])][0][0][0]);
  textureStore(st19, unconst_i32(632777845), vec4i(vec4i(unconst_i32(37583397), unconst_i32(502324684), unconst_i32(155493647), unconst_i32(183957200))));
  let ptr82: ptr<storage, f16, read_write> = &(*&buffer197)[arrayLength(&(*&buffer197))][u32(buffer197[unconst_u32(1320486784)][1][u32((*&buffer197)[unconst_u32(562683643)][unconst_u32(1104429267)][unconst_u32(18079992)][0][0][0][0][22][0][unconst_u32(638018806)][unconst_u32(494521339)][0])][unconst_u32(287160550)][0][unconst_u32(409992023)][unconst_u32(241596118)][22][u32(buffer197[arrayLength(&buffer197)][u32((*&buffer197)[arrayLength(&(*&buffer197))][1][5][unconst_u32(2036443312)][u32((*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(3293223159)][unconst_u32(1481609300)][0][0][unconst_u32(370323124)][0][22][unconst_u32(622419256)][unconst_u32(3250125362)][unconst_u32(736198921)][0])][0][unconst_u32(402148370)][unconst_u32(290277521)][unconst_u32(4294967295)][u32((*&buffer197)[unconst_u32(57723256)][u32((*&buffer198)[unconst_u32(185914121)][u32(buffer197[unconst_u32(355830601)][unconst_u32(744827477)][5][0][unconst_u32(1328357375)][unconst_u32(44089922)][unconst_u32(275795251)][22][unconst_u32(49208221)][0][unconst_u32(412972511)][0])][19][unconst_u32(8232737)][u32((*&buffer197)[arrayLength(&(*&buffer197))][1][5][0][0][0][unconst_u32(137335206)][unconst_u32(1424622783)][unconst_u32(1228410771)][0][unconst_u32(2880640473)][unconst_u32(2162272850)])].location_7)][5][0][unconst_u32(2220306865)][0][0][22][0][0][unconst_u32(528773296)][0])][u32((*&buffer197)[arrayLength(&(*&buffer197))][u32(buffer197[unconst_u32(62084872)][1][5][0][unconst_u32(688600672)][unconst_u32(801041326)][0][22][0][u32((*&buffer197)[unconst_u32(1312547256)][1][unconst_u32(876672645)][0][0][0][0][unconst_u32(654149506)][0][unconst_u32(123378518)][0][0])][0][unconst_u32(408937144)])][5][unconst_u32(323143764)][0][unconst_u32(621563464)][u32((*&buffer197)[arrayLength(&(*&buffer197))][1][5][0][unconst_u32(465395981)][0][unconst_u32(1976492096)][22][unconst_u32(817091919)][0][unconst_u32(669690714)][unconst_u32(579368351)])][unconst_u32(472006661)][0][unconst_u32(88622457)][0][0])][0])][5][unconst_u32(89984439)][unconst_u32(519885362)][0][unconst_u32(12571726)][22][0][0][unconst_u32(607688123)][0])][0][0][0])][5][0][0][unconst_u32(1287532125)][0][22][unconst_u32(571733851)][0][0][0];
  let ptr83: ptr<storage, array<f16, 1>, read_write> = &(*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(203158769)][5][0][unconst_u32(1172651426)][0][0][22][unconst_u32(287881695)][0][unconst_u32(743003166)];
  return out;
  _ = buffer197;
  _ = buffer196;
  _ = buffer198;
  _ = st19;
}

/* used global variables: buffer196, buffer197 */
@compute @workgroup_size(1, 1, 1)
fn compute12(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(num_workgroups) num_workgroups: vec3u, a4: ComputeInput15) {
  vp13 ^= vec2u(u32((*&buffer197)[unconst_u32(802062780)][unconst_u32(1183527467)][5][unconst_u32(81530408)][unconst_u32(416357758)][u32(buffer197[arrayLength(&buffer197)][1][5][unconst_u32(260776411)][unconst_u32(407466382)][0][unconst_u32(1074654428)][22][unconst_u32(332083243)][0][unconst_u32(1509224483)][unconst_u32(75820438)])][0][22][0][unconst_u32(23820030)][0][0]));
  var vf145: f16 = length(vec3h(unconst_f16(7076.6), unconst_f16(-19308.9), unconst_f16(1236.3)));
  buffer196[unconst_u32(1437432044)][unconst_u32(713354742)].location_6 = vec2f(f32(buffer197[unconst_u32(5668098)][1][5][unconst_u32(970824482)][unconst_u32(77370481)][unconst_u32(1972792225)][0][unconst_u32(455926681)][unconst_u32(1880568413)][u32(buffer197[unconst_u32(515053142)][unconst_u32(240202516)][unconst_u32(2691367968)][unconst_u32(413068994)][unconst_u32(982240911)][unconst_u32(3773028068)][unconst_u32(714343348)][22][unconst_u32(72454852)][0][0][0])][unconst_u32(668319458)][unconst_u32(1104069874)]));
  let ptr84: ptr<storage, f16, read_write> = &buffer197[unconst_u32(291326630)][unconst_u32(93117255)][unconst_u32(275955769)][0][0][unconst_u32(1792898584)][0][22][0][0][0][unconst_u32(2079001953)];
  let ptr85: ptr<storage, f16, read_write> = &(*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(117028047)][5][unconst_u32(717472310)][0][unconst_u32(148750343)][unconst_u32(454556681)][22][0][unconst_u32(439106189)][unconst_u32(1467895981)][unconst_u32(284719156)];
  let ptr86: ptr<storage, f16, read_write> = &buffer197[arrayLength(&buffer197)][unconst_u32(615188646)][5][unconst_u32(539305020)][0][unconst_u32(207215257)][unconst_u32(2414792303)][u32(buffer197[arrayLength(&buffer197)][unconst_u32(650243486)][unconst_u32(30850109)][0][unconst_u32(44593920)][0][0][22][unconst_u32(1651804825)][0][0][0])][0][0][unconst_u32(162109709)][unconst_u32(106890252)];
  let ptr87: ptr<storage, f16, read_write> = &buffer197[arrayLength(&buffer197)][1][unconst_u32(379489087)][0][unconst_u32(657630847)][0][unconst_u32(476096592)][22][unconst_u32(144938745)][0][unconst_u32(1029440309)][unconst_u32(571045900)];
  _ = buffer196;
  _ = buffer197;
}`,
});
let pipelineLayout5 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout19, veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout12],
});
let commandEncoder220 = device0.createCommandEncoder({});
try {
computePassEncoder4.setBindGroup(1, bindGroup49, []);
} catch {}
try {
renderPassEncoder11.draw(29, 0, 398_889_492);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer68, 36);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer136, 'uint32', 4, 5);
} catch {}
let texture271 = device0.createTexture({
  size: [195, 120, 112],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView258 = texture93.createView({dimension: '2d-array'});
let renderPassEncoder30 = commandEncoder213.beginRenderPass({
  colorAttachments: [{
  view: textureView255,
  depthSlice: 52,
  clearValue: { r: 949.3, g: -508.2, b: -427.5, a: -369.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder11.drawIndirect(buffer94, 4);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder20.insertDebugMarker('\u0e75');
} catch {}
let commandEncoder221 = device0.createCommandEncoder({});
let textureView259 = texture220.createView({});
let textureView260 = texture49.createView({aspect: 'all'});
try {
renderPassEncoder11.drawIndexedIndirect(buffer136, 8);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer106, 'uint16', 42, 7);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline40);
} catch {}
try {
commandEncoder134.copyBufferToBuffer(buffer43, 20, buffer153, 40, 0);
} catch {}
let bindGroup115 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 58, resource: {buffer: buffer21, size: 1576}},
    {binding: 6, resource: {buffer: buffer109}},
    {binding: 3, resource: textureView3},
    {binding: 43, resource: {buffer: buffer179}},
  ],
});
let commandEncoder222 = device0.createCommandEncoder({});
try {
renderPassEncoder11.drawIndexed(2, 0, 0, 1_168_559_985);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer137, 'uint32', 0, 9);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer108, 0);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline39);
} catch {}
try {
renderBundleEncoder16.popDebugGroup();
} catch {}
try {
renderPassEncoder22.insertDebugMarker('\u6171');
} catch {}
let commandEncoder223 = device0.createCommandEncoder({});
try {
renderPassEncoder11.end();
} catch {}
try {
renderBundleEncoder25.insertDebugMarker('\u{1fea4}');
} catch {}
let bindGroup116 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout18,
  entries: [
    {binding: 212, resource: textureView26},
    {binding: 1, resource: textureView76},
    {binding: 14, resource: {buffer: buffer90, size: 437}},
    {binding: 39, resource: textureView3},
    {binding: 11, resource: {buffer: buffer174}},
    {binding: 3, resource: {buffer: buffer20}},
    {binding: 33, resource: textureView13},
    {binding: 7, resource: externalTexture22},
  ],
});
let commandEncoder224 = device0.createCommandEncoder({});
let textureView261 = texture174.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1});
let sampler34 = device0.createSampler({addressModeW: 'mirror-repeat', minFilter: 'nearest'});
try {
renderBundleEncoder28.setBindGroup(3, bindGroup104, new Uint32Array(202), 12, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 2,
  origin: {x: 41, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(41).fill(69), /* required buffer size: 41 */
{offset: 41, bytesPerRow: 163, rowsPerImage: 62}, {width: 61, height: 6, depthOrArrayLayers: 0});
} catch {}
let pipeline49 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule4,
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 40,
        attributes: [
          {format: 'sint8x4', offset: 12, shaderLocation: 13},
          {format: 'sint16x2', offset: 0, shaderLocation: 7},
          {format: 'float16x2', offset: 4, shaderLocation: 6},
          {format: 'sint16x4', offset: 0, shaderLocation: 10},
          {format: 'snorm8x2', offset: 6, shaderLocation: 2},
          {format: 'unorm8x4', offset: 8, shaderLocation: 12},
          {format: 'sint16x2', offset: 0, shaderLocation: 0},
          {format: 'uint8x4', offset: 0, shaderLocation: 4},
          {format: 'snorm8x4', offset: 0, shaderLocation: 9},
          {format: 'uint32x3', offset: 0, shaderLocation: 15},
          {format: 'unorm8x4', offset: 0, shaderLocation: 8},
          {format: 'uint16x4', offset: 20, shaderLocation: 1},
          {format: 'uint8x4', offset: 0, shaderLocation: 3},
          {format: 'float32x3', offset: 0, shaderLocation: 11},
          {format: 'float32', offset: 4, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [{format: 'unorm10-10-10-2', offset: 0, shaderLocation: 14}],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
let texture272 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 2},
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture273 = device0.createTexture({
  size: {width: 780, height: 480, depthOrArrayLayers: 349},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['r16sint'],
});
try {
renderPassEncoder4.setBindGroup(0, bindGroup13);
} catch {}
await gc();
let commandEncoder225 = device0.createCommandEncoder({});
let texture274 = device0.createTexture({
  size: {width: 4, height: 6, depthOrArrayLayers: 1},
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder7.setBindGroup(3, bindGroup116, new Uint32Array(1549), 279, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer108, 'uint32', 4, 5);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer100, 'uint16', 22, 24);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
  await promise30;
} catch {}
let img7 = await imageWithData(5, 48, '#10101010', '#20202020');
let imageData35 = new ImageData(28, 40);
let bindGroup117 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout6,
  entries: [{binding: 3, resource: textureView3}, {binding: 1, resource: externalTexture13}],
});
let textureView262 = texture272.createView({dimension: '3d'});
let texture275 = device0.createTexture({
  size: [32, 48, 8],
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView263 = texture35.createView({baseArrayLayer: 0});
try {
renderPassEncoder0.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup30, new Uint32Array(962), 70, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let buffer199 = device0.createBuffer({size: 141, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder226 = device0.createCommandEncoder({});
let texture276 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture277 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 478},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder27.setPipeline(pipeline37);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(7, buffer156, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer101, 0, new DataView(new Uint8Array(4638).map((_, i) => i).buffer), 880, 32);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture138,
  mipLevel: 0,
  origin: {x: 7, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(513).fill(49), /* required buffer size: 513 */
{offset: 513}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
let promise32 = device0.queue.onSubmittedWorkDone();
await gc();
let bindGroup118 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 33, resource: textureView38},
    {binding: 5, resource: textureView53},
    {binding: 9, resource: {buffer: buffer146}},
    {binding: 40, resource: externalTexture28},
    {binding: 255, resource: {buffer: buffer37}},
    {binding: 7, resource: textureView4},
    {binding: 45, resource: externalTexture17},
    {binding: 0, resource: {buffer: buffer35}},
    {binding: 2, resource: {buffer: buffer36, offset: 0}},
    {binding: 6, resource: textureView76},
    {binding: 11, resource: {buffer: buffer21, size: 3304}},
    {binding: 84, resource: {buffer: buffer116}},
    {binding: 264, resource: textureView36},
    {binding: 219, resource: textureView3},
    {binding: 210, resource: {buffer: buffer21, size: 2672}},
    {binding: 3, resource: {buffer: buffer21, size: 136}},
    {binding: 269, resource: textureView160},
    {binding: 117, resource: {buffer: buffer21, size: 1596}},
    {binding: 211, resource: {buffer: buffer179}},
    {binding: 148, resource: textureView54},
    {binding: 284, resource: textureView59},
    {binding: 386, resource: textureView174},
    {binding: 201, resource: {buffer: buffer21, size: 2184}},
  ],
});
let commandEncoder227 = device0.createCommandEncoder({});
let textureView264 = texture220.createView({dimension: '2d-array'});
let computePassEncoder29 = commandEncoder156.beginComputePass();
let externalTexture50 = device0.importExternalTexture({source: videoFrame2});
try {
computePassEncoder25.setBindGroup(0, bindGroup105, [0]);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline27);
} catch {}
try {
commandEncoder227.insertDebugMarker('\u02d3');
} catch {}
let commandEncoder228 = device0.createCommandEncoder({});
try {
renderPassEncoder21.setBindGroup(2, bindGroup19, new Uint32Array(3889), 246, 1);
} catch {}
try {
renderPassEncoder14.setViewport(188.89976216528652, 238.3869768454004, 126.7319000309916, 0.25484873487730697, 0.8989803086615178, 0.992881062677733);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let autogeneratedBindGroupLayout27 = pipeline3.getBindGroupLayout(0);
let bindGroup119 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer111, size: 36}}],
});
let commandEncoder229 = device0.createCommandEncoder({});
let externalTexture51 = device0.importExternalTexture({source: videoFrame15});
try {
renderPassEncoder19.setVertexBuffer(0, buffer96);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer131, 'uint16', 4, 10);
} catch {}
try {
buffer183.unmap();
} catch {}
try {
commandEncoder130.resolveQuerySet(querySet0, 110, 0, buffer141, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer56, 104, new Uint32Array(3811).map((_, i) => i * 8), 389, 220);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture108,
  mipLevel: 0,
  origin: {x: 34, y: 20, z: 5},
  aspect: 'all',
}, new Uint8Array(13_227).fill(56), /* required buffer size: 13_227 */
{offset: 207, bytesPerRow: 36, rowsPerImage: 40}, {width: 12, height: 2, depthOrArrayLayers: 10});
} catch {}
try {
computePassEncoder29.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder20.setBindGroup(1, bindGroup74, new Uint32Array(241), 56, 0);
} catch {}
let bindGroup120 = device0.createBindGroup({
  label: '\u0bd4\u8882\u19eb\ua311',
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 58, resource: {buffer: buffer107}},
    {binding: 6, resource: {buffer: buffer133, offset: 0, size: 20}},
    {binding: 3, resource: textureView3},
    {binding: 43, resource: {buffer: buffer51}},
  ],
});
let buffer200 = device0.createBuffer({size: 206, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let commandBuffer10 = commandEncoder54.finish();
let textureView265 = texture185.createView({dimension: 'cube-array', format: 'r16sint', baseArrayLayer: 1, arrayLayerCount: 6});
let textureView266 = texture57.createView({});
let externalTexture52 = device0.importExternalTexture({source: videoFrame31});
try {
renderPassEncoder19.drawIndexedIndirect(buffer117, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer120, 12, new BigInt64Array(8472).map((_, i) => BigInt(i - 0)), 15, 4);
} catch {}
let autogeneratedBindGroupLayout28 = pipeline47.getBindGroupLayout(0);
let bindGroup121 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout22,
  entries: [{binding: 6, resource: {buffer: buffer70}}, {binding: 58, resource: {buffer: buffer107}}],
});
try {
renderPassEncoder26.setVertexBuffer(0, buffer146, 0, 10);
} catch {}
try {
renderBundleEncoder0.setBindGroup(1, bindGroup106, [0]);
} catch {}
let commandEncoder230 = device0.createCommandEncoder();
let texture278 = gpuCanvasContext2.getCurrentTexture();
try {
renderPassEncoder19.drawIndexedIndirect(buffer144, 20);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer54, 12);
} catch {}
let autogeneratedBindGroupLayout29 = pipeline28.getBindGroupLayout(0);
let textureView267 = texture63.createView({aspect: 'all'});
let sampler35 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 57.11, maxAnisotropy: 1});
try {
commandEncoder119.copyTextureToBuffer({
  texture: texture255,
  mipLevel: 0,
  origin: {x: 53, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5648 */
  offset: 5648,
  bytesPerRow: 17408,
  rowsPerImage: 7,
  buffer: buffer91,
}, {width: 11, height: 6, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 14,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 69,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let autogeneratedBindGroupLayout30 = pipeline37.getBindGroupLayout(0);
let commandEncoder231 = device0.createCommandEncoder({});
let textureView268 = texture274.createView({aspect: 'all', baseArrayLayer: 0});
let textureView269 = texture267.createView({baseArrayLayer: 6, arrayLayerCount: 1});
try {
renderPassEncoder21.setBindGroup(1, bindGroup118, [0, 0]);
} catch {}
try {
renderPassEncoder19.draw(0, 203, 0, 2_590_725_446);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer102, 4);
} catch {}
try {
buffer173.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture205,
  mipLevel: 0,
  origin: {x: 67, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(162).fill(29), /* required buffer size: 162 */
{offset: 162, bytesPerRow: 362}, {width: 159, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise33 = device0.queue.onSubmittedWorkDone();
try {
renderPassEncoder14.setBindGroup(2, bindGroup0, new Uint32Array(2780), 106, 0);
} catch {}
try {
renderPassEncoder19.drawIndirect(buffer59, 8);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup9);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer90, 'uint32', 56, 106);
} catch {}
let computePassEncoder30 = commandEncoder99.beginComputePass();
try {
computePassEncoder30.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder19.end();
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline26);
} catch {}
try {
buffer46.unmap();
} catch {}
let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d' },
    },
    {binding: 40, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 70,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 161,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup122 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout18,
  entries: [
    {binding: 212, resource: textureView241},
    {binding: 7, resource: externalTexture1},
    {binding: 1, resource: textureView76},
    {binding: 39, resource: textureView17},
    {binding: 11, resource: {buffer: buffer141}},
    {binding: 14, resource: {buffer: buffer56}},
    {binding: 3, resource: {buffer: buffer103}},
    {binding: 33, resource: textureView13},
  ],
});
let buffer201 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder232 = device0.createCommandEncoder({});
try {
renderPassEncoder3.setBindGroup(1, bindGroup31);
} catch {}
try {
commandEncoder80.copyBufferToBuffer(buffer43, 0, buffer132, 20, 0);
} catch {}
let bindGroup123 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []});
let commandEncoder233 = device0.createCommandEncoder({});
try {
computePassEncoder18.setBindGroup(0, bindGroup88);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer69, 'uint32', 40, 188);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer112, 'uint16', 22, 1);
} catch {}
try {
buffer32.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer159, 0, new Float64Array(9773).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/9772)), 1525, 8);
} catch {}
let bindGroup124 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 184, resource: {buffer: buffer136}},
    {binding: 0, resource: {buffer: buffer56}},
    {binding: 5, resource: sampler22},
    {binding: 1, resource: sampler31},
    {binding: 365, resource: textureView218},
    {binding: 48, resource: textureView3},
    {binding: 32, resource: externalTexture4},
  ],
});
try {
renderPassEncoder6.setIndexBuffer(buffer52, 'uint16', 6, 0);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline18);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(5, buffer139, 76, 13);
} catch {}
let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 47,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 241,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 290,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 348,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 556,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 711,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let textureView270 = texture36.createView({mipLevelCount: 1});
try {
renderPassEncoder14.setBindGroup(2, bindGroup24, new Uint32Array(2823), 382, 1);
} catch {}
try {
renderPassEncoder15.insertDebugMarker('\u{1faa0}');
} catch {}
try {
device0.queue.submit([commandBuffer10]);
} catch {}
let commandBuffer11 = commandEncoder68.finish({});
let texture279 = device0.createTexture({
  size: [780, 480, 1],
  mipLevelCount: 2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
commandEncoder177.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 32 */
  offset: 32,
  bytesPerRow: 36352,
  buffer: buffer0,
}, {
  texture: texture276,
  mipLevel: 1,
  origin: {x: 13, y: 2, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: canvas9,
  origin: { x: 16, y: 20 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 37, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 23, height: 8, depthOrArrayLayers: 0});
} catch {}
let textureView271 = texture220.createView({baseMipLevel: 0});
try {
commandEncoder71.clearBuffer(buffer76);
} catch {}
let commandEncoder234 = device0.createCommandEncoder({});
let texture280 = device0.createTexture({size: {width: 4}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderPassEncoder4.setVertexBuffer(0, buffer160, 0, 23);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer9, 'uint16', 6, 8);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline41);
} catch {}
try {
device0.queue.submit([commandBuffer11]);
} catch {}
let promise34 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 97, height: 60, depthOrArrayLayers: 1}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 18, y: 14, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame37 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'linear'} });
let bindGroup125 = device0.createBindGroup({layout: autogeneratedBindGroupLayout14, entries: []});
let texture281 = device0.createTexture({
  size: [16, 24, 4],
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture53 = device0.importExternalTexture({source: videoFrame22});
let bindGroup126 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 138, resource: textureView128},
    {binding: 0, resource: externalTexture49},
    {binding: 1, resource: externalTexture24},
  ],
});
let textureView272 = texture56.createView({dimension: '2d-array'});
try {
device0.queue.writeBuffer(buffer120, 0, new Float32Array(30271).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.200)), 6305, 8);
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(33); };
} catch {}
let buffer202 = device0.createBuffer({size: 272, usage: GPUBufferUsage.COPY_DST});
let commandEncoder235 = device0.createCommandEncoder({});
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
let texture282 = device0.createTexture({
  size: [390, 24, 1],
  mipLevelCount: 3,
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup63, new Uint32Array(877), 231, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture134,
  mipLevel: 1,
  origin: {x: 10, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(118).fill(170), /* required buffer size: 118 */
{offset: 118, bytesPerRow: 448}, {width: 186, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout31 = pipeline47.getBindGroupLayout(0);
let bindGroup127 = device0.createBindGroup({layout: autogeneratedBindGroupLayout21, entries: [{binding: 1, resource: externalTexture27}]});
let commandEncoder236 = device0.createCommandEncoder({});
let texture283 = device0.createTexture({
  label: '\u0c5a\u3e04\u61b7\u0cca\u0686\u{1f708}\u{1f8c0}\uc2bd\u3739\u0a46',
  size: [390, 24, 1],
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16uint'],
});
try {
renderBundleEncoder14.setBindGroup(0, bindGroup67);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer69, 'uint16', 38, 18);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline38);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(1, buffer107);
} catch {}
try {
commandEncoder128.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 16, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 520 widthInBlocks: 130 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 180 */
  offset: 180,
  bytesPerRow: 9472,
  buffer: buffer184,
}, {width: 130, height: 7, depthOrArrayLayers: 0});
} catch {}
let buffer203 = device0.createBuffer({size: 248, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false});
let texture284 = device0.createTexture({
  size: [195, 120, 1605],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder4.setBindGroup(3, bindGroup33, new Uint32Array(1436), 15, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer100, 'uint16', 10, 3);
} catch {}
try {
commandEncoder74.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 0 */
  offset: 0,
  bytesPerRow: 28416,
  buffer: buffer142,
}, {
  texture: texture206,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext10.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
document.body.prepend(canvas4);
let bindGroup128 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 6, resource: {buffer: buffer158}}, {binding: 58, resource: {buffer: buffer107}}],
});
let texture285 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder7.setBindGroup(3, bindGroup104);
} catch {}
try {
commandEncoder86.insertDebugMarker('\ue52f');
} catch {}
try {
device0.queue.writeBuffer(buffer184, 32, new Float16Array(2497).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.689)), 110, 24);
} catch {}
let bindGroup129 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout20,
  entries: [{binding: 69, resource: textureView118}, {binding: 14, resource: textureView245}],
});
let texture286 = device0.createTexture({
  size: [2],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderBundleEncoder18.setBindGroup(0, bindGroup106, new Uint32Array(2927), 91, 1);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(2, buffer59, 0);
} catch {}
let buffer204 = device0.createBuffer({
  size: 223,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView273 = texture34.createView({mipLevelCount: 1});
try {
renderPassEncoder15.setPipeline(pipeline14);
} catch {}
try {
buffer108.unmap();
} catch {}
let img8 = await imageWithData(39, 19, '#10101010', '#20202020');
let autogeneratedBindGroupLayout32 = pipeline20.getBindGroupLayout(2);
let buffer205 = device0.createBuffer({size: 348, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder237 = device0.createCommandEncoder();
let texture287 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture288 = device0.createTexture({
  size: {width: 390, height: 240, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder4.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup129, new Uint32Array(1127), 165, 0);
} catch {}
try {
renderBundleEncoder22.insertDebugMarker('\u3322');
} catch {}
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(6); };
} catch {}
let bindGroup130 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout9,
  entries: [{binding: 1, resource: externalTexture29}, {binding: 3, resource: textureView3}],
});
let commandEncoder238 = device0.createCommandEncoder();
let textureView274 = texture287.createView({dimension: '2d-array'});
let texture289 = device0.createTexture({
  size: [780, 480, 1],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder1.setBindGroup(1, bindGroup105, [0]);
} catch {}
try {
  await promise34;
} catch {}
document.body.append(img0);
let bindGroup131 = device0.createBindGroup({layout: autogeneratedBindGroupLayout18, entries: [{binding: 1, resource: externalTexture46}]});
let commandEncoder239 = device0.createCommandEncoder();
let textureView275 = texture212.createView({dimension: 'cube', aspect: 'all', baseArrayLayer: 1});
let texture290 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 13},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView276 = texture279.createView({dimension: '2d-array', mipLevelCount: 1});
try {
buffer57.unmap();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(20); };
} catch {}
let commandEncoder240 = device0.createCommandEncoder({});
let texture291 = device0.createTexture({
  size: [8, 12, 2],
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView277 = texture92.createView({arrayLayerCount: 1});
try {
computePassEncoder29.setBindGroup(1, bindGroup18, new Uint32Array(5274), 90, 0);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(3, buffer62, 0, 4);
} catch {}
let buffer206 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView278 = texture4.createView({mipLevelCount: 1});
try {
renderBundleEncoder14.setIndexBuffer(buffer112, 'uint32', 0, 26);
} catch {}
let videoFrame38 = new VideoFrame(videoFrame20, {timestamp: 0});
let textureView279 = texture34.createView({baseArrayLayer: 0});
try {
renderPassEncoder2.setBindGroup(3, bindGroup79);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer74, 'uint16', 0, 86);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(0, buffer154, 36);
} catch {}
let buffer207 = device0.createBuffer({size: 357, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder241 = device0.createCommandEncoder();
let textureView280 = texture188.createView({dimension: '2d', format: 'astc-5x5-unorm-srgb', mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder17.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder23.setBindGroup(1, bindGroup127);
} catch {}
try {
commandEncoder210.resolveQuerySet(querySet1, 338, 1, buffer57, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer184, 128, new DataView(new Uint8Array(34037).map((_, i) => i).buffer), 6151, 4);
} catch {}
let bindGroup132 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []});
try {
renderPassEncoder25.setBindGroup(3, bindGroup72, new Uint32Array(12), 2, 0);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder6.draw(0, 0);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer19, 'uint32', 0, 25);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView281 = texture161.createView({dimension: '1d'});
let renderBundle3 = renderBundleEncoder6.finish({});
try {
computePassEncoder14.setBindGroup(0, bindGroup78);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer1, 'uint16', 46, 35);
} catch {}
document.body.prepend(canvas5);
let buffer208 = device0.createBuffer({size: 168, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder8.setBindGroup(0, bindGroup90, new Uint32Array(46), 4, 2);
} catch {}
try {
buffer55.unmap();
} catch {}
try {
  await promise33;
} catch {}
let texture292 = device0.createTexture({
  size: {width: 1560, height: 96, depthOrArrayLayers: 1},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let textureView282 = texture197.createView({});
try {
renderPassEncoder16.setPipeline(pipeline26);
} catch {}
try {
device0.queue.writeBuffer(buffer137, 0, new Float16Array(15680).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.568)), 413, 8);
} catch {}
let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {binding: 2, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 9, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 11,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 33,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 40,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {binding: 45, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 84,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 148,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 201,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 210,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 211,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 219,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 255,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 264,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 269,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 284,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 386,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
try {
computePassEncoder27.setBindGroup(1, bindGroup58, [0]);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer188, 'uint16', 234, 3);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup2);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer65, 'uint16', 0, 3);
} catch {}
let commandEncoder242 = device0.createCommandEncoder({});
try {
computePassEncoder18.setBindGroup(0, bindGroup22, new Uint32Array(2475), 305, 1);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer65, 'uint32', 4, 2);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline27);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture218,
  mipLevel: 0,
  origin: {x: 252, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(25).fill(121), /* required buffer size: 25 */
{offset: 25}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(9); };
} catch {}
let buffer209 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let texture293 = device0.createTexture({
  size: [195, 120, 1],
  mipLevelCount: 4,
  dimension: '2d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView283 = texture293.createView({mipLevelCount: 1});
try {
renderPassEncoder20.setIndexBuffer(buffer144, 'uint16', 12, 1);
} catch {}
try {
commandEncoder79.copyBufferToBuffer(buffer143, 8, buffer208, 8, 4);
} catch {}
document.body.append(img1);
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout4, veryExplicitBindGroupLayout9]});
let texture294 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView284 = texture9.createView({dimension: '2d-array', aspect: 'all'});
try {
computePassEncoder24.setBindGroup(0, bindGroup95, new Uint32Array(1904), 962, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer76, 24, new Float32Array(334).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.689)), 26, 4);
} catch {}
let bindGroup133 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 5, resource: sampler13},
    {binding: 1, resource: sampler5},
    {binding: 48, resource: textureView0},
    {binding: 0, resource: {buffer: buffer107}},
    {binding: 184, resource: {buffer: buffer176}},
    {binding: 365, resource: textureView249},
    {binding: 32, resource: externalTexture39},
  ],
});
try {
renderPassEncoder25.setBindGroup(3, bindGroup3, new Uint32Array(2085), 91, 1);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer9, 'uint32', 0, 0);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline40);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(0, buffer71);
} catch {}
let bindGroup134 = device0.createBindGroup({layout: autogeneratedBindGroupLayout17, entries: []});
try {
computePassEncoder25.setBindGroup(1, bindGroup33);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(12); };
} catch {}
let commandEncoder243 = device0.createCommandEncoder({});
let pipeline50 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule12, entryPoint: 'compute10', constants: {}}});
let offscreenCanvas8 = new OffscreenCanvas(63, 107);
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]});
let buffer210 = device0.createBuffer({size: 252, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
computePassEncoder30.setBindGroup(0, bindGroup47, new Uint32Array(971), 98, 0);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline23);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline38);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder232.clearBuffer(buffer66);
} catch {}
try {
commandEncoder60.resolveQuerySet(querySet1, 172, 11, buffer76, 0);
} catch {}
try {
commandEncoder216.insertDebugMarker('\u05b9');
} catch {}
let promise35 = device0.queue.onSubmittedWorkDone();
let pipeline51 = await promise21;
let bindGroup135 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 6, resource: {buffer: buffer158, offset: 0}}, {binding: 58, resource: {buffer: buffer107}}],
});
let buffer211 = device0.createBuffer({size: 33, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
try {
renderPassEncoder24.setIndexBuffer(buffer1, 'uint32', 132, 85);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline31);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer156, 0, 0);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer63, 'uint32', 28, 30);
} catch {}
let gpuCanvasContext17 = offscreenCanvas8.getContext('webgpu');
let buffer212 = device0.createBuffer({size: 348, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
renderBundleEncoder26.setBindGroup(0, bindGroup117);
} catch {}
try {
renderBundleEncoder26.drawIndexedIndirect(buffer109, 0);
} catch {}
try {
renderBundleEncoder26.drawIndirect(buffer22, 0);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline38);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(2, buffer9, 0);
} catch {}
let promise36 = device0.queue.onSubmittedWorkDone();
let bindGroup136 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 3, resource: textureView17}, {binding: 1, resource: externalTexture12}],
});
try {
renderBundleEncoder17.setBindGroup(1, bindGroup43, new Uint32Array(2661), 979, 0);
} catch {}
try {
renderBundleEncoder26.draw(306, 0, 636_222_935);
} catch {}
try {
renderBundleEncoder26.drawIndexed(2, 0, 0, -1_831_901_914);
} catch {}
try {
renderBundleEncoder26.drawIndirect(buffer200, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer131, 'uint16', 30, 79);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(6, buffer137);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup24, new Uint32Array(333), 19, 1);
} catch {}
try {
renderBundleEncoder26.drawIndexed(2, 0, 1, 657_832_087, 0);
} catch {}
try {
renderBundleEncoder26.drawIndirect(buffer68, 20);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let pipeline52 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule11, constants: {}}});
let bindGroup137 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout20,
  entries: [{binding: 69, resource: textureView63}, {binding: 14, resource: textureView118}],
});
let texture295 = device0.createTexture({
  size: [32],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder14.setBindGroup(0, bindGroup134, new Uint32Array(3991), 910, 0);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(0, buffer68, 80);
} catch {}
let commandEncoder244 = device0.createCommandEncoder({});
let renderBundle4 = renderBundleEncoder26.finish();
try {
renderPassEncoder28.setVertexBuffer(3, buffer136, 12, 36);
} catch {}
try {
buffer159.unmap();
} catch {}
try {
commandEncoder144.copyTextureToBuffer({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 340 */
  offset: 340,
  bytesPerRow: 34048,
  buffer: buffer132,
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup138 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout23,
  entries: [
    {binding: 7, resource: textureView35},
    {binding: 255, resource: {buffer: buffer116}},
    {binding: 6, resource: textureView76},
    {binding: 284, resource: textureView115},
    {binding: 386, resource: textureView245},
    {binding: 45, resource: externalTexture35},
    {binding: 264, resource: textureView54},
    {binding: 9, resource: {buffer: buffer80}},
    {binding: 3, resource: {buffer: buffer204, size: 128}},
    {binding: 219, resource: textureView0},
    {binding: 5, resource: textureView220},
    {binding: 33, resource: textureView270},
    {binding: 117, resource: {buffer: buffer21, size: 2824}},
    {binding: 210, resource: {buffer: buffer21, size: 1608}},
    {binding: 211, resource: {buffer: buffer179}},
    {binding: 201, resource: {buffer: buffer21, size: 1024}},
    {binding: 84, resource: {buffer: buffer116}},
    {binding: 2, resource: {buffer: buffer156, offset: 0}},
    {binding: 269, resource: textureView160},
    {binding: 40, resource: externalTexture15},
    {binding: 148, resource: textureView54},
    {binding: 0, resource: {buffer: buffer210, size: 89}},
    {binding: 11, resource: {buffer: buffer21, size: 3268}},
  ],
});
let buffer213 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_SRC});
let textureView285 = texture141.createView({dimension: '3d'});
try {
computePassEncoder21.setBindGroup(0, bindGroup82);
} catch {}
try {
computePassEncoder14.setBindGroup(1, bindGroup92, new Uint32Array(828), 47, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer131, 'uint16', 74, 57);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline41);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline31);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer214 = device0.createBuffer({size: 1024, usage: GPUBufferUsage.COPY_SRC});
let texture296 = device0.createTexture({
  size: [195],
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16sint'],
});
try {
computePassEncoder20.setBindGroup(3, bindGroup37);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer53, 'uint32', 4, 0);
} catch {}
try {
renderBundleEncoder22.setBindGroup(1, bindGroup43, new Uint32Array(1128), 191, 0);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline51);
} catch {}
try {
buffer70.unmap();
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 3, y: 5, z: 1},
  aspect: 'all',
}, new Uint8Array(20).fill(129), /* required buffer size: 20 */
{offset: 20, bytesPerRow: 72, rowsPerImage: 89}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 49, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 7, depthOrArrayLayers: 0});
} catch {}
let buffer215 = device0.createBuffer({size: 76, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder245 = device0.createCommandEncoder({});
let texture297 = device0.createTexture({
  size: [195, 120, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder22.setBindGroup(0, bindGroup122);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer71);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline20);
} catch {}
try {
commandEncoder172.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2834 */
  offset: 2834,
  bytesPerRow: 9984,
  buffer: buffer118,
}, {
  texture: texture177,
  mipLevel: 2,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
}, {width: 40, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder75.resolveQuerySet(querySet0, 71, 0, buffer190, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture212,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'stencil-only',
}, new Uint8Array(55).fill(93), /* required buffer size: 55 */
{offset: 55}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: canvas4,
  origin: { x: 6, y: 20 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 6, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 86, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let videoFrame39 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'smpteSt4281'} });
try {
renderPassEncoder4.setBindGroup(0, bindGroup108);
} catch {}
try {
device0.queue.writeBuffer(buffer202, 8, new BigInt64Array(6049).map((_, i) => BigInt(i - 3)), 397, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: img1,
  origin: { x: 4, y: 4 },
  flipY: false,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 211, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 17, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline41);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline26);
} catch {}
try {
device0.queue.writeBuffer(buffer63, 0, new Float32Array(13928).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9632)), 1393, 0);
} catch {}
let pipeline53 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1}});
try {
gpuCanvasContext10.unconfigure();
} catch {}
let autogeneratedBindGroupLayout33 = pipeline22.getBindGroupLayout(0);
let texture298 = device0.createTexture({
  size: {width: 195, height: 120, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderPassEncoder31 = commandEncoder91.beginRenderPass({
  colorAttachments: [{
  view: textureView172,
  clearValue: { r: -761.9, g: 562.0, b: 46.75, a: -666.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderBundleEncoder23.setPipeline(pipeline49);
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(95); };
} catch {}
let buffer216 = device0.createBuffer({size: 352, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder2.setBindGroup(2, bindGroup107);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup13, new Uint32Array(754), 127, 0);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(6, buffer199, 12, 9);
} catch {}
try {
  await buffer159.mapAsync(GPUMapMode.READ, 0, 0);
} catch {}
try {
gpuCanvasContext4.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC});
} catch {}
try {
  await promise32;
} catch {}
let buffer217 = device0.createBuffer({size: 260, usage: GPUBufferUsage.VERTEX});
let commandEncoder246 = device0.createCommandEncoder({});
let textureView286 = texture246.createView({dimension: 'cube', aspect: 'all', format: 'r32float', baseArrayLayer: 1});
try {
renderPassEncoder6.setPipeline(pipeline41);
} catch {}
try {
renderBundleEncoder10.setBindGroup(3, bindGroup85, [0]);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer137, 'uint32', 0, 5);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 508 widthInBlocks: 254 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2972 */
  offset: 2972,
  bytesPerRow: 15872,
  buffer: buffer118,
}, {
  texture: texture43,
  mipLevel: 0,
  origin: {x: 73, y: 247, z: 0},
  aspect: 'all',
}, {width: 254, height: 35, depthOrArrayLayers: 0});
} catch {}
document.body.append(img2);
let commandEncoder247 = device0.createCommandEncoder();
let textureView287 = texture109.createView({dimension: '2d-array'});
try {
renderPassEncoder15.setPipeline(pipeline26);
} catch {}
try {
  await buffer173.mapAsync(GPUMapMode.READ);
} catch {}
document.body.prepend(canvas0);
let commandEncoder248 = device0.createCommandEncoder({});
let texture299 = device0.createTexture({
  size: [2, 2, 14],
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder24.setBindGroup(0, bindGroup6, new Uint32Array(546), 62, 1);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(2, buffer143);
} catch {}
let autogeneratedBindGroupLayout34 = pipeline50.getBindGroupLayout(0);
let commandEncoder249 = device0.createCommandEncoder();
try {
computePassEncoder6.setBindGroup(3, bindGroup66, [0]);
} 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 commandEncoder250 = device0.createCommandEncoder({});
try {
computePassEncoder26.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup44, new Uint32Array(1021), 161, 0);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle4, renderBundle4]);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(6, buffer154);
} catch {}
try {
commandEncoder192.copyBufferToBuffer(buffer117, 16, buffer103, 28, 8);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(14); };
} catch {}
let buffer218 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder251 = device0.createCommandEncoder({});
let texture300 = device0.createTexture({
  size: [97, 60, 238],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler36 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 94.78,
  compare: 'always',
  maxAnisotropy: 1,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup59);
} catch {}
let textureView288 = texture181.createView({dimension: '2d-array', format: 'rgba8snorm', mipLevelCount: 1});
try {
computePassEncoder20.setBindGroup(0, bindGroup135);
} catch {}
try {
adapter0.label = '\u{1ff0d}\u{1faf3}\u{1f786}\u0264\u7e90';
} catch {}
let buffer219 = device0.createBuffer({size: 52, usage: GPUBufferUsage.INDIRECT});
let commandEncoder252 = device0.createCommandEncoder({});
let texture301 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 1},
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder25.setBindGroup(0, bindGroup123);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer78, 0, new Float64Array(7050).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/7046)), 548, 0);
} catch {}
try {
globalThis.someLabel = textureView176.label;
} catch {}
try {
renderBundleEncoder23.setBindGroup(2, bindGroup102, new Uint32Array(4293), 30, 1);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder57.resolveQuerySet(querySet1, 107, 1, buffer204, 0);
} catch {}
try {
commandEncoder247.pushDebugGroup('\u0ee8');
} catch {}
try {
externalTexture50.label = '\u0ed8\u943a\u{1fa7b}\u{1ffac}\u5575\u0cbf\ud1ae\u{1fc74}';
} catch {}
let texture302 = device0.createTexture({size: {width: 97}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST});
let sampler37 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 60.14,
});
let externalTexture54 = device0.importExternalTexture({source: videoFrame27, colorSpace: 'srgb'});
try {
renderPassEncoder1.setBindGroup(2, bindGroup3, [0]);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(0, buffer146);
} catch {}
try {
device0.queue.writeBuffer(buffer63, 0, new Float32Array(3125).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.104)), 15, 16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(4).fill(83), /* required buffer size: 4 */
{offset: 4, bytesPerRow: 18}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup139 = device0.createBindGroup({layout: autogeneratedBindGroupLayout19, entries: []});
let buffer220 = device0.createBuffer({size: 128, usage: GPUBufferUsage.INDIRECT});
let texture303 = device0.createTexture({
  size: [32, 48, 8],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler38 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 99.79, compare: 'never'});
try {
renderPassEncoder2.setVertexBuffer(4, buffer193, 28, 12);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline31);
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(67); };
} catch {}
let imageData36 = new ImageData(16, 20);
let commandEncoder253 = device0.createCommandEncoder();
try {
renderPassEncoder20.beginOcclusionQuery(373);
} catch {}
try {
gpuCanvasContext15.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 1, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 138,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' },
    },
  ],
});
let bindGroup140 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []});
let commandEncoder254 = device0.createCommandEncoder({});
let sampler39 = device0.createSampler({addressModeU: 'repeat', minFilter: 'linear', lodMaxClamp: 77.07, maxAnisotropy: 1});
try {
renderPassEncoder5.setVertexBuffer(5, buffer96, 56);
} catch {}
try {
renderBundleEncoder29.setBindGroup(1, bindGroup0);
} catch {}
try {
commandEncoder236.pushDebugGroup('\u0ff6');
} catch {}
try {
device0.queue.writeBuffer(buffer201, 64, new DataView(new Uint8Array(25796).map((_, i) => i).buffer), 1811, 0);
} catch {}
let bindGroup141 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 6, resource: {buffer: buffer111, size: 20}},
    {binding: 43, resource: {buffer: buffer79}},
    {binding: 58, resource: {buffer: buffer107}},
    {binding: 3, resource: textureView3},
  ],
});
let buffer221 = device0.createBuffer({size: 224, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderBundleEncoder24.setIndexBuffer(buffer55, 'uint32', 3_084, 1_836);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder173.resolveQuerySet(querySet0, 34, 28, buffer187, 0);
} catch {}
try {
computePassEncoder30.insertDebugMarker('\u4e04');
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer216, 12, new DataView(new ArrayBuffer(172288)), 5374, 4);
} catch {}
try {
computePassEncoder12.setBindGroup(2, bindGroup88, new Uint32Array(358), 18, 0);
} catch {}
try {
renderPassEncoder20.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder30.setBindGroup(2, bindGroup23, new Uint32Array(939), 334, 0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer63, 'uint16', 38, 58);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(4, buffer141, 0);
} catch {}
let autogeneratedBindGroupLayout35 = pipeline43.getBindGroupLayout(0);
let bindGroup142 = device0.createBindGroup({layout: autogeneratedBindGroupLayout35, entries: [{binding: 138, resource: textureView121}]});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 2, depthOrArrayLayers: 14}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture246,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder255 = device0.createCommandEncoder({});
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture180,
  mipLevel: 0,
  origin: {x: 12, y: 10, z: 0},
  aspect: 'all',
}, new Uint8Array(69).fill(119), /* required buffer size: 69 */
{offset: 69, bytesPerRow: 242}, {width: 90, height: 10, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 2, depthOrArrayLayers: 14}
*/
{
  source: offscreenCanvas5,
  origin: { x: 0, y: 16 },
  flipY: false,
}, {
  texture: texture246,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData37 = new ImageData(84, 4);
try {
computePassEncoder3.setPipeline(pipeline34);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline46);
} catch {}
try {
gpuCanvasContext17.unconfigure();
} catch {}
let commandEncoder256 = device0.createCommandEncoder({});
try {
computePassEncoder3.setBindGroup(2, bindGroup4, new Uint32Array(789), 1, 1);
} catch {}
try {
renderPassEncoder5.setBindGroup(1, bindGroup63);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup1);
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout32, veryExplicitBindGroupLayout9]});
try {
renderPassEncoder0.setIndexBuffer(buffer152, 'uint32', 8, 0);
} catch {}
try {
renderBundleEncoder23.setBindGroup(0, bindGroup61, new Uint32Array(2399), 177, 0);
} catch {}
try {
buffer70.unmap();
} catch {}
let img9 = await imageWithData(5, 38, '#10101010', '#20202020');
let sampler40 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat'});
try {
computePassEncoder18.setBindGroup(0, bindGroup134);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer118, 'uint32', 520, 225);
} catch {}
try {
commandEncoder222.copyTextureToBuffer({
  texture: texture124,
  mipLevel: 0,
  origin: {x: 63, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 54 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4294 */
  offset: 4294,
  bytesPerRow: 1024,
  buffer: buffer56,
}, {width: 27, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder72.insertDebugMarker('\u0c1e');
} catch {}
try {
device0.queue.writeBuffer(buffer216, 32, new DataView(new ArrayBuffer(68436)), 879, 4);
} catch {}
let bindGroup143 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout31,
  entries: [{binding: 58, resource: {buffer: buffer21, size: 1744}}, {binding: 6, resource: {buffer: buffer154}}],
});
let textureView289 = texture294.createView({});
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
renderPassEncoder30.setBindGroup(3, bindGroup14, new Uint32Array(2453), 708, 1);
} catch {}
try {
  await promise35;
} catch {}
try {
computePassEncoder29.setBindGroup(3, bindGroup10, [0]);
} catch {}
try {
renderBundleEncoder17.setPipeline(pipeline5);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer176, 'uint32', 0, 0);
} catch {}
try {
buffer68.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer201, 108, new DataView(new Uint8Array(4482).map((_, i) => i).buffer), 1517, 24);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise36;
} catch {}
let commandEncoder257 = device0.createCommandEncoder({});
try {
renderPassEncoder5.setVertexBuffer(3, buffer106);
} catch {}
let imageData38 = new ImageData(44, 20);
try {
computePassEncoder3.setPipeline(pipeline44);
} catch {}
try {
commandEncoder186.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 48 */
  offset: 48,
  bytesPerRow: 42496,
  buffer: buffer213,
}, {
  texture: texture170,
  mipLevel: 0,
  origin: {x: 50, y: 30, z: 0},
  aspect: 'all',
}, {width: 50, height: 12, depthOrArrayLayers: 0});
} catch {}
let buffer222 = device0.createBuffer({
  size: 104,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup139, new Uint32Array(595), 39, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup109, []);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup89, new Uint32Array(2809), 449, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer217);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup134);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(234).fill(33), /* required buffer size: 234 */
{offset: 234}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer223 = device0.createBuffer({size: 124, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView290 = texture287.createView({dimension: '2d-array'});
try {
computePassEncoder11.setBindGroup(2, bindGroup75, [0, 0]);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(7, buffer136, 12, 32);
} catch {}
try {
renderBundleEncoder3.setBindGroup(3, bindGroup126, new Uint32Array(797), 48, 0);
} catch {}
try {
commandEncoder84.copyTextureToTexture({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 6, y: 6, z: 0},
  aspect: 'all',
},
{
  texture: texture202,
  mipLevel: 0,
  origin: {x: 612, y: 6, z: 0},
  aspect: 'all',
},
{width: 120, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture61,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(215).fill(190), /* required buffer size: 215 */
{offset: 215, bytesPerRow: 39}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline54 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x11450e1},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment9',
  constants: {},
  targets: [{
  format: 'r16sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex10',
    constants: {},
    buffers: [
      {
        arrayStride: 8,
        attributes: [
          {format: 'sint8x2', offset: 0, shaderLocation: 6},
          {format: 'float32', offset: 0, shaderLocation: 5},
          {format: 'snorm16x4', offset: 0, shaderLocation: 2},
          {format: 'snorm8x2', offset: 0, shaderLocation: 8},
          {format: 'sint32', offset: 0, shaderLocation: 3},
          {format: 'uint32x2', offset: 0, shaderLocation: 9},
        ],
      },
    ],
  },
});
let commandEncoder258 = device0.createCommandEncoder({});
let querySet4 = device0.createQuerySet({type: 'timestamp', count: 1096});
let texture304 = device0.createTexture({
  size: [195, 120, 1],
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder9.setBindGroup(2, bindGroup138, [0, 0]);
} catch {}
try {
computePassEncoder23.setBindGroup(1, bindGroup25, new Uint32Array(1510), 16, 1);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint32', 40, 23);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline31);
} catch {}
try {
commandEncoder248.resolveQuerySet(querySet2, 31, 0, buffer50, 0);
} catch {}
try {
commandEncoder205.insertDebugMarker('\u{1fcba}');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture194,
  mipLevel: 0,
  origin: {x: 0, y: 15, z: 0},
  aspect: 'all',
}, new Uint8Array(282).fill(150), /* required buffer size: 282 */
{offset: 282, bytesPerRow: 26, rowsPerImage: 107}, {width: 0, height: 20, depthOrArrayLayers: 0});
} catch {}
document.body.append(img5);
let textureView291 = texture32.createView({dimension: '1d', arrayLayerCount: 1});
try {
computePassEncoder18.setBindGroup(3, bindGroup119);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline46);
} catch {}
try {
commandEncoder133.copyBufferToBuffer(buffer214, 132, buffer64, 28, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 0, new Uint32Array(3101).map((_, i) => i * 3), 187, 0);
} catch {}
let imageData39 = new ImageData(164, 36);
let commandEncoder259 = device0.createCommandEncoder({});
let textureView292 = texture212.createView({dimension: 'cube', mipLevelCount: 1});
let texture305 = device0.createTexture({
  size: [8, 12, 2],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder3.setIndexBuffer(buffer106, 'uint32', 68, 9);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup52);
} catch {}
try {
device0.queue.writeBuffer(buffer103, 16, new DataView(new ArrayBuffer(69644)), 582, 68);
} catch {}
let pipeline55 = device0.createRenderPipeline({
  label: '\u53b8\u0326\uc956\u0de7\u0792',
  layout: 'auto',
  multisample: {count: 4},
  fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint'}]},
  vertex: {module: shaderModule11, constants: {}, buffers: []},
  primitive: {unclippedDepth: true},
});
try {
globalThis.someLabel = externalTexture28.label;
} catch {}
let bindGroup144 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [
    {binding: 6, resource: textureView175},
    {binding: 290, resource: {buffer: buffer22}},
    {binding: 10, resource: textureView20},
    {binding: 711, resource: sampler33},
    {binding: 556, resource: textureView124},
    {binding: 241, resource: {buffer: buffer34, offset: 0}},
    {binding: 3, resource: sampler25},
    {binding: 348, resource: {buffer: buffer5}},
    {binding: 47, resource: textureView233},
    {binding: 7, resource: {buffer: buffer116}},
  ],
});
try {
renderPassEncoder28.setVertexBuffer(5, buffer156, 0);
} catch {}
let videoFrame40 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'hlg'} });
let textureView293 = texture214.createView({mipLevelCount: 1});
let texture306 = device0.createTexture({
  size: [195, 12, 1],
  mipLevelCount: 5,
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let sampler41 = device0.createSampler({
  label: '\u062a\u0f92\ud455\u{1fce1}\u08d9\u{1f9ab}\u8f1d',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.78,
  maxAnisotropy: 7,
});
try {
computePassEncoder12.setBindGroup(3, bindGroup97);
} catch {}
try {
computePassEncoder1.setBindGroup(0, bindGroup22, new Uint32Array(2517), 47, 1);
} catch {}
try {
renderBundleEncoder30.setBindGroup(0, bindGroup45);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline41);
} catch {}
try {
buffer51.unmap();
} catch {}
try {
commandEncoder190.resolveQuerySet(querySet4, 315, 7, buffer190, 0);
} catch {}
let shaderModule14 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires unrestricted_pointer_parameters;

enable f16;

enable f16;

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

struct T2 {
  f0: array<vec4f>,
}

struct T1 {
  f0: array<vec4h>,
}

var<private> vp15: array<vec4h, 24> = array(vec4h(11110.3, 5864.9, 13455.5, 17012.2), vec4h(2714.6, 5129.0, -64.68, 909.2), vec4h(13694.8, 15867.7, 14773.2, 8468.8), vec4h(11239.1, 4745.5, 14561.3, 7095.6), vec4h(16554.1, 7870.4, 2224.1, -6156.2), vec4h(539.3, 4388.5, 5527.8, -2903.2), vec4h(27715.4, -6159.6, 1951.2, -1896.4), vec4h(8403.9, 10298.0, 6352.0, -6974.1), vec4h(873.9, 22279.5, 1554.6, -4354.3), vec4h(13654.3, 5983.3, 1547.5, 9776.6), vec4h(2733.8, 590.1, 8425.1, 6168.0), vec4h(241.1, 1861.6, -474.9, 7086.7), vec4h(1958.3, 9897.2, 4659.5, 14423.2), vec4h(6403.2, 20983.7, -17369.9, 15420.6), vec4h(5108.4, 4213.7, 13205.7, 4332.0), vec4h(17881.4, 259.8, -2702.7, -1117.7), vec4h(16605.1, -245.5, 9235.9, 1874.1), vec4h(1967.4, 6476.2, 19497.5, 1752.9), vec4h(-29306.0, 3793.2, 6680.9, 7457.0), vec4h(9265.1, 13366.9, 65500.0, -17444.2), vec4h(7803.4, 2001.7, 12006.9, 8672.7), vec4h(697.8, 8364.7, 10078.9, 1493.9), vec4h(8042.8, 13016.5, 2498.5, 4374.3), vec4h(-7732.6, 10953.6, -13021.6, 433.3));

var<private> vp17 = frexp(f16(26140.6));

var<workgroup> vw15: array<array<vec2u, 27>, 1>;

@group(2) @binding(138) var st22: texture_storage_2d<r32uint, read_write>;

@group(1) @binding(10) var<storage, read> buffer228: array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 1>, 1>, 5>, 2>>;

struct FragmentInput30 {
  @location(2) location_2: u32,
}

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

var<workgroup> vw14: vec4u;

@group(0) @binding(3) var tex15: texture_depth_2d;

struct FragmentOutput8 {
  @location(0) location_0: vec4i,
  @location(4) location_4: vec4i,
}

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

struct T0 {
  @size(104) f0: array<array<vec4i, 1>, 1>,
}

@group(1) @binding(3) var<storage, read_write> buffer226: array<array<array<array<VertexInput51, 206>, 1>, 4>>;

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

var<private> vp18: u32 = u32(585670675);

@group(0) @binding(43) var<uniform> buffer225: array<array<vec4u, 1>, 1>;

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

struct FragmentInput31 {
  @location(11) @interpolate(flat, sample) location_11: i32,
  @location(14) location_14: vec4i,
  @location(13) location_13: u32,
  @location(3) location_3: vec4u,
  @location(10) @interpolate(flat) location_10: vec4u,
  @location(4) @interpolate(flat, center) location_4: vec2i,
  @location(0) location_0: vec4i,
  @location(8) location_8: f32,
  @location(6) @interpolate(flat, center) location_6: vec4h,
  @location(1) location_1: f32,
}

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

struct FragmentInput32 {
  @builtin(sample_mask) sample_mask: u32,
  @builtin(sample_index) sample_index: u32,
}

alias vec3b = vec3<bool>;

var<private> vp14 = modf(f16(6002.5));

@group(0) @binding(6) var<storage, read_write> buffer224: T2;

@group(1) @binding(5) var<storage, read> buffer227: array<ComputeInput16>;

var<private> vp16: u32 = u32(342984358);

struct VertexInput51 {
  @location(4) @interpolate(flat, either) location_4: u32,
  @location(11) location_11: f16,
}

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

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

/* used global variables: tex15 */
fn fn1(a0: ptr<private, vec4h>, a1: array<f16, 1>, a2: ptr<function, vec4<bool>>, a3: ptr<function, vec4<bool>>, a4: ptr<function, mat4x4h>, a5: vec2f, a6: ptr<private, u32>, a7: ptr<uniform, vec4u>, a8: texture_storage_3d<rgba8sint, read>, a9: ptr<private, i32>, a10: ptr<uniform, array<array<vec4u, 1>, 1>>, a11: ptr<private, f16>, a12: ptr<uniform, vec4u>, a13: ptr<uniform, vec4u>, a14: vec2h, a15: array<f32, 1>, a16: texture_depth_2d, a17: bool, a18: ptr<private, array<vec4h, 24>>, a19: array<array<array<vec2i, 1>, 1>, 2>, a20: texture_external, a21: vec4h, a22: ptr<uniform, array<array<vec4u, 1>, 1>>, a23: array<vec4f, 1>, a24: vec2u, a25: f16, a26: i32, a27: vec2u, a28: array<array<vec4<bool>, 1>, 1>, a29: ptr<private, i32>, a30: ptr<private, f16>, a31: texture_depth_2d, a32: array<array<array<vec2i, 1>, 6>, 1>, a33: ptr<private, u32>, a34: mat3x4h, a35: ptr<function, array<f16, 15>>, a36: ptr<private, u32>, a37: array<f32, 9>, a38: i32, a39: ptr<private, f16>, a40: vec2u, a41: vec4h, a42: vec4i, a43: ptr<private, f16>, a44: array<vec4f, 1>, a45: ptr<private, vec4h>, a46: ptr<private, i32>, a47: ptr<uniform, array<array<vec4u, 1>, 1>>, a48: ptr<function, array<array<array<f32, 1>, 1>, 44>>, a49: texture_external, a50: array<array<vec2i, 1>, 1>, a51: vec4h, a52: array<array<bool, 1>, 1>, a53: bool, a54: ptr<uniform, vec4u>, a55: array<array<array<array<array<array<vec2h, 2>, 1>, 1>, 1>, 1>, 1>, a56: ptr<uniform, vec4u>, a57: ptr<uniform, vec4u>, a58: array<vec2<bool>, 1>, a59: array<array<vec2f, 14>, 1>, a60: array<array<u32, 1>, 1>, a61: ptr<private, f16>, a62: ptr<private, u32>, a63: ptr<private, i32>, a64: ptr<private, u32>, a65: ptr<function, vec4u>, a66: ptr<private, array<vec4h, 24>>, a67: vec2i, a68: array<vec4i, 1>, a69: ptr<private, array<vec4h, 24>>, a70: texture_storage_3d<rgba8sint, read>, a71: ptr<private, u32>, a72: array<array<vec2i, 1>, 1>, a73: ptr<uniform, vec4u>, a74: array<array<array<array<array<i32, 1>, 4>, 1>, 1>, 9>, a75: ptr<function, array<vec4f, 1>>, a76: texture_depth_2d, a77: vec2h, a78: ptr<private, i32>, a79: texture_storage_3d<rgba8sint, read>, a80: f16, a81: texture_depth_2d, a82: ptr<private, u32>, a83: texture_depth_2d, a84: array<u32, 1>, a85: f32, a86: texture_external, a87: ptr<uniform, array<vec4u, 1>>, a88: ptr<private, f16>) {
  (*a33) |= bitcast<u32>(a55[0][0][unconst_u32(69151054)][unconst_u32(1125559499)][unconst_u32(381548131)][u32((*a18)[23][1])]);
  let ptr96: ptr<uniform, vec4u> = &(*a22)[0][0];
  let vf146: u32 = textureNumLevels(a31);
  var vf147: vec2u = textureDimensions(a31, unconst_i32(117227048));
  let vf148: vec2h = a55[bitcast<u32>(textureLoad(tex15, vec2i(unconst_i32(54304836), unconst_i32(627216151)), unconst_i32(955242402)))][unconst_u32(1527567358)][0][unconst_u32(2347414637)][0][1];
  _ = tex15;
}

/* used global variables: buffer224, buffer226, buffer227, sam7, st22 */
fn fn0() -> array<array<u32, 2>, 1> {
  var out: array<array<u32, 2>, 1>;
  let ptr88: ptr<storage, f16, read_write> = &buffer226[arrayLength(&buffer226)][3][0][unconst_u32(308982695)].location_11;
  while bool((*&buffer226)[arrayLength(&(*&buffer226))][unconst_u32(49056313)][unconst_u32(106085698)][205].location_4) {
  textureStore(st22, vec2i(unconst_i32(459732689), unconst_i32(604299715)), vec4u(vec4u(unconst_u32(556759929), unconst_u32(2836172100), unconst_u32(751113878), unconst_u32(93316804))));
  let ptr89: ptr<storage, VertexInput51, read_write> = &(*&buffer226)[(*&buffer226)[arrayLength(&(*&buffer226))][3][0][205].location_4][3][unconst_u32(1291629345)][unconst_u32(2099615403)];
  _ = st22;
  _ = buffer226;
}
  for (var jj57=0u; jj57<3; jj57++) { out[jj57][1] >>= u32(buffer226[arrayLength(&buffer226)][3][0][205].location_11); }
  let ptr90: ptr<storage, array<array<VertexInput51, 206>, 1>, read_write> = &buffer226[unconst_u32(118519933)][3];
  vp16 |= out[0][1];
  for (var jj90=0u; jj90<6; jj90++) { for (var jj5=0u; jj5<3; jj5++) { buffer226[unconst_u32(70639194)][jj90][jj5][unconst_u32(3118629580)].location_4 = u32((*ptr90)[0][unconst_u32(1566681132)].location_11); } }
  let ptr91: ptr<storage, array<vec4f>, read_write> = &(*&buffer224).f0;
  let ptr92: ptr<storage, VertexInput51, read_write> = &(*&buffer226)[arrayLength(&(*&buffer226))][unconst_u32(476936104)][unconst_u32(51115597)][unconst_u32(1017900059)];
  {
  _ = sam7;
  vp15[unconst_u32(526922545)] = vec4h(buffer227[arrayLength(&buffer227)].num_workgroups.brgg);
  let ptr93: ptr<storage, vec3u, read> = &(*&buffer227)[unconst_u32(709737328)].num_workgroups;
  vp18 = (*&buffer226)[arrayLength(&(*&buffer226))][3][0][205].location_4;
  let ptr94: ptr<storage, array<array<array<array<VertexInput51, 206>, 1>, 4>>, read_write> = &buffer226;
  _ = sam7;
  _ = buffer226;
  _ = buffer227;
}
  let ptr95: ptr<storage, f16, read_write> = &buffer226[buffer226[unconst_u32(815797275)][unconst_u32(305030721)][0][205].location_4][unconst_u32(787597762)][0][unconst_u32(210007444)].location_11;
  return out;
  _ = buffer226;
  _ = buffer227;
  _ = sam7;
  _ = buffer224;
  _ = st22;
}

struct VertexOutput11 {
  @location(0) @interpolate(flat, first) location_0: i32,
  @location(6) @interpolate(flat, either) location_6: i32,
  @location(2) @interpolate(flat, first) location_2: vec4u,
  @location(8) location_8: f16,
  @location(15) @interpolate(linear, centroid) location_15: vec2h,
  @location(14) location_14: f16,
  @location(7) @interpolate(flat, center) location_7: i32,
  @location(10) @interpolate(perspective, centroid) location_10: f16,
  @builtin(position) position: vec4f,
  @location(5) @interpolate(flat, either) location_5: u32,
}

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

/* used global variables: buffer225 */
@vertex
fn vertex16(@location(8) location_8: i32, @location(7) @interpolate(linear, first) location_7: vec4f, @location(14) location_14: vec4u, a3: VertexInput51, @location(1) location_1: i32, @location(13) location_13: vec2f, @location(15) location_15: vec4f, @location(5) location_5: vec4f) -> VertexOutput11 {
  var out: VertexOutput11;
  out.position = vec4f((*&buffer225)[0][0]);
  out.location_6 ^= i32(location_7[unconst_u32(744215807)]);
  loop {
  let ptr97: ptr<private, f16> = &vp17.fract;
  out.location_7 -= i32(out.location_10);
  out.location_10 = vec4h(out.location_2.bgrr.ggaa.yyxw).w;
  break;
}
  out.location_15 = bitcast<vec2h>(out.position[unconst_u32(389805323)]);
  return out;
  _ = buffer225;
}

/* used global variables: buffer224, buffer226, buffer227, et17, sam7, st22 */
@fragment
fn fragment13(@location(9) @interpolate(flat) location_9: vec4i, @location(5) location_5: f16, a2: FragmentInput30, a3: FragmentInput31, a4: FragmentInput32, @builtin(front_facing) front_facing: bool, @builtin(position) position: vec4f) -> FragmentOutput8 {
  var out: FragmentOutput8;
  vp16 = u32(buffer226[unconst_u32(105259827)][unconst_u32(553888791)][0][205].location_11);
  _ = fn0();
  _ = fn0();
  while bool(pack4xU8Clamp(a3.location_3)) {
  let ptr98: ptr<storage, u32, read_write> = &(*&buffer226)[unconst_u32(1529970243)][3][0][unconst_u32(934382657)].location_4;
  _ = buffer226;
}
  for (var ii95=0u; ii95<0x1000; ii95+=0x11) { buffer226[ii95][unconst_u32(165485834)][unconst_u32(325608794)][unconst_u32(36297055)] = VertexInput51(u32(buffer226[unconst_u32(314606921)][3][0][205].location_11), buffer226[unconst_u32(314606921)][3][0][205].location_11); }
  switch i32((*&buffer226)[unconst_u32(1088022223)][3][0][u32((*&buffer224).f0[arrayLength(&(*&buffer224).f0)][unconst_u32(444830667)])].location_4) { 
  default {
  fn0();
  while bool(vp15[23][0]) {
  vp16 = textureDimensions(et17)[1];
  {
  discard;
  break;
}
  let ptr99: ptr<storage, VertexInput51, read_write> = &buffer226[unconst_u32(806324667)][unconst_u32(494345405)][0][unconst_u32(493366067)];
  var vf149: f32 = a3.location_8;
  _ = et17;
  _ = buffer226;
}
  buffer224 = buffer224;
  let ptr100: ptr<storage, f16, read_write> = &buffer226[u32((*&buffer226)[arrayLength(&(*&buffer226))][unconst_u32(1056256282)][0][205].location_11)][unconst_u32(208338565)][unconst_u32(123324928)][205].location_11;
  let ptr101: ptr<function, vec4i> = &out.location_0;
  return out;
  _ = buffer226;
  _ = buffer227;
  _ = et17;
  _ = st22;
  _ = sam7;
  _ = buffer224;
}
  }
  fn0();
  let ptr102: ptr<storage, f16, read_write> = &buffer226[u32(buffer226[unconst_u32(115120913)][unconst_u32(390566168)][0][unconst_u32(586965775)].location_11)][unconst_u32(140938035)][0][205].location_11;
  vp15[unconst_u32(584859340)] = vec4h(buffer226[arrayLength(&buffer226)][3][0][unconst_u32(311153750)].location_11);
  discard;
  return out;
  _ = buffer224;
  _ = st22;
  _ = buffer227;
  _ = buffer226;
  _ = et17;
  _ = sam7;
}

/* used global variables: buffer224, buffer226, buffer228 */
@compute @workgroup_size(1, 1, 1)
fn compute13(a0: ComputeInput16, @builtin(workgroup_id) workgroup_id: vec3u, a2: ComputeInput17) {
  let ptr103: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 1>, read> = &(*&buffer228)[unconst_u32(471229779)][1][4][unconst_u32(84102593)];
  vp15[unconst_u32(114219066)] -= vec4h((*&buffer228)[arrayLength(&(*&buffer228))][1][4][0][0][unconst_u32(640083672)][unconst_u32(1745620298)][0][0]);
  let ptr104: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &(*&buffer228)[arrayLength(&(*&buffer228))][u32(buffer228[arrayLength(&buffer228)][1][unconst_u32(120749647)][unconst_u32(2043054)][0][2][0][0][0])][unconst_u32(120773386)][unconst_u32(276637954)][0][2];
  vp18 >>= u32((*&buffer228)[arrayLength(&(*&buffer228))][unconst_u32(188534844)][4][0][0][2][unconst_u32(479685927)][unconst_u32(900034271)][unconst_u32(1011933467)]);
  vp14.whole = f16(buffer224.f0[arrayLength(&buffer224.f0)][unconst_u32(312821784)]);
  let ptr105: ptr<storage, f16, read> = &buffer228[unconst_u32(659768168)][1][unconst_u32(651813982)][0][0][unconst_u32(133905741)][0][u32((*&buffer228)[arrayLength(&(*&buffer228))][unconst_u32(1401646194)][4][unconst_u32(846165652)][0][unconst_u32(98513160)][unconst_u32(352667124)][0][0])][unconst_u32(13615421)];
  let ptr106: ptr<storage, array<f16, 1>, read> = &(*ptr103)[unconst_u32(80969995)][unconst_u32(387677913)][unconst_u32(732010015)][unconst_u32(358353197)];
  vw15[0][unconst_u32(1072859130)] = vec2u(u32(buffer228[u32((*&buffer228)[unconst_u32(338446310)][unconst_u32(1928796179)][unconst_u32(78324188)][unconst_u32(987792518)][0][unconst_u32(2130222589)][buffer226[unconst_u32(54969414)][3][0][205].location_4][unconst_u32(480912853)][0])][unconst_u32(1289504550)][unconst_u32(1096530562)][unconst_u32(320835443)][u32((*&buffer228)[arrayLength(&(*&buffer228))][unconst_u32(149150570)][4][unconst_u32(1255878758)][u32((*ptr103)[0][2][unconst_u32(1546452610)][0][0])][u32((*&buffer228)[unconst_u32(981619654)][unconst_u32(1770794891)][unconst_u32(889724456)][0][(*&buffer226)[arrayLength(&(*&buffer226))][unconst_u32(671842661)][unconst_u32(50295120)][unconst_u32(686215956)].location_4][u32(buffer228[arrayLength(&buffer228)][1][4][0][unconst_u32(1155235854)][2][0][0][0])][0][u32(buffer228[arrayLength(&buffer228)][unconst_u32(133748179)][unconst_u32(244697320)][0][0][2][unconst_u32(427996051)][0][0])][0])][0][unconst_u32(374451571)][0])][2][unconst_u32(1762659725)][0][0]));
  let ptr107: ptr<storage, array<f16, 1>, read> = &(*&buffer228)[unconst_u32(220075753)][unconst_u32(9194753)][unconst_u32(4097970172)][unconst_u32(382721671)][0][2][0][0];
  vw14 = unpack4xU8(u32((*&buffer228)[arrayLength(&(*&buffer228))][unconst_u32(1391619915)][4][0][unconst_u32(2199505061)][unconst_u32(2130902607)][unconst_u32(195836693)][unconst_u32(289579462)][0]));
  _ = buffer224;
  _ = buffer228;
  _ = buffer226;
}`,
});
let autogeneratedBindGroupLayout36 = pipeline17.getBindGroupLayout(0);
let commandEncoder260 = device0.createCommandEncoder({});
let texture307 = device0.createTexture({
  size: [2, 2, 14],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg8sint'],
});
try {
renderBundleEncoder9.setBindGroup(3, bindGroup82, new Uint32Array(466), 72, 0);
} catch {}
let bindGroup145 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []});
let texture308 = device0.createTexture({
  size: {width: 195, height: 120, depthOrArrayLayers: 345},
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder8.setBindGroup(2, bindGroup55, [256, 0]);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder10.setBindGroup(2, bindGroup132);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 120, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 8, y: 4 },
  flipY: false,
}, {
  texture: texture297,
  mipLevel: 0,
  origin: {x: 24, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 11, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup57, []);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(3, buffer179, 60, 3);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup3, new Uint32Array(808), 8, 1);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(0, buffer143, 0, 9);
} catch {}
let pipeline56 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule6, constants: {5_373: 1}}});
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(40); };
} catch {}
let buffer230 = device0.createBuffer({size: 44, usage: GPUBufferUsage.QUERY_RESOLVE});
try {
renderBundleEncoder12.setPipeline(pipeline38);
} catch {}
try {
commandEncoder151.copyTextureToBuffer({
  texture: texture161,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 944 */
  offset: 944,
  rowsPerImage: 1160,
  buffer: buffer187,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32uint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 92,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 197,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {binding: 234, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 992,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup146 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 3, resource: textureView0},
    {binding: 43, resource: {buffer: buffer186, size: 115}},
    {binding: 6, resource: {buffer: buffer204, offset: 0, size: 16}},
    {binding: 58, resource: {buffer: buffer116}},
  ],
});
let texture309 = device0.createTexture({
  size: {width: 780, height: 48, depthOrArrayLayers: 54},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView294 = texture97.createView({dimension: '2d-array'});
try {
computePassEncoder9.setBindGroup(2, bindGroup45);
} catch {}
try {
computePassEncoder12.setBindGroup(2, bindGroup32, new Uint32Array(7256), 1_027, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup36, new Uint32Array(2791), 16, 1);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(1, buffer68, 32);
} catch {}
let commandEncoder261 = device0.createCommandEncoder({});
let textureView295 = texture66.createView({format: 'r16sint'});
let externalTexture55 = device0.importExternalTexture({source: videoFrame27});
try {
computePassEncoder11.setBindGroup(0, bindGroup101, new Uint32Array(366), 154, 0);
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup82, new Uint32Array(679), 25, 0);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer65, 'uint16', 12, 0);
} catch {}
try {
texture29.destroy();
} catch {}
try {
buffer191.unmap();
} catch {}
try {
commandEncoder236.popDebugGroup();
} catch {}
try {
gpuCanvasContext14.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 97, height: 60, depthOrArrayLayers: 1}
*/
{
  source: imageData34,
  origin: { x: 3, y: 3 },
  flipY: true,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 18, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise37 = device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x5dc12f4f},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment9',
  constants: {},
  targets: [{
  format: 'r16sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex2',
    constants: {},
    buffers: [
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [{format: 'uint32x3', offset: 0, shaderLocation: 14}, {format: 'uint32', offset: 0, shaderLocation: 2}],
      },
      {
        arrayStride: 40,
        stepMode: 'vertex',
        attributes: [{format: 'float32x2', offset: 0, shaderLocation: 6}],
      },
    ],
  },
  primitive: {frontFace: 'cw'},
});
let bindGroup147 = device0.createBindGroup({
  label: '\uf723\u7c19\ud6a0\ua3ee\uf353\u05c3\u3d50\u29bf\u0fdd\u{1f9a1}',
  layout: veryExplicitBindGroupLayout18,
  entries: [
    {binding: 7, resource: externalTexture2},
    {binding: 3, resource: {buffer: buffer22}},
    {binding: 14, resource: {buffer: buffer116}},
    {binding: 11, resource: {buffer: buffer110, offset: 0}},
    {binding: 33, resource: textureView58},
    {binding: 212, resource: textureView29},
    {binding: 1, resource: textureView201},
    {binding: 39, resource: textureView0},
  ],
});
let texture310 = device0.createTexture({size: {width: 390}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST});
try {
renderBundleEncoder23.setVertexBuffer(0, buffer128, 0);
} catch {}
try {
commandEncoder74.copyTextureToTexture({
  texture: texture208,
  mipLevel: 0,
  origin: {x: 310, y: 13, z: 0},
  aspect: 'all',
},
{
  texture: texture208,
  mipLevel: 0,
  origin: {x: 72, y: 17, z: 0},
  aspect: 'all',
},
{width: 354, height: 9, depthOrArrayLayers: 0});
} catch {}
let commandEncoder262 = device0.createCommandEncoder();
let texture311 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 14},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
renderPassEncoder5.setIndexBuffer(buffer63, 'uint32', 312, 31);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer172, 'uint32', 0, 5);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline48);
} catch {}
try {
device0.queue.writeBuffer(buffer91, 2_608, new Uint32Array(3470).map((_, i) => i * 4), 102, 504);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup148 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout12,
  entries: [{binding: 6, resource: {buffer: buffer136}}, {binding: 58, resource: {buffer: buffer37}}],
});
let texture312 = device0.createTexture({
  size: [390, 24, 1],
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture313 = device0.createTexture({size: [2, 2, 23], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderBundleEncoder9.setVertexBuffer(1, buffer172, 0, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer189, 4, new Float64Array(22343).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/22339)), 1141, 0);
} catch {}
let pipeline57 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5}});
let bindGroup149 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout17,
  entries: [
    {binding: 48, resource: textureView17},
    {binding: 0, resource: {buffer: buffer107}},
    {binding: 32, resource: externalTexture52},
    {binding: 1, resource: sampler36},
    {binding: 365, resource: textureView170},
    {binding: 5, resource: sampler23},
    {binding: 184, resource: {buffer: buffer32}},
  ],
});
let buffer231 = device0.createBuffer({size: 92, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder263 = device0.createCommandEncoder({});
let textureView296 = texture312.createView({format: 'rgba8snorm', mipLevelCount: 1});
try {
renderPassEncoder16.setBindGroup(2, bindGroup82, new Uint32Array(964), 133, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer199, 'uint16', 14, 23);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(0, buffer137, 0, 2);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder222.resolveQuerySet(querySet3, 23, 0, buffer109, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer179, 24, new Uint16Array(38531).map((_, i) => i + 7), 3333, 4);
} catch {}
let bindGroup150 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout26,
  entries: [
    {binding: 43, resource: {buffer: buffer82}},
    {binding: 6, resource: {buffer: buffer103}},
    {binding: 58, resource: {buffer: buffer37}},
  ],
});
let texture314 = device0.createTexture({
  size: [390, 240, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView297 = texture114.createView({dimension: '2d-array', mipLevelCount: 1});
let externalTexture56 = device0.importExternalTexture({source: videoFrame36});
try {
renderPassEncoder30.setVertexBuffer(3, buffer118, 0, 1_353);
} catch {}
try {
renderBundleEncoder20.insertDebugMarker('\u6a41');
} catch {}
let commandEncoder264 = device0.createCommandEncoder({});
try {
renderPassEncoder16.setIndexBuffer(buffer131, 'uint32', 64, 72);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer65, 'uint32', 0, 13);
} catch {}
try {
commandEncoder250.insertDebugMarker('\u7343');
} catch {}
try {
computePassEncoder17.insertDebugMarker('\u04a4');
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer136, 32, new DataView(new ArrayBuffer(32388)), 975, 0);
} catch {}
let bindGroup151 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 84, resource: {buffer: buffer21, size: 1292}},
    {binding: 201, resource: {buffer: buffer37}},
    {binding: 219, resource: textureView17},
    {binding: 45, resource: externalTexture33},
    {binding: 284, resource: textureView262},
    {binding: 211, resource: {buffer: buffer179}},
    {binding: 386, resource: textureView7},
    {binding: 117, resource: {buffer: buffer107}},
    {binding: 40, resource: externalTexture9},
    {binding: 264, resource: textureView36},
    {binding: 0, resource: {buffer: buffer36, size: 49}},
    {binding: 255, resource: {buffer: buffer21, size: 912}},
    {binding: 210, resource: {buffer: buffer21, offset: 0, size: 1768}},
    {binding: 33, resource: textureView250},
    {binding: 2, resource: {buffer: buffer120}},
    {binding: 9, resource: {buffer: buffer34}},
    {binding: 269, resource: textureView28},
    {binding: 11, resource: {buffer: buffer21, size: 3108}},
    {binding: 6, resource: textureView213},
    {binding: 5, resource: textureView260},
    {binding: 7, resource: textureView4},
    {binding: 3, resource: {buffer: buffer21, size: 448}},
    {binding: 148, resource: textureView36},
  ],
});
let texture315 = device0.createTexture({
  size: {width: 780},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderBundleEncoder22.setBindGroup(2, bindGroup19, [0]);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup72, new Uint32Array(1728), 78, 0);
} catch {}
let bindGroup152 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 43, resource: {buffer: buffer174}},
    {binding: 3, resource: textureView0},
    {binding: 58, resource: {buffer: buffer116}},
    {binding: 6, resource: {buffer: buffer154}},
  ],
});
let textureView298 = texture300.createView({mipLevelCount: 1});
try {
renderBundleEncoder10.setIndexBuffer(buffer112, 'uint32', 52, 58);
} catch {}
let commandEncoder265 = device0.createCommandEncoder();
let textureView299 = texture53.createView({});
try {
renderPassEncoder1.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup34, [0]);
} catch {}
try {
gpuCanvasContext17.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer130, 0, new Float32Array(12157).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.1379)), 2270, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 195, height: 120, depthOrArrayLayers: 1}
*/
{
  source: imageData39,
  origin: { x: 0, y: 9 },
  flipY: false,
}, {
  texture: texture297,
  mipLevel: 0,
  origin: {x: 3, y: 20, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 11, height: 10, depthOrArrayLayers: 0});
} catch {}
let imageData40 = new ImageData(4, 12);
let bindGroup153 = device0.createBindGroup({layout: autogeneratedBindGroupLayout20, entries: [{binding: 1, resource: externalTexture38}]});
let commandEncoder266 = device0.createCommandEncoder({});
try {
buffer139.unmap();
} catch {}
let commandEncoder267 = device0.createCommandEncoder();
let texture316 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 14},
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
commandEncoder264.copyTextureToBuffer({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 304 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1536 */
  offset: 1536,
  rowsPerImage: 2998,
  buffer: buffer56,
}, {width: 114, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup154 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 15, resource: {buffer: buffer70}},
    {binding: 152, resource: textureView87},
    {binding: 141, resource: {buffer: buffer157, size: 48}},
    {binding: 166, resource: textureView88},
    {binding: 148, resource: {buffer: buffer43}},
    {binding: 125, resource: textureView270},
    {binding: 81, resource: externalTexture55},
    {binding: 2, resource: textureView100},
    {binding: 86, resource: {buffer: buffer116}},
    {binding: 220, resource: {buffer: buffer141}},
    {binding: 11, resource: textureView26},
    {binding: 3, resource: textureView134},
    {binding: 106, resource: {buffer: buffer107}},
    {binding: 4, resource: {buffer: buffer153, offset: 0}},
    {binding: 1, resource: externalTexture51},
    {binding: 251, resource: {buffer: buffer81, size: 28}},
    {binding: 6, resource: textureView3},
    {binding: 5, resource: {buffer: buffer209}},
    {binding: 12, resource: textureView251},
    {binding: 0, resource: {buffer: buffer21, offset: 256, size: 1288}},
  ],
});
let textureView300 = texture312.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder14.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup16, new Uint32Array(2572), 133, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let textureView301 = texture290.createView({});
try {
computePassEncoder3.setBindGroup(1, bindGroup23);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup153, new Uint32Array(717), 68, 0);
} catch {}
let imageData41 = new ImageData(36, 16);
try {
renderPassEncoder26.executeBundles([renderBundle4, renderBundle4]);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(3, buffer160);
} catch {}
let bindGroup155 = device0.createBindGroup({layout: autogeneratedBindGroupLayout19, entries: []});
let texture317 = device0.createTexture({
  size: {width: 8, height: 12, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder3.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(2, buffer160, 0);
} catch {}
try {
commandEncoder247.popDebugGroup();
} catch {}
let pipeline58 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x425c5ca3},
  fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint'}]},
  vertex: {
    module: shaderModule7,
    constants: {override18: 1},
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint8x4', offset: 0, shaderLocation: 7},
          {format: 'unorm8x2', offset: 0, shaderLocation: 8},
          {format: 'snorm16x2', offset: 0, shaderLocation: 12},
          {format: 'uint8x2', offset: 0, shaderLocation: 9},
          {format: 'unorm8x4', offset: 0, shaderLocation: 14},
          {format: 'sint8x4', offset: 0, shaderLocation: 6},
          {format: 'unorm8x4', offset: 0, shaderLocation: 0},
          {format: 'uint8x2', offset: 0, shaderLocation: 3},
          {format: 'snorm16x2', offset: 0, shaderLocation: 5},
          {format: 'unorm8x2', offset: 0, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4},
          {format: 'float32', offset: 0, shaderLocation: 13},
          {format: 'uint32', offset: 0, shaderLocation: 11},
          {format: 'sint8x2', offset: 0, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'front'},
});
try {
computePassEncoder5.setBindGroup(0, bindGroup134);
} catch {}
try {
computePassEncoder14.setBindGroup(0, bindGroup27, new Uint32Array(885), 146, 1);
} catch {}
try {
renderBundleEncoder19.setBindGroup(3, bindGroup98, [0]);
} catch {}
try {
renderBundleEncoder28.insertDebugMarker('\u0d42');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 780, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 0,
  origin: {x: 65, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer232 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let externalTexture57 = device0.importExternalTexture({source: videoFrame5});
try {
renderPassEncoder14.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle4, renderBundle4, renderBundle4, renderBundle4]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer93, 'uint16', 4, 15);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup131);
} catch {}
try {
commandEncoder50.copyBufferToBuffer(buffer103, 44, buffer120, 0, 12);
} catch {}
try {
gpuCanvasContext15.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer64, 124, new Float64Array(2896).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/2891)), 542, 0);
} catch {}
offscreenCanvas7.width = 38;
try {
renderBundleEncoder2.setBindGroup(0, bindGroup138, [0, 0]);
} catch {}
try {
commandEncoder131.copyTextureToTexture({
  texture: texture216,
  mipLevel: 0,
  origin: {x: 132, y: 8, z: 0},
  aspect: 'all',
},
{
  texture: texture56,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline59 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule2, constants: {}, targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALPHA}]},
  vertex: {module: shaderModule12, buffers: []},
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let textureView302 = texture309.createView({mipLevelCount: 1});
try {
computePassEncoder29.setPipeline(pipeline50);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer172, 'uint32', 4, 5);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer120, 'uint16', 50, 7);
} catch {}
try {
commandEncoder132.copyTextureToTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 5},
  aspect: 'all',
},
{
  texture: texture131,
  mipLevel: 0,
  origin: {x: 53, y: 0, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer138, 40, new Float32Array(7848).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.07350)), 2257, 0);
} catch {}
try {
computePassEncoder29.setBindGroup(0, bindGroup67, new Uint32Array(255), 10, 0);
} catch {}
try {
commandEncoder98.resolveQuerySet(querySet3, 107, 0, buffer230, 0);
} catch {}
let imageData42 = new ImageData(36, 72);
let bindGroup156 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 0, resource: {buffer: buffer90, size: 66}},
    {binding: 386, resource: textureView17},
    {binding: 84, resource: {buffer: buffer116}},
    {binding: 201, resource: {buffer: buffer21, size: 1288}},
    {binding: 210, resource: {buffer: buffer107}},
    {binding: 284, resource: textureView59},
    {binding: 3, resource: {buffer: buffer136}},
    {binding: 211, resource: {buffer: buffer51}},
    {binding: 5, resource: textureView282},
    {binding: 40, resource: externalTexture8},
    {binding: 6, resource: textureView220},
    {binding: 219, resource: textureView3},
    {binding: 148, resource: textureView243},
    {binding: 255, resource: {buffer: buffer37}},
    {binding: 11, resource: {buffer: buffer21, size: 3156}},
    {binding: 9, resource: {buffer: buffer205}},
    {binding: 45, resource: externalTexture14},
    {binding: 117, resource: {buffer: buffer21, size: 1524}},
    {binding: 264, resource: textureView54},
    {binding: 269, resource: textureView160},
    {binding: 2, resource: {buffer: buffer158}},
    {binding: 33, resource: textureView239},
    {binding: 7, resource: textureView278},
  ],
});
let buffer233 = device0.createBuffer({size: 92, usage: GPUBufferUsage.COPY_DST});
let texture318 = device0.createTexture({
  size: [97, 60, 35],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView303 = texture304.createView({dimension: '2d-array'});
try {
renderBundleEncoder28.setIndexBuffer(buffer100, 'uint16', 80, 23);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline60 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1'}});
document.body.prepend(img1);
let bindGroup157 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 269, resource: textureView284},
    {binding: 2, resource: {buffer: buffer80}},
    {binding: 45, resource: externalTexture14},
    {binding: 9, resource: {buffer: buffer20}},
    {binding: 284, resource: textureView285},
    {binding: 219, resource: textureView0},
    {binding: 264, resource: textureView36},
    {binding: 0, resource: {buffer: buffer54, size: 48}},
    {binding: 6, resource: textureView32},
    {binding: 3, resource: {buffer: buffer190}},
    {binding: 7, resource: textureView278},
    {binding: 386, resource: textureView17},
    {binding: 255, resource: {buffer: buffer116, offset: 0}},
    {binding: 84, resource: {buffer: buffer21, size: 1660}},
    {binding: 11, resource: {buffer: buffer21, size: 3124}},
    {binding: 5, resource: textureView17},
    {binding: 210, resource: {buffer: buffer21, size: 1532}},
    {binding: 40, resource: externalTexture3},
    {binding: 211, resource: {buffer: buffer37}},
    {binding: 33, resource: textureView241},
    {binding: 201, resource: {buffer: buffer107, offset: 256}},
    {binding: 148, resource: textureView54},
    {binding: 117, resource: {buffer: buffer21, size: 1556}},
  ],
});
let textureView304 = texture45.createView({dimension: 'cube', baseArrayLayer: 0});
try {
renderPassEncoder21.setBindGroup(1, bindGroup12, new Uint32Array(1101), 38, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(5, buffer185, 0, 219);
} catch {}
let buffer234 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let textureView305 = texture300.createView({mipLevelCount: 1});
try {
commandEncoder205.copyTextureToTexture({
  texture: texture216,
  mipLevel: 1,
  origin: {x: 170, y: 3, z: 0},
  aspect: 'all',
},
{
  texture: texture302,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer141, 20, new Float16Array(7854).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.583)), 1053, 4);
} catch {}
let bindGroup158 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout20,
  entries: [{binding: 69, resource: textureView174}, {binding: 14, resource: textureView223}],
});
try {
renderPassEncoder29.setIndexBuffer(buffer38, 'uint16', 4, 7);
} catch {}
try {
commandEncoder61.resolveQuerySet(querySet3, 10, 24, buffer96, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer132, 12, new Float32Array(7905).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9544)), 2836, 16);
} catch {}
let autogeneratedBindGroupLayout37 = pipeline49.getBindGroupLayout(0);
let texture319 = device0.createTexture({
  size: {width: 780, height: 480, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView306 = texture290.createView({arrayLayerCount: 1});
try {
computePassEncoder30.setBindGroup(3, bindGroup83, new Uint32Array(3129), 146, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(2, buffer193, 0, 11);
} catch {}
try {
  await shaderModule9.getCompilationInfo();
} catch {}
try {
commandEncoder81.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 726 */
  offset: 726,
  bytesPerRow: 13056,
  buffer: buffer11,
}, {
  texture: texture129,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup159 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout29,
  entries: [{binding: 58, resource: {buffer: buffer116, offset: 0}}],
});
let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true});
try {
computePassEncoder30.setBindGroup(2, bindGroup144, new Uint32Array(2319), 297, 1);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup38, new Uint32Array(1558), 188, 0);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer53, 'uint16', 0, 0);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline40);
} catch {}
try {
commandEncoder265.copyTextureToBuffer({
  texture: texture203,
  mipLevel: 0,
  origin: {x: 10, y: 50, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 192 */
  offset: 192,
  bytesPerRow: 25600,
  buffer: buffer200,
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame41 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'film', transfer: 'smpte240m'} });
let bindGroup160 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout25,
  entries: [
    {binding: 43, resource: textureView118},
    {binding: 234, resource: externalTexture7},
    {binding: 3, resource: textureView65},
    {binding: 1, resource: textureView169},
    {binding: 92, resource: sampler0},
    {binding: 197, resource: textureView0},
    {binding: 75, resource: textureView304},
    {binding: 992, resource: {buffer: buffer56}},
  ],
});
try {
computePassEncoder19.setBindGroup(0, bindGroup134, new Uint32Array(903), 50, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer112, 'uint32', 24, 9);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline39);
} catch {}
let texture320 = gpuCanvasContext14.getCurrentTexture();
try {
computePassEncoder20.setBindGroup(0, bindGroup148, []);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(2, buffer156);
} catch {}
try {
computePassEncoder14.pushDebugGroup('\u09ce');
} catch {}
try {
computePassEncoder14.popDebugGroup();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
await gc();
let textureView307 = texture103.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder27.setBindGroup(2, bindGroup132, new Uint32Array(637), 86, 0);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(193);
} catch {}
let offscreenCanvas9 = new OffscreenCanvas(565, 111);
let videoFrame42 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'iec6196624'} });
let textureView308 = texture190.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer100, 'uint32', 12, 141);
} catch {}
try {
computePassEncoder15.insertDebugMarker('\u0b55');
} catch {}
try {
computePassEncoder19.setBindGroup(1, bindGroup25, [0]);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(5, buffer118, 0, 1_475);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup152, [0]);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(7, buffer190, 0, 48);
} catch {}
try {
commandEncoder124.copyTextureToBuffer({
  texture: texture164,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 198 */
  offset: 198,
  buffer: buffer221,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder152.clearBuffer(buffer201);
} catch {}
let videoFrame43 = videoFrame9.clone();
try {
computePassEncoder17.setBindGroup(3, bindGroup62);
} catch {}
try {
renderBundleEncoder30.setBindGroup(3, bindGroup131);
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(19); };
} catch {}
document.body.append(canvas6);
let bindGroup161 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 557, resource: externalTexture41},
    {binding: 0, resource: {buffer: buffer205, size: 20}},
    {binding: 176, resource: {buffer: buffer107}},
  ],
});
let buffer235 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
try {
computePassEncoder0.setBindGroup(2, bindGroup23, new Uint32Array(2878), 279, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer188, 'uint16', 68, 90);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(1, buffer185, 0, 1_921);
} catch {}
try {
buffer200.unmap();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(2); };
} catch {}
let texture321 = device0.createTexture({
  size: {width: 97, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView309 = texture25.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder16.setBindGroup(3, bindGroup94, new Uint32Array(5521), 1_397, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 97, height: 60, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 19, y: 88 },
  flipY: false,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 20, y: 28, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 4, depthOrArrayLayers: 0});
} catch {}
await gc();
let buffer236 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_DST});
let computePassEncoder31 = commandEncoder102.beginComputePass();
try {
computePassEncoder14.setBindGroup(0, bindGroup134);
} catch {}
try {
computePassEncoder31.setPipeline(pipeline52);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup84, new Uint32Array(1145), 50, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer188, 'uint32', 108, 89);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder18.setBindGroup(1, bindGroup120, [0]);
} catch {}
try {
renderBundleEncoder16.insertDebugMarker('\u{1f934}');
} catch {}
try {
gpuCanvasContext14.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer233, 0, new Float32Array(24944).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.2011)), 7295, 4);
} catch {}
document.body.prepend(img5);
let texture322 = device0.createTexture({size: [8, 12, 28], format: 'r16sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
try {
computePassEncoder7.setBindGroup(1, bindGroup45, new Uint32Array(680), 383, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer217, 0, 9);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup68, new Uint32Array(2960), 264, 0);
} catch {}
let arrayBuffer13 = buffer173.getMappedRange(0, 4);
let promise38 = device0.queue.onSubmittedWorkDone();
let buffer237 = device0.createBuffer({size: 122, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
try {
renderBundleEncoder21.setIndexBuffer(buffer118, 'uint32', 1_044, 240);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(4, buffer186, 36);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer223.unmap();
} catch {}
try {
device0.queue.submit([]);
} catch {}
let texture323 = device0.createTexture({
  size: [8, 12, 2],
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder31.setBindGroup(2, bindGroup86);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer172, 4);
} catch {}
try {
renderBundleEncoder28.pushDebugGroup('\u4226');
} catch {}
try {
device0.queue.writeBuffer(buffer138, 4, new Float32Array(21640).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.6422)), 7130, 12);
} catch {}
document.body.append(img6);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
computePassEncoder19.setBindGroup(1, bindGroup104);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer108, 'uint16', 0, 0);
} catch {}
try {
  await promise38;
} catch {}
let texture324 = device0.createTexture({
  size: {width: 780},
  dimension: '1d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView310 = texture227.createView({baseArrayLayer: 0});
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup22, new Uint32Array(353), 12, 1);
} catch {}
try {
renderPassEncoder28.beginOcclusionQuery(668);
} catch {}
try {
renderPassEncoder20.setBlendConstant({ r: 100.9, g: -830.1, b: -521.3, a: -748.3, });
} catch {}
try {
renderPassEncoder31.setPipeline(pipeline41);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer137, 'uint32', 4, 4);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(179);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(2, buffer193, 24, 41);
} catch {}
try {
buffer158.unmap();
} catch {}
try {
renderBundleEncoder28.popDebugGroup();
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer234, 'uint16', 0, 26);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline41);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture66,
  mipLevel: 0,
  origin: {x: 136, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(213).fill(151), /* required buffer size: 213 */
{offset: 213, bytesPerRow: 279, rowsPerImage: 50}, {width: 126, height: 8, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext18 = offscreenCanvas9.getContext('webgpu');
try {
computePassEncoder7.setBindGroup(0, bindGroup109);
} catch {}
try {
renderPassEncoder28.endOcclusionQuery();
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer199, 'uint32', 4, 19);
} catch {}
let arrayBuffer14 = buffer173.getMappedRange(8, 4);
try {
commandEncoder208.copyBufferToTexture({
  /* bytesInLastRow: 240 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 112 */
  offset: 112,
  bytesPerRow: 5376,
  buffer: buffer90,
}, {
  texture: texture180,
  mipLevel: 0,
  origin: {x: 18, y: 20, z: 0},
  aspect: 'all',
}, {width: 90, height: 100, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas10 = new OffscreenCanvas(43, 540);
let buffer238 = device0.createBuffer({
  size: 72,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture325 = device0.createTexture({
  size: {width: 97},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView311 = texture294.createView({dimension: '2d-array'});
let sampler42 = device0.createSampler({lodMaxClamp: 92.82, compare: 'less', maxAnisotropy: 1});
try {
computePassEncoder0.setBindGroup(2, bindGroup160);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer176, 'uint16', 0, 0);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup100);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer107, 'uint32', 60, 300);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(1, buffer141);
} catch {}
try {
gpuCanvasContext12.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer76, 20, new Uint32Array(10839).map((_, i) => i * 1), 1511, 0);
} catch {}
let gpuCanvasContext19 = offscreenCanvas10.getContext('webgpu');
let buffer239 = device0.createBuffer({size: 26, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let textureView312 = texture250.createView({label: '\u061b\u6c4b\u32e3\u0bf7\u0452\ud748\u229c\u1bda\u0e08', baseArrayLayer: 0});
try {
renderPassEncoder12.setIndexBuffer(buffer9, 'uint32', 4, 137);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline16);
} catch {}
let texture326 = device0.createTexture({size: [4], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder17.setIndexBuffer(buffer234, 'uint32', 20, 16);
} catch {}
let textureView313 = texture86.createView({});
try {
renderPassEncoder5.setIndexBuffer(buffer178, 'uint16', 4, 31);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup155, new Uint32Array(148), 13, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer183, 'uint32', 20, 11);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline20);
} catch {}
document.body.append(img4);
let bindGroup162 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 43, resource: {buffer: buffer56}},
    {binding: 6, resource: {buffer: buffer136}},
    {binding: 3, resource: textureView3},
    {binding: 58, resource: {buffer: buffer107}},
  ],
});
let buffer240 = device0.createBuffer({
  size: 248,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder1.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer68, 32, 52);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup138, [0, 0]);
} catch {}
let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 43,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let texture327 = device0.createTexture({
  size: {width: 195, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder23.setIndexBuffer(buffer1, 'uint32', 88, 9);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer65, 'uint16', 12, 0);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(6, buffer118, 0, 722);
} catch {}
try {
device0.queue.writeBuffer(buffer216, 4, new DataView(new ArrayBuffer(18696)), 1330, 4);
} catch {}
document.body.append(img7);
let imageData43 = new ImageData(20, 44);
let buffer241 = device0.createBuffer({size: 128, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture328 = gpuCanvasContext3.getCurrentTexture();
try {
renderPassEncoder17.setIndexBuffer(buffer178, 'uint16', 4, 16);
} catch {}
try {
commandEncoder72.resolveQuerySet(querySet1, 39, 2, buffer222, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(33).fill(181), /* required buffer size: 33 */
{offset: 33, rowsPerImage: 24}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder11.setBindGroup(2, bindGroup135, new Uint32Array(3053), 138, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder150.clearBuffer(buffer106);
} catch {}
try {
device0.queue.writeBuffer(buffer192, 0, new Float32Array(2909).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.737)), 19, 0);
} catch {}
videoFrame0.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame5.close();
videoFrame8.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
videoFrame27.close();
videoFrame28.close();
videoFrame29.close();
videoFrame30.close();
videoFrame31.close();
videoFrame32.close();
videoFrame33.close();
videoFrame35.close();
videoFrame37.close();
videoFrame38.close();
videoFrame39.close();
videoFrame41.close();
videoFrame43.close();
}

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

  let workers = [

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