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

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

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

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

const videoUrls = [

];

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

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

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

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

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


async function window0() {
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'bgra8unorm-storage',
  ],
});
let sampler0 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 77.05,
  maxAnisotropy: 16,
});
let commandEncoder0 = device0.createCommandEncoder({});
let computePassEncoder0 = commandEncoder0.beginComputePass({});
let buffer0 = device0.createBuffer({size: 4322, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 885});
let texture0 = device0.createTexture({
  size: {width: 730, height: 1, depthOrArrayLayers: 154},
  sampleCount: 1,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture1 = device0.createTexture({
  size: {width: 12, height: 396, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler1 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', mipmapFilter: 'linear', lodMaxClamp: 99.70});
let commandEncoder1 = device0.createCommandEncoder({});
let textureView0 = texture0.createView({dimension: '2d', baseArrayLayer: 8});
let buffer1 = device0.createBuffer({
  size: 7185,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let commandEncoder2 = device0.createCommandEncoder({});
let textureView1 = texture0.createView({dimension: '2d', format: 'depth24plus', baseMipLevel: 0, baseArrayLayer: 23});
let texture2 = device0.createTexture({
  size: [365, 1, 9],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
device0.queue.writeBuffer(buffer1, 100, new Int16Array(3532), 367, 184);
} catch {}
let texture3 = device0.createTexture({
  size: {width: 7},
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture4 = device0.createTexture({
  size: [6],
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder1 = commandEncoder1.beginComputePass({});
let buffer2 = device0.createBuffer({
  size: 4948,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder3 = device0.createCommandEncoder();
let textureView2 = texture3.createView({});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true});
try {
renderBundleEncoder0.setVertexBuffer(7, buffer2);
} catch {}
try {
commandEncoder2.copyBufferToBuffer(buffer0, 832, buffer1, 1220, 828);
} catch {}
try {
commandEncoder2.clearBuffer(buffer2);
} catch {}
let buffer3 = device0.createBuffer({
  size: 2500,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
try {
renderBundleEncoder0.setVertexBuffer(0, undefined);
} catch {}
try {
commandEncoder3.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2366 */
  offset: 2366,
  buffer: buffer2,
}, {
  texture: texture2,
  mipLevel: 0,
  origin: {x: 69, y: 0, z: 0},
  aspect: 'all',
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder3.clearBuffer(buffer1, 688, 868);
} catch {}
let buffer4 = device0.createBuffer({
  size: 10477,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture5 = device0.createTexture({
  size: {width: 30, height: 20, depthOrArrayLayers: 286},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
commandEncoder3.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 120 */
  offset: 120,
  bytesPerRow: 21760,
  buffer: buffer1,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer4, 2132, new Int16Array(557), 27, 8);
} catch {}
let commandEncoder4 = device0.createCommandEncoder({});
let texture6 = device0.createTexture({
  size: {width: 730},
  sampleCount: 1,
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle0 = renderBundleEncoder0.finish({});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 263,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup0 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 263, resource: {buffer: buffer4, offset: 256, size: 2664}},
    {binding: 48, resource: {buffer: buffer1, offset: 768, size: 600}},
  ],
});
let buffer5 = device0.createBuffer({
  size: 2434,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder5 = device0.createCommandEncoder({});
let computePassEncoder2 = commandEncoder5.beginComputePass({});
try {
computePassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(513), 26, 0);
} catch {}
let commandEncoder6 = device0.createCommandEncoder({});
let texture7 = device0.createTexture({
  size: [16, 16, 150],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder3 = commandEncoder4.beginComputePass({});
try {
computePassEncoder3.setBindGroup(1, bindGroup0, new Uint32Array(688), 10, 0);
} catch {}
try {
computePassEncoder0.insertDebugMarker('\ue24e');
} catch {}
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'iec6196624'} });
let bindGroup1 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 263, resource: {buffer: buffer4, offset: 1792, size: 976}},
    {binding: 48, resource: {buffer: buffer1, offset: 4608, size: 1024}},
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let buffer6 = device0.createBuffer({
  size: 1496,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture8 = device0.createTexture({
  size: [30, 20, 1],
  mipLevelCount: 3,
  format: 'astc-5x4-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder2.setBindGroup(2, bindGroup0);
} catch {}
try {
computePassEncoder0.setBindGroup(1, bindGroup0, new Uint32Array(2410), 460, 0);
} catch {}
try {
commandEncoder6.copyTextureToBuffer({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 253, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 268 widthInBlocks: 67 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 648 */
  offset: 648,
  buffer: buffer2,
}, {width: 67, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let textureView3 = texture8.createView({mipLevelCount: 1});
let computePassEncoder4 = commandEncoder3.beginComputePass({});
try {
computePassEncoder2.setBindGroup(0, bindGroup0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 263,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder3.setBindGroup(2, bindGroup1);
} catch {}
let texture9 = device0.createTexture({
  size: [120, 48, 79],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8sint', 'rg8sint'],
});
let computePassEncoder5 = commandEncoder6.beginComputePass({});
let sampler2 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 89.16,
});
try {
computePassEncoder4.setBindGroup(0, bindGroup0, []);
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 48, resource: {buffer: buffer4, offset: 512, size: 3496}},
    {binding: 263, resource: {buffer: buffer1, offset: 0, size: 848}},
  ],
});
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]});
let commandEncoder7 = device0.createCommandEncoder();
let computePassEncoder6 = commandEncoder2.beginComputePass({});
try {
computePassEncoder3.setBindGroup(2, bindGroup0, new Uint32Array(272), 46, 0);
} catch {}
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 263,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let buffer7 = device0.createBuffer({
  size: 1092,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint']});
try {
renderBundleEncoder1.setBindGroup(0, bindGroup2);
} catch {}
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 263,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let buffer8 = device0.createBuffer({
  size: 4722,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let computePassEncoder7 = commandEncoder7.beginComputePass({});
let sampler3 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 92.56,
});
try {
computePassEncoder3.setBindGroup(1, bindGroup0);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer7, 'uint32', 68, 43);
} catch {}
try {
device0.queue.label = '\u0192\u{1fd34}\u{1fa8a}\u0353';
} catch {}
let commandEncoder8 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(3, bindGroup0);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 12, y: 18, z: 1},
  aspect: 'all',
},
{
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle1 = renderBundleEncoder1.finish({});
let sampler4 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 49.95,
  compare: 'greater',
  maxAnisotropy: 13,
});
try {
computePassEncoder4.setBindGroup(2, bindGroup2);
} catch {}
try {
computePassEncoder3.setBindGroup(2, bindGroup2, new Uint32Array(882), 140, 0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(2, bindGroup0, new Uint32Array(254), 5, 0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(7, buffer4);
} catch {}
let imageData0 = new ImageData(20, 20);
let textureView4 = texture4.createView({});
let renderBundle2 = renderBundleEncoder2.finish({});
let textureView5 = texture2.createView({baseArrayLayer: 4, arrayLayerCount: 2});
let computePassEncoder8 = commandEncoder9.beginComputePass();
let sampler5 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 17,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup2);
} catch {}
let buffer9 = device0.createBuffer({size: 3402, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder10 = device0.createCommandEncoder();
let sampler6 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.55,
});
let texture10 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 12},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler7 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'clamp-to-edge', lodMaxClamp: 59.41});
try {
computePassEncoder2.setBindGroup(0, bindGroup0);
} catch {}
let bindGroup3 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 263, resource: {buffer: buffer4, offset: 4864, size: 556}},
    {binding: 48, resource: {buffer: buffer1, offset: 1024, size: 1356}},
  ],
});
let commandEncoder11 = device0.createCommandEncoder();
let textureView6 = texture8.createView({mipLevelCount: 1, arrayLayerCount: 1});
let texture11 = device0.createTexture({
  size: {width: 3, height: 99, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder9 = commandEncoder10.beginComputePass();
let shaderModule0 = device0.createShaderModule({
  label: '\uf41c\u2912\u22aa\u74e2\u1356',
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

struct FragmentOutput0 {
  @location(0) @interpolate(flat, center) f0: vec4i,
  @location(7) f1: vec2i,
  @builtin(sample_mask) f2: u32,
}

var<private> vp0: FragmentOutput0 = FragmentOutput0(vec4i(556, 58, 23, 91), vec2i(522, 341), u32(29));

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

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

struct T0 {
  f0: array<u32>,
}

var<workgroup> vw0: VertexOutput0;

var<workgroup> vw1: array<array<array<array<array<vec2h, 1>, 1>, 26>, 1>, 1>;

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

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

@group(0) @binding(48) var<storage, read_write> buffer10: array<u32, 44>;

@group(0) @binding(263) var<storage, read> buffer11: array<f32>;

var<workgroup> vw3: mat4x4h;

alias vec3b = vec3<bool>;

fn fn0() -> VertexOutput0 {
  var out: VertexOutput0;
  let ptr0: ptr<private, vec2i> = &vp0.f1;
  vp0 = FragmentOutput0(vec4i(i32(length(vec3h(unconst_f16(7280.8), unconst_f16(1053.6), unconst_f16(2978.2))))), vec2i(i32(length(vec3h(unconst_f16(7280.8), unconst_f16(1053.6), unconst_f16(2978.2))))), u32(length(vec3h(unconst_f16(7280.8), unconst_f16(1053.6), unconst_f16(2978.2)))));
  var vf0: u32 = pack4xU8(vec4u(unconst_u32(86), unconst_u32(32), unconst_u32(16), unconst_u32(321)));
  return out;
}

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

var<workgroup> vw2: VertexOutput0;

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

@vertex
fn vertex0(@location(11) a0: vec4i, @location(6) @interpolate(flat) a1: vec2u, @location(9) a2: f16) -> VertexOutput0 {
  var out: VertexOutput0;
  vp0 = FragmentOutput0(vec4i(acosh(vec4h(unconst_f16(629.3), unconst_f16(-12903.7), unconst_f16(16577.9), unconst_f16(4659.4)))), bitcast<vec2i>(acosh(vec4h(unconst_f16(629.3), unconst_f16(-12903.7), unconst_f16(16577.9), unconst_f16(4659.4)))), vec4u(acosh(vec4h(unconst_f16(629.3), unconst_f16(-12903.7), unconst_f16(16577.9), unconst_f16(4659.4)))).x);
  vp0 = FragmentOutput0(unpack4xI8(arrayLength(&buffer11)), vec2i(bitcast<i32>(arrayLength(&buffer11))), arrayLength(&buffer11));
  let vf1: f16 = a2;
  out = VertexOutput0(vec4f(f32(cos(f16(unconst_f16(7108.0))))), vec4f(f32(cos(f16(unconst_f16(7108.0))))));
  out.f1 = vec4f(f32(vf1));
  out.f1 = vec4f(buffer11[u32(unconst_u32(37))]);
  let ptr1: ptr<storage, array<f32>, read> = &buffer11;
  let ptr2: ptr<storage, f32, read> = &(*&buffer11)[i32(unconst_i32(150))];
  let vf2: i32 = vp0.f0[u32(unconst_u32(141))];
  let ptr3: ptr<private, FragmentOutput0> = &vp0;
  let vf3: vec2f = unpack2x16snorm(u32(unconst_u32(12)));
  let ptr4: ptr<private, u32> = &(*ptr3).f2;
  let ptr5: ptr<private, u32> = &vp0.f2;
  let ptr6: ptr<private, FragmentOutput0> = &(*ptr3);
  return out;
  _ = buffer11;
}

@fragment
fn fragment0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  out.f1 &= vec2i(tanh(bitcast<vec2h>(buffer10[u32(unconst_u32(96))])));
  var vf4: vec2f = round(vec2f(unconst_f32(0.05697), unconst_f32(-0.09160)));
  out = FragmentOutput0(vec4i(vp0.f1[u32(unconst_u32(201))]), vec2i(vp0.f1[u32(unconst_u32(201))]), bitcast<u32>(vp0.f1[u32(unconst_u32(201))]));
  let vf5: mat2x3f = transpose(mat3x2f(unconst_f32(0.1912), unconst_f32(0.08329), unconst_f32(0.04293), unconst_f32(0.2576), unconst_f32(0.1503), unconst_f32(-0.1254)));
  var vf6 = fn0();
  buffer10[u32(unconst_u32(38))] += vec3u(vf5[unconst_i32(1)]).b;
  vf6.f1 *= vec4f(f32(arrayLength(&(*&buffer11))));
  out.f2 = u32(sign(vec3f(unconst_f32(0.1875), unconst_f32(0.1144), unconst_f32(0.03723)))[1]);
  var vf7 = fn0();
  fn0();
  buffer10[u32(unconst_u32(90))] = pack4xU8(vec4u(vf7.f0));
  let ptr7: ptr<function, vec4f> = &vf7.f0;
  let vf8: f32 = vf7.f0[u32(unconst_u32(17))];
  return out;
  _ = buffer11;
  _ = buffer10;
}

@compute @workgroup_size(2, 1, 1)
fn compute0() {
  let vf9: f16 = vw1[0][pack4x8snorm(vw0.f0)][u32(unconst_u32(41))][u32(unconst_u32(105))][0][bitcast<u32>((*&vw1)[0][u32(unconst_u32(65))][25][0][0])];
  let ptr8: ptr<workgroup, vec2h> = &vw1[0][u32(unconst_u32(43))][u32(buffer11[u32(unconst_u32(5))])][0][u32(unconst_u32(71))];
  let ptr9: ptr<workgroup, vec2h> = &vw1[0][0][u32(unconst_u32(18))][u32(unconst_u32(51))][0];
  let ptr10: ptr<workgroup, array<vec2h, 1>> = &vw1[u32(unconst_u32(111))][u32(unconst_u32(74))][25][0];
  vp0.f2 ^= u32(vw2.f1[2]);
  let ptr11: ptr<workgroup, array<array<vec2h, 1>, 1>> = &(*&vw1)[0][u32(unconst_u32(120))][u32(unconst_u32(82))];
  vp0 = FragmentOutput0(vec4i((*&vw1)[0][0][25][0][0].rggg), vec2i((*&vw1)[0][0][25][0][0]), bitcast<u32>((*&vw1)[0][0][25][0][0]));
  vw0.f0 *= vec4f(f32(vw1[u32(unconst_u32(59))][u32(unconst_u32(124))][u32(unconst_u32(229))][u32(unconst_u32(99))][0][u32(unconst_u32(315))]));
  let ptr12: ptr<workgroup, array<vec2h, 1>> = &(*&vw1)[0][u32(unconst_u32(245))][bitcast<u32>(vw1[u32(unconst_u32(517))][0][25][0][u32(unconst_u32(221))])][u32(unconst_u32(170))];
  var vf10: f16 = vw3[u32(unconst_u32(618))][u32((*&vw1)[0][u32(unconst_u32(2))][u32(unconst_u32(111))][0][0][u32(unconst_u32(54))])];
  let ptr13: ptr<workgroup, vec2h> = &(*&vw1)[u32(unconst_u32(371))][0][u32(unconst_u32(505))][bitcast<u32>(vw1[u32(unconst_u32(38))][0][25][0][0])][u32(unconst_u32(273))];
  let ptr14: ptr<workgroup, vec2h> = &(*&vw1)[u32(unconst_u32(337))][u32(unconst_u32(102))][u32(unconst_u32(336))][u32(unconst_u32(40))][u32(unconst_u32(125))];
  vw0 = VertexOutput0(vec4f(f32(vf10)), vec4f(f32(vf10)));
  let ptr15: ptr<workgroup, vec2h> = &(*&vw1)[0][0][bitcast<u32>((*&vw1)[u32(unconst_u32(56))][0][u32(unconst_u32(62))][0][0])][0][0];
  vw2.f0 = vw2.f1;
  let ptr16: ptr<workgroup, vec2h> = &(*ptr11)[0][0];
  var vf11: f16 = (*&vw1)[u32(unconst_u32(61))][0][25][u32(unconst_u32(646))][u32(unconst_u32(349))][u32(unconst_u32(163))];
  let vf12: f16 = (*&vw1)[0][u32(unconst_u32(126))][25][0][0][u32(unconst_u32(47))];
  let ptr17: ptr<workgroup, array<vec2h, 1>> = &(*&vw1)[bitcast<u32>(vw1[0][0][25][bitcast<u32>(vw1[u32(unconst_u32(136))][u32(unconst_u32(122))][25][u32(unconst_u32(133))][u32(unconst_u32(85))])][0])][0][25][u32(unconst_u32(126))];
  var vf13: f16 = vf12;
  var vf14: f16 = (*&vw1)[u32(unconst_u32(15))][u32(unconst_u32(119))][25][0][u32(unconst_u32(140))][u32(unconst_u32(136))];
  vw2.f0 = vec4f(vw1[bitcast<u32>((*&vw1)[u32(unconst_u32(140))][0][25][u32(unconst_u32(297))][0])][u32(unconst_u32(19))][25][u32(unconst_u32(48))][0].xyyy);
  vf11 = (*ptr14).r;
  _ = buffer11;
}`,
});
let textureView7 = texture0.createView({baseArrayLayer: 1, arrayLayerCount: 77});
let computePassEncoder10 = commandEncoder11.beginComputePass();
try {
computePassEncoder0.setBindGroup(1, bindGroup3, []);
} catch {}
try {
computePassEncoder1.setBindGroup(2, bindGroup2, new Uint32Array(994), 133, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let texture12 = device0.createTexture({
  size: [365, 1, 13],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.setBindGroup(0, bindGroup1);
} catch {}
try {
commandEncoder8.copyBufferToTexture({
  /* bytesInLastRow: 174 widthInBlocks: 87 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1388 */
  offset: 1388,
  bytesPerRow: 20480,
  buffer: buffer0,
}, {
  texture: texture12,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 2},
  aspect: 'all',
}, {width: 87, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer4, 7300, new BigUint64Array(12271), 1046, 16);
} catch {}
let commandEncoder12 = device0.createCommandEncoder({});
try {
commandEncoder8.copyTextureToTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 2},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer4, 4752, new BigUint64Array(36751), 6333, 12);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView8 = texture5.createView({label: '\u{1fd1c}\u07f4'});
let sampler8 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.99,
  maxAnisotropy: 4,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(73), 16, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(578).fill(41), /* required buffer size: 578 */
{offset: 578}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer12 = device0.createBuffer({
  size: 25958,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let externalTexture1 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'display-p3'});
try {
computePassEncoder8.setBindGroup(0, bindGroup1, new Uint32Array(32), 9, 0);
} catch {}
try {
computePassEncoder4.insertDebugMarker('\ue114');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 5},
  aspect: 'all',
}, new Uint8Array(4_141).fill(2), /* required buffer size: 4_141 */
{offset: 86, bytesPerRow: 3, rowsPerImage: 193}, {width: 1, height: 1, depthOrArrayLayers: 8});
} catch {}
let promise0 = device0.queue.onSubmittedWorkDone();
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 4096});
let computePassEncoder11 = commandEncoder12.beginComputePass({label: '\udc1a\u95e4'});
try {
computePassEncoder10.setBindGroup(0, bindGroup1, []);
} catch {}
let computePassEncoder12 = commandEncoder8.beginComputePass({});
let sampler9 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
buffer5.unmap();
} catch {}
let pipeline0 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}});
await gc();
let bindGroup4 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 48, resource: {buffer: buffer6, offset: 256, size: 224}},
    {binding: 263, resource: {buffer: buffer4, offset: 512, size: 316}},
  ],
});
let commandEncoder13 = device0.createCommandEncoder({});
let textureView9 = texture4.createView({});
let computePassEncoder13 = commandEncoder13.beginComputePass({});
let sampler10 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 17,
});
try {
computePassEncoder4.setPipeline(pipeline0);
} catch {}
let buffer13 = device0.createBuffer({size: 5352, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder14 = device0.createCommandEncoder({});
let textureView10 = texture11.createView({mipLevelCount: 1});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1, 2); };
} catch {}
try {
computePassEncoder4.end();
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(4, buffer7);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 904, new Int16Array(24876), 457, 308);
} catch {}
let commandEncoder15 = device0.createCommandEncoder({});
let textureView11 = texture0.createView({aspect: 'depth-only', baseArrayLayer: 2, arrayLayerCount: 11});
let renderPassEncoder0 = commandEncoder3.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  depthSlice: 0,
  clearValue: { r: 446.2, g: 593.2, b: -925.2, a: -288.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 8050106,
});
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup2, new Uint32Array(482), 212, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer1, 'uint16', 1_104, 1_108);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer9, 436, 538);
} catch {}
try {
device0.queue.writeBuffer(buffer8, 1524, new BigUint64Array(16472), 1775, 20);
} catch {}
let renderPassEncoder1 = commandEncoder14.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  depthSlice: 0,
  clearValue: { r: 785.3, g: 692.5, b: 318.4, a: -487.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let sampler11 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 84.97});
try {
computePassEncoder6.setBindGroup(3, bindGroup4, new Uint32Array(3374), 757, 0);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer8, 'uint16', 1_054, 207);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(1, buffer4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(0);
try {
computePassEncoder5.setBindGroup(0, bindGroup2, new Uint32Array(1600), 171, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup2, new Uint32Array(1100), 48, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup4);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(2, buffer13, 0, 1_557);
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(30, 222);
let shaderModule1 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires pointer_composite_access;

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

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

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

struct T3 {
  @align(4) @size(4) f0: f16,
}

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

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

@group(0) @binding(48) var<storage, read_write> buffer14: T2;

var<workgroup> vw4: atomic<i32>;

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

struct FragmentOutput1 {
  @location(2) f0: vec4i,
  @location(0) f1: vec4i,
}

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

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

struct S0 {
  @location(13) @interpolate(flat) f0: i32,
  @location(12) @interpolate(flat) f1: vec2u,
}

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

struct T1 {
  f0: array<u32>,
}

@vertex
fn vertex1(a0: S0, @location(4) a1: u32, @location(7) @interpolate(flat) a2: vec4i, @builtin(instance_index) a3: u32, @location(1) a4: vec2h) -> VertexOutput1 {
  var out: VertexOutput1;
  let ptr18: ptr<storage, array<f16, 1>, read> = &buffer15[u32(unconst_u32(5))][1];
  var vf15: vec2h = inverseSqrt(vec2h(unconst_f16(20856.9), unconst_f16(1975.4)));
  let ptr19: ptr<storage, f16, read> = &buffer15[u32(unconst_u32(50))][1][0];
  return out;
  _ = buffer15;
}

@fragment
fn fragment1() -> FragmentOutput1 {
  var out: FragmentOutput1;
  let ptr20: ptr<storage, atomic<i32>, read_write> = &(*&buffer14).f1[u32(unconst_u32(218))][bitcast<u32>((*&buffer14).f0.f0[0])][u32(unconst_u32(24))];
  out.f1 &= vec4i(i32(buffer15[u32(unconst_u32(154))][1][0]));
  let ptr21: ptr<storage, atomic<i32>, read_write> = &buffer14.f1[arrayLength(&buffer14.f1)][u32(unconst_u32(166))][0];
  let ptr22: ptr<storage, f16, read> = &buffer15[u32(buffer15[arrayLength(&buffer15) - 1][1][0])][1][0];
  return out;
  _ = buffer14;
  _ = buffer15;
}

@compute @workgroup_size(2, 1, 1)
fn compute1() {
  buffer14.f0 = T0(array<i32, 1>(atomicExchange(&buffer14.f1[u32(unconst_u32(68))][0][u32(unconst_u32(415))], i32(unconst_i32(29)))));
  atomicAdd(&vw4, i32(unconst_i32(-85)));
  var vf16: i32 = atomicLoad(&(*&buffer14).f1[u32(unconst_u32(185))][0][u32(unconst_u32(436))]);
  let ptr23: ptr<storage, atomic<i32>, read_write> = &(*&buffer14).f1[arrayLength(&(*&buffer14).f1)][u32(unconst_u32(151))][0];
  atomicCompareExchangeWeak(&buffer14.f1[u32(unconst_u32(21))][0][u32((*&buffer15)[u32(buffer15[u32(unconst_u32(56))][1][0])][u32(unconst_u32(38))][bitcast<u32>(atomicLoad(&(*&buffer14).f1[u32(unconst_u32(195))][u32(unconst_u32(274))][0]))])], unconst_i32(16), unconst_i32(244));
  let vf17: i32 = atomicLoad(&(*&buffer14).f1[arrayLength(&(*&buffer14).f1)][0][0]);
  let ptr24: ptr<storage, atomic<i32>, read_write> = &(*&buffer14).f1[arrayLength(&(*&buffer14).f1)][0][0];
  vf16 = atomicLoad(&(*&buffer14).f1[u32(unconst_u32(152))][0][0]);
  vf16 = bitcast<i32>(arrayLength(&buffer14.f1));
  vf16 -= buffer14.f0.f0[0];
  buffer14.f0 = T0(array<i32, 1>(i32(sin(vec4h(unconst_f16(5172.6), unconst_f16(209.8), unconst_f16(8073.0), unconst_f16(8361.2))).x)));
  let ptr25: ptr<storage, atomic<i32>, read_write> = &(*&buffer14).f1[arrayLength(&(*&buffer14).f1)][0][u32(quantizeToF16(vec2f(unconst_f32(0.2036), unconst_f32(0.09891))).g)];
  let ptr26: ptr<storage, f16, read> = &buffer15[arrayLength(&buffer15)][u32(unconst_u32(87))][0];
  let vf18: u32 = pack2x16float(vec2f(unconst_f32(0.2713), unconst_f32(0.2176)));
  atomicCompareExchangeWeak(&vw4, unconst_i32(425), unconst_i32(323));
  atomicCompareExchangeWeak(&vw4, unconst_i32(155), unconst_i32(63));
  let ptr27: ptr<storage, atomic<i32>, read_write> = &buffer14.f1[u32(unconst_u32(79))][u32(buffer15[u32(buffer15[arrayLength(&buffer15)][1][0])][u32(unconst_u32(167))][0])][0];
  _ = buffer15;
  _ = buffer14;
}`,
});
let commandEncoder16 = device0.createCommandEncoder({});
let renderBundle3 = renderBundleEncoder3.finish({});
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
commandEncoder15.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2760 */
  offset: 2760,
  buffer: buffer1,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 4928, new BigUint64Array(8733), 83, 20);
} catch {}
let promise1 = device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule1,
  constants: {},
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 264,
        attributes: [
          {format: 'uint32x3', offset: 180, shaderLocation: 6},
          {format: 'sint32x3', offset: 88, shaderLocation: 11},
          {format: 'snorm16x4', offset: 12, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'back', unclippedDepth: true},
});
let computePassEncoder14 = commandEncoder16.beginComputePass({});
let sampler12 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', minFilter: 'linear'});
try {
computePassEncoder5.setBindGroup(3, bindGroup3);
} catch {}
try {
computePassEncoder5.setBindGroup(0, bindGroup2, new Uint32Array(1018), 264, 0);
} catch {}
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer5, 640, 301);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer1, 440, new DataView(new ArrayBuffer(18379)), 2544, 0);
} catch {}
let buffer16 = device0.createBuffer({
  size: 19717,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView12 = texture3.createView({});
let computePassEncoder15 = commandEncoder15.beginComputePass();
try {
renderPassEncoder1.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer12);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let sampler13 = device0.createSampler({lodMaxClamp: 85.25});
try {
computePassEncoder15.setBindGroup(3, bindGroup3);
} catch {}
let textureView13 = texture2.createView({dimension: '2d', baseArrayLayer: 1});
try {
computePassEncoder3.setBindGroup(2, bindGroup2);
} catch {}
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.pushDebugGroup('\uf35c');
} catch {}
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 37});
let texture13 = device0.createTexture({
  size: {width: 15, height: 6, depthOrArrayLayers: 33},
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler14 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 99.75, compare: 'greater'});
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder1.popDebugGroup();
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u0eb4');
} catch {}
let bindGroup5 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 48, resource: {buffer: buffer8, offset: 1024, size: 1144}},
    {binding: 263, resource: {buffer: buffer13, offset: 512, size: 908}},
  ],
});
let buffer17 = device0.createBuffer({size: 5554, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder17 = device0.createCommandEncoder({});
let renderPassEncoder2 = commandEncoder17.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -73.13, g: 568.0, b: 523.9, a: -74.87, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup2, []);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(79);
} catch {}
try {
buffer4.unmap();
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let pipeline1 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule0,
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex1',
    constants: {},
    buffers: [
      {
        arrayStride: 160,
        attributes: [
          {format: 'float16x4', offset: 16, shaderLocation: 1},
          {format: 'uint8x2', offset: 12, shaderLocation: 12},
          {format: 'sint8x4', offset: 48, shaderLocation: 13},
          {format: 'sint16x4', offset: 4, shaderLocation: 7},
          {format: 'uint8x4', offset: 16, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', unclippedDepth: true},
});
let bindGroup6 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 263, resource: {buffer: buffer1, offset: 1024, size: 1684}},
    {binding: 48, resource: {buffer: buffer13, offset: 1024}},
  ],
});
let commandEncoder18 = device0.createCommandEncoder({});
let computePassEncoder16 = commandEncoder18.beginComputePass({});
let sampler15 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.00,
  lodMaxClamp: 70.27,
  compare: 'equal',
  maxAnisotropy: 8,
});
try {
renderPassEncoder1.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer12, 'uint32', 208, 5_930);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
let commandEncoder19 = device0.createCommandEncoder({});
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 743});
let renderPassEncoder3 = commandEncoder19.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -522.1, g: 882.3, b: 186.3, a: -850.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer9, 0, 439);
} catch {}
let texture14 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 12},
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: 670.6, g: 315.1, b: 6.111, a: 745.0, });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
try {
  await promise2;
} catch {}
let querySet4 = device0.createQuerySet({type: 'occlusion', count: 63});
let textureView14 = texture5.createView({mipLevelCount: 1});
let texture15 = device0.createTexture({
  size: [15, 6, 25],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let recycledExplicitBindGroupLayout1 = pipeline0.getBindGroupLayout(0);
let externalTexture2 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder5.setBindGroup(0, bindGroup0, new Uint32Array(1058), 6, 0);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup5, new Uint32Array(2178), 1_050, 0);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(253);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(2, buffer3, 0, 251);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let pipeline2 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule1}});
let commandEncoder20 = device0.createCommandEncoder({});
let renderPassEncoder4 = commandEncoder20.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -763.5, g: -946.4, b: 128.8, a: 892.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 547486181,
});
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setScissorRect(16, 0, 16, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer2, 'uint32', 196, 605);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(5, buffer2);
} catch {}
try {
device0.queue.writeBuffer(buffer6, 196, new DataView(new ArrayBuffer(11029)), 1059, 124);
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

enable f16;

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

struct VertexOutput2 {
  @location(1) @interpolate(flat) f3: vec4f,
  @builtin(position) f4: vec4f,
  @location(8) f5: vec2u,
  @location(6) @interpolate(flat, sample) f6: vec2u,
  @location(15) @interpolate(flat, center) f7: vec2u,
}

var<private> vp2: mat2x2h = mat2x2h();

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

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

@group(0) @binding(263) var<storage, read> buffer19: array<array<T0, 2>, 1>;

struct S1 {
  @location(13) @interpolate(linear) f0: vec2h,
  @location(6) f1: vec4f,
  @location(15) f2: vec4i,
  @location(2) f3: vec2i,
  @location(12) @interpolate(flat) f4: vec4f,
  @location(1) @interpolate(flat) f5: vec2u,
  @location(9) f6: i32,
  @location(0) @interpolate(flat, center) f7: u32,
  @location(8) f8: vec2i,
}

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

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

var<private> vp1: mat4x3h = mat4x3h();

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

fn fn0() -> S1 {
  var out: S1;
  vp1 -= mat4x3h(vec3h(vp3.f1.yzz), vec3h(vp3.f1.rra), vec3h(vp3.f1.rrb), vec3h(vp3.f1.xwy));
  let vf19: vec4h = sqrt(vec4h(unconst_f16(5517.7), unconst_f16(13937.4), unconst_f16(28521.7), unconst_f16(7535.5)));
  let ptr28: ptr<private, vec4i> = &vp3.f1;
  let ptr29: ptr<storage, f16, read> = &buffer19[0][u32(unconst_u32(409))].f0[0];
  out.f6 = (*ptr28)[u32(unconst_u32(130))];
  out.f3 ^= vec2i(i32((*&buffer19)[u32(unconst_u32(112))][u32(unconst_u32(134))].f0[0]));
  let ptr30: ptr<storage, f16, read> = &buffer19[0][1].f0[u32(unconst_u32(299))];
  let ptr31: ptr<storage, f16, read> = &buffer19[0][u32(unconst_u32(369))].f0[0];
  let ptr32: ptr<storage, array<T0, 2>, read> = &(*&buffer19)[u32(unconst_u32(29))];
  let ptr33: ptr<storage, f16, read> = &buffer19[0][u32(unconst_u32(577))].f0[u32(unconst_u32(20))];
  let ptr34: ptr<storage, f16, read> = &(*&buffer19)[0][u32(unconst_u32(90))].f0[0];
  let ptr35: ptr<storage, f16, read> = &(*ptr32)[u32(unconst_u32(309))].f0[0];
  let ptr36: ptr<storage, array<f16, 1>, read> = &(*&buffer19)[pack4xU8Clamp(vec4u(acos(vec4h(unconst_f16(1538.3), unconst_f16(47844.4), unconst_f16(13314.2), unconst_f16(18373.0)))))][u32(unconst_u32(799))].f0;
  out = S1(vec2h(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])]), vec4f(f32(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])])), vec4i(i32(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])])), vec2i(i32(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])])), vec4f(f32(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])])), vec2u(u32(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])])), i32(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])]), u32(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])]), vec2i(i32(vp1[u32(unconst_u32(47))][u32((*ptr36)[0])])));
  out.f3 += vec2i(i32((*&buffer19)[u32(buffer19[u32(unconst_u32(110))][pack4xU8(vec4u(inverseSqrt(vec4h(unconst_f16(47049.1), unconst_f16(13799.6), unconst_f16(-8313.5), unconst_f16(20222.7)))))].f0[0])][1].f0[0]));
  out.f0 *= vec2h(buffer19[0][u32(unconst_u32(70))].f0[u32(unconst_u32(100))]);
  out.f4 -= vec4f(reflect(vec4h(unconst_f16(9305.1), unconst_f16(1504.0), unconst_f16(-1901.4), unconst_f16(12111.0)), vec4h(unconst_f16(7675.7), unconst_f16(3208.6), unconst_f16(4076.4), unconst_f16(5411.7))));
  vp1 += mat4x3h((*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0], (*&buffer19)[u32(unconst_u32(193))][1].f0[0]);
  out.f5 <<= vec2u(countTrailingZeros(vec3i(unconst_i32(17), unconst_i32(117), unconst_i32(57))).xz);
  let ptr37: ptr<storage, f16, read> = &(*&buffer19)[u32(unconst_u32(58))][1].f0[0];
  let ptr38: ptr<storage, array<f16, 1>, read> = &buffer19[0][1].f0;
  let ptr39: ptr<storage, f16, read> = &(*ptr36)[u32(unconst_u32(123))];
  return out;
  _ = buffer19;
}

@group(0) @binding(48) var<storage, read_write> buffer18: array<array<array<array<array<T0, 1>, 2>, 2>, 22>>;

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

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

var<private> vp3: FragmentOutput2 = FragmentOutput2(f32(0.1530), vec4i(239, 39, 32, 10));

@vertex
fn vertex2(@location(14) @interpolate(flat) a0: vec2i, @location(5) @interpolate(flat, sample) a1: vec4i, @location(4) @interpolate(flat) a2: vec2u, @location(11) @interpolate(flat) a3: u32, a4: S1, @location(7) @interpolate(flat, centroid) a5: vec4h, @location(10) a6: f16, @location(3) a7: f16, @builtin(instance_index) a8: u32) -> VertexOutput2 {
  var out: VertexOutput2;
  out.f3 *= vec4f(bitcast<f32>(a0[u32(unconst_u32(12))]));
  var vf20 = fn0();
  let vf21: f16 = atan(f16(unconst_f16(7545.7)));
  var vf22 = fn0();
  out.f3 = vec4f(f32(vf21));
  var vf23 = fn0();
  fn0();
  let ptr40: ptr<function, vec2h> = &vf22.f0;
  vf23 = S1(vec2h(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0]), vec4f(f32(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0])), vec4i(i32(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0])), vec2i(i32(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0])), vec4f(f32(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0])), vec2u(u32(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0])), i32(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0]), u32(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0]), vec2i(i32(buffer19[u32(unconst_u32(260))][u32(unconst_u32(13))].f0[0])));
  let ptr41: ptr<function, vec2u> = &vf23.f5;
  var vf24 = fn0();
  out.f3 = vec4f(f32((*&buffer19)[u32(unconst_u32(91))][1].f0[0]));
  var vf25 = fn0();
  var vf26 = fn0();
  fn0();
  out.f4 -= vec4f(bitcast<f32>(vf20.f8[u32(unconst_u32(369))]));
  vp2 = mat2x2h((*&buffer19)[0][1].f0[0], (*&buffer19)[0][1].f0[0], (*&buffer19)[0][1].f0[0], (*&buffer19)[0][1].f0[0]);
  fn0();
  return out;
  _ = buffer19;
}

@fragment
fn fragment2() -> FragmentOutput2 {
  var out: FragmentOutput2;
  vp3.f0 = f32((*&buffer18)[arrayLength(&(*&buffer18))][21][1][u32(unconst_u32(396))][u32(unconst_u32(45))].f0[u32(unconst_u32(291))]);
  vp3.f1 = vec4i(i32((*&buffer18)[u32(unconst_u32(34))][u32(unconst_u32(242))][u32(unconst_u32(31))][1][u32(unconst_u32(232))].f0[u32(unconst_u32(101))]));
  vp3.f0 -= f32(buffer18[u32(unconst_u32(170))][21][1][u32(unconst_u32(193))][u32(unconst_u32(91))].f0[0]);
  vp2 = mat2x2h(buffer18[u32(buffer18[arrayLength(&buffer18)][21][1][1][u32(unconst_u32(47))].f0[0])][u32(unconst_u32(311))][1][u32(buffer18[u32(unconst_u32(100))][21][u32(unconst_u32(11))][u32(unconst_u32(71))][0].f0[0])][0].f0[0], buffer18[u32(buffer18[arrayLength(&buffer18)][21][1][1][u32(unconst_u32(47))].f0[0])][u32(unconst_u32(311))][1][u32(buffer18[u32(unconst_u32(100))][21][u32(unconst_u32(11))][u32(unconst_u32(71))][0].f0[0])][0].f0[0], buffer18[u32(buffer18[arrayLength(&buffer18)][21][1][1][u32(unconst_u32(47))].f0[0])][u32(unconst_u32(311))][1][u32(buffer18[u32(unconst_u32(100))][21][u32(unconst_u32(11))][u32(unconst_u32(71))][0].f0[0])][0].f0[0], buffer18[u32(buffer18[arrayLength(&buffer18)][21][1][1][u32(unconst_u32(47))].f0[0])][u32(unconst_u32(311))][1][u32(buffer18[u32(unconst_u32(100))][21][u32(unconst_u32(11))][u32(unconst_u32(71))][0].f0[0])][0].f0[0]);
  let ptr42: ptr<storage, f16, read_write> = &buffer18[arrayLength(&buffer18)][21][1][u32(unconst_u32(85))][0].f0[0];
  vp3.f0 = f32((*&buffer18)[u32(unconst_u32(41))][21][1][u32(unconst_u32(24))][0].f0[u32(buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(61))][u32((*&buffer18)[arrayLength(&(*&buffer18))][u32(unconst_u32(101))][1][1][u32(unconst_u32(147))].f0[0])][u32(unconst_u32(17))].f0[0])]);
  out.f1 = vec4i(i32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(441))][u32(unconst_u32(231))][0].f0[0]));
  let ptr43: ptr<storage, f16, read_write> = &buffer18[u32(unconst_u32(27))][u32(unconst_u32(313))][u32(unconst_u32(27))][1][u32(unconst_u32(36))].f0[0];
  fn0();
  out.f1 &= vec4i(i32(buffer18[u32(buffer18[u32(unconst_u32(24))][u32(unconst_u32(74))][1][1][0].f0[0])][21][1][1][0].f0[0]));
  let ptr44: ptr<storage, array<array<T0, 1>, 2>, read_write> = &buffer18[u32(unconst_u32(64))][21][u32(unconst_u32(4))];
  var vf27 = fn0();
  out.f1 = vec4i(i32(buffer18[arrayLength(&buffer18)][u32(unconst_u32(459))][1][1][0].f0[0]));
  let ptr45: ptr<storage, T0, read_write> = &(*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(1))][1][0];
  var vf28 = fn0();
  out.f1 |= vec4i(i32((*&buffer18)[arrayLength(&(*&buffer18))][u32(unconst_u32(237))][u32(unconst_u32(139))][1][u32(unconst_u32(72))].f0[u32(unconst_u32(85))]));
  out.f1 = vec4i(i32((*ptr44)[1][u32(unconst_u32(100))].f0[0]));
  vf28 = S1(vec2h((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0]), vec4f(f32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0])), vec4i(i32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0])), vec2i(i32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0])), vec4f(f32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0])), vec2u(u32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0])), i32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0]), u32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0]), vec2i(i32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(19))][1][0].f0[0])));
  var vf29 = fn0();
  out = FragmentOutput2(f32((*&buffer18)[arrayLength(&(*&buffer18))][u32(unconst_u32(263))][1][1][0].f0[0]), vec4i(i32((*&buffer18)[arrayLength(&(*&buffer18))][u32(unconst_u32(263))][1][1][0].f0[0])));
  return out;
  _ = buffer19;
  _ = buffer18;
}

@fragment
fn fragment3() -> FragmentOutput3 {
  var out: FragmentOutput3;
  let ptr46: ptr<storage, T0, read_write> = &(*&buffer18)[u32(unconst_u32(84))][u32(unconst_u32(52))][1][u32(buffer18[u32(unconst_u32(129))][21][1][u32(unconst_u32(440))][0].f0[0])][0];
  fn0();
  let ptr47: ptr<storage, T0, read> = &(*&buffer19)[u32(buffer18[arrayLength(&buffer18)][u32(unconst_u32(167))][u32(unconst_u32(221))][u32(unconst_u32(147))][0].f0[u32(unconst_u32(21))])][u32(unconst_u32(714))];
  vp1 += mat4x3h(buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0], buffer18[u32(unconst_u32(24))][u32(unconst_u32(176))][1][1][u32(unconst_u32(13))].f0[0]);
  let ptr48: ptr<storage, f16, read> = &buffer19[u32(unconst_u32(132))][u32(unconst_u32(45))].f0[u32(unconst_u32(32))];
  out.f0 >>= u32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(199))][u32(unconst_u32(99))][u32(unconst_u32(1))].f0[0]);
  out.f0 ^= u32((*&buffer18)[u32(unconst_u32(287))][u32(unconst_u32(53))][u32(buffer18[u32(unconst_u32(136))][21][u32(unconst_u32(708))][1][0].f0[u32(unconst_u32(78))])][u32(unconst_u32(439))][0].f0[u32(unconst_u32(103))]);
  fn0();
  out = FragmentOutput3(u32((*&buffer18)[u32(unconst_u32(71))][21][1][u32(unconst_u32(281))][0].f0[0]), vec2f(f32((*&buffer18)[u32(unconst_u32(71))][21][1][u32(unconst_u32(281))][0].f0[0])));
  let ptr49: ptr<storage, f16, read_write> = &(*&buffer18)[u32(unconst_u32(72))][u32(unconst_u32(69))][1][u32(unconst_u32(29))][0].f0[0];
  let ptr50: ptr<storage, array<f16, 1>, read_write> = &(*&buffer18)[arrayLength(&(*&buffer18))][u32(unconst_u32(355))][1][1][u32(unconst_u32(139))].f0;
  var vf30 = fn0();
  var vf31 = fn0();
  vp1 = mat4x3h((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0], (*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[0]);
  vp3 = FragmentOutput2(f32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[u32(unconst_u32(360))]), vec4i(i32((*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(210))][1][0].f0[u32(unconst_u32(360))])));
  vp2 = mat2x2h(buffer18[u32((*ptr50)[u32(unconst_u32(108))])][u32(unconst_u32(68))][u32(unconst_u32(4))][1][0].f0[0], buffer18[u32((*ptr50)[u32(unconst_u32(108))])][u32(unconst_u32(68))][u32(unconst_u32(4))][1][0].f0[0], buffer18[u32((*ptr50)[u32(unconst_u32(108))])][u32(unconst_u32(68))][u32(unconst_u32(4))][1][0].f0[0], buffer18[u32((*ptr50)[u32(unconst_u32(108))])][u32(unconst_u32(68))][u32(unconst_u32(4))][1][0].f0[0]);
  let ptr51: ptr<storage, f16, read> = &(*&buffer19)[u32(unconst_u32(27))][1].f0[u32(unconst_u32(84))];
  vp1 += mat4x3h(buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0], buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0]);
  let ptr52: ptr<function, vec2i> = &vf30.f8;
  return out;
  _ = buffer18;
  _ = buffer19;
}

@compute @workgroup_size(1, 1, 1)
fn compute2() {
  let vf32: u32 = pack2x16float(vec2f(unconst_f32(-0.1250), unconst_f32(0.1568)));
  vp3.f1 -= vec4i(i32((*&buffer18)[u32(unconst_u32(10))][21][u32(unconst_u32(90))][u32(buffer18[u32(unconst_u32(231))][u32(unconst_u32(163))][1][1][0].f0[0])][0].f0[0]));
  let ptr53: ptr<storage, T0, read_write> = &(*&buffer18)[arrayLength(&(*&buffer18))][21][1][u32(unconst_u32(55))][u32((*&buffer18)[u32(unconst_u32(171))][21][1][1][0].f0[0])];
  let ptr54: ptr<storage, T0, read_write> = &buffer18[arrayLength(&buffer18)][u32(unconst_u32(32))][u32(unconst_u32(154))][1][u32(unconst_u32(501))];
  let ptr55: ptr<storage, f16, read_write> = &buffer18[arrayLength(&buffer18)][21][1][vec3u(vp1[unconst_i32(1)])[2]][u32(unconst_u32(3))].f0[0];
  vp3 = FragmentOutput2(f32(buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0]), vec4i(i32(buffer18[arrayLength(&buffer18)][21][1][1][0].f0[0])));
  let ptr56: ptr<storage, f16, read_write> = &(*&buffer18)[u32(buffer18[arrayLength(&buffer18)][u32(unconst_u32(993))][1][1][0].f0[0])][u32(unconst_u32(124))][u32(unconst_u32(376))][1][0].f0[u32(unconst_u32(61))];
  vp2 = mat2x2h(buffer18[u32(unconst_u32(29))][21][1][1][0].f0[0], buffer18[u32(unconst_u32(29))][21][1][1][0].f0[0], buffer18[u32(unconst_u32(29))][21][1][1][0].f0[0], buffer18[u32(unconst_u32(29))][21][1][1][0].f0[0]);
  vp3 = FragmentOutput2(f32((*&buffer18)[arrayLength(&(*&buffer18))][u32(buffer18[u32(buffer18[arrayLength(&buffer18)][u32(unconst_u32(128))][1][1][u32(unconst_u32(29))].f0[0])][21][1][1][u32(unconst_u32(91))].f0[0])][u32(unconst_u32(2))][u32(unconst_u32(327))][u32(unconst_u32(145))].f0[0]), vec4i(i32((*&buffer18)[arrayLength(&(*&buffer18))][u32(buffer18[u32(buffer18[arrayLength(&buffer18)][u32(unconst_u32(128))][1][1][u32(unconst_u32(29))].f0[0])][21][1][1][u32(unconst_u32(91))].f0[0])][u32(unconst_u32(2))][u32(unconst_u32(327))][u32(unconst_u32(145))].f0[0])));
  let ptr57: ptr<storage, T0, read_write> = &buffer18[u32(unconst_u32(56))][u32(unconst_u32(47))][1][1][0];
  let ptr58: ptr<storage, f16, read_write> = &(*&buffer18)[arrayLength(&(*&buffer18))][u32(unconst_u32(41))][1][1][u32(unconst_u32(543))].f0[0];
  let vf33: vec4f = degrees(vec4f(unconst_f32(0.2301), unconst_f32(0.08178), unconst_f32(0.2432), unconst_f32(0.7128)));
  vp1 -= mat4x3h(buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))], buffer18[arrayLength(&buffer18)][21][u32(unconst_u32(300))][1][0].f0[u32(unconst_u32(41))]);
  vp2 += mat2x2h(buffer18[arrayLength(&buffer18)][u32(unconst_u32(222))][1][u32(unconst_u32(60))][u32(unconst_u32(1000))].f0[0], buffer18[arrayLength(&buffer18)][u32(unconst_u32(222))][1][u32(unconst_u32(60))][u32(unconst_u32(1000))].f0[0], buffer18[arrayLength(&buffer18)][u32(unconst_u32(222))][1][u32(unconst_u32(60))][u32(unconst_u32(1000))].f0[0], buffer18[arrayLength(&buffer18)][u32(unconst_u32(222))][1][u32(unconst_u32(60))][u32(unconst_u32(1000))].f0[0]);
  _ = buffer18;
}

@compute @workgroup_size(3, 1, 1)
fn compute3(@builtin(local_invocation_id) a0: vec3u) {
  var vf34: i32 = vp3.f1[u32(unconst_u32(121))];
  vp2 = mat2x2h((*&buffer18)[u32(unconst_u32(433))][u32(unconst_u32(514))][1][u32(unconst_u32(6))][u32(unconst_u32(385))].f0[0], (*&buffer18)[u32(unconst_u32(433))][u32(unconst_u32(514))][1][u32(unconst_u32(6))][u32(unconst_u32(385))].f0[0], (*&buffer18)[u32(unconst_u32(433))][u32(unconst_u32(514))][1][u32(unconst_u32(6))][u32(unconst_u32(385))].f0[0], (*&buffer18)[u32(unconst_u32(433))][u32(unconst_u32(514))][1][u32(unconst_u32(6))][u32(unconst_u32(385))].f0[0]);
  let ptr59: ptr<storage, f16, read_write> = &(*&buffer18)[u32(unconst_u32(51))][u32(unconst_u32(312))][u32((*&buffer18)[arrayLength(&(*&buffer18))][u32(unconst_u32(226))][1][u32(unconst_u32(20))][u32(unconst_u32(89))].f0[0])][u32(unconst_u32(161))][0].f0[0];
  let ptr60: ptr<storage, f16, read_write> = &buffer18[u32(unconst_u32(2))][21][1][u32(unconst_u32(351))][u32(unconst_u32(263))].f0[0];
  buffer18[u32(unconst_u32(92))][u32(unconst_u32(53))][u32(unconst_u32(41))][u32(unconst_u32(217))][u32(unconst_u32(80))] = T0(array<f16, 1>((*&buffer18)[u32(buffer18[u32(unconst_u32(14))][21][u32(unconst_u32(140))][1][u32(unconst_u32(48))].f0[u32(unconst_u32(129))])][21][1][u32(unconst_u32(153))][0].f0[u32(unconst_u32(232))]));
  let ptr61: ptr<storage, f16, read_write> = &(*&buffer18)[u32(unconst_u32(22))][21][u32(unconst_u32(79))][1][0].f0[0];
  let ptr62: ptr<storage, array<f16, 1>, read_write> = &(*&buffer18)[u32(unconst_u32(215))][u32((*&buffer18)[arrayLength(&(*&buffer18))][u32(unconst_u32(64))][1][u32(unconst_u32(94))][0].f0[0])][1][u32(unconst_u32(706))][0].f0;
  let ptr63: ptr<storage, array<array<T0, 1>, 2>, read_write> = &(*&buffer18)[arrayLength(&(*&buffer18))][21][u32(unconst_u32(57))];
  let ptr64: ptr<storage, T0, read_write> = &(*ptr63)[1][0];
  let ptr65: ptr<storage, array<T0, 1>, read_write> = &(*&buffer18)[u32(unconst_u32(5))][21][u32(unconst_u32(9))][u32(unconst_u32(96))];
  _ = buffer18;
}`,
});
let buffer20 = device0.createBuffer({size: 43414, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder21 = device0.createCommandEncoder();
let texture16 = device0.createTexture({size: {width: 60}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST});
let sampler16 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 89.70,
});
try {
computePassEncoder13.setBindGroup(0, bindGroup5);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer17, 116); };
} catch {}
try {
computePassEncoder5.end();
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup2, new Uint32Array(2866), 466, 0);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(161);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setScissorRect(18, 0, 21, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer9);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 1,
  origin: {x: 1, y: 3, z: 15},
  aspect: 'all',
}, new Uint8Array(9_278).fill(64), /* required buffer size: 9_278 */
{offset: 148, bytesPerRow: 55, rowsPerImage: 166}, {width: 0, height: 0, depthOrArrayLayers: 2});
} catch {}
let computePassEncoder17 = commandEncoder21.beginComputePass();
let renderPassEncoder5 = commandEncoder6.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  depthSlice: 0,
  clearValue: { r: -704.4, g: 382.4, b: 670.4, a: -422.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
let sampler17 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', minFilter: 'linear'});
try {
computePassEncoder8.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder6.setBindGroup(0, bindGroup1, new Uint32Array(3983), 118, 0);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -516.1, g: -982.3, b: -973.9, a: -610.6, });
} catch {}
try {
renderPassEncoder1.setViewport(1.4520439753378664, 38.8265804333903, 0.9054587134442734, 53.25385304351156, 0.9543081537030897, 0.9819104037366251);
} catch {}
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 48, resource: {buffer: buffer12, offset: 256, size: 4004}},
    {binding: 263, resource: {buffer: buffer12, offset: 23808, size: 28}},
  ],
});
let buffer21 = device0.createBuffer({size: 22182, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
renderPassEncoder3.setBindGroup(0, bindGroup5, new Uint32Array(3932), 5, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint32', 92, 201);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer7);
} catch {}
try {
buffer8.unmap();
} catch {}
let recycledExplicitBindGroupLayout2 = pipeline0.getBindGroupLayout(0);
let bindGroup8 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 48, resource: {buffer: buffer6, offset: 0}},
    {binding: 263, resource: {buffer: buffer4, offset: 3072, size: 1292}},
  ],
});
let commandEncoder22 = device0.createCommandEncoder({});
let textureView15 = texture14.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6});
let computePassEncoder18 = commandEncoder22.beginComputePass({});
let sampler18 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', maxAnisotropy: 1});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder15.setPipeline(pipeline2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let buffer22 = device0.createBuffer({size: 777, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
try {
computePassEncoder7.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup2, new Uint32Array(734), 203, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer5, 'uint16', 22, 551);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
await gc();
let texture17 = device0.createTexture({
  size: {width: 60, height: 40, depthOrArrayLayers: 127},
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder15.setBindGroup(0, bindGroup3, new Uint32Array(2080), 569, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(6, buffer13, 0);
} catch {}
let pipeline3 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0}});
let pipeline4 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth16unorm',
    depthWriteEnabled: false,
    depthCompare: 'not-equal',
    stencilWriteMask: 49067265,
    depthBias: 0,
  },
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 224,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 8, shaderLocation: 15},
          {format: 'uint16x2', offset: 4, shaderLocation: 1},
          {format: 'snorm16x4', offset: 136, shaderLocation: 7},
          {format: 'sint8x4', offset: 0, shaderLocation: 9},
          {format: 'sint16x2', offset: 24, shaderLocation: 8},
          {format: 'sint8x4', offset: 12, shaderLocation: 14},
          {format: 'snorm8x4', offset: 36, shaderLocation: 12},
          {format: 'uint32x3', offset: 48, shaderLocation: 11},
          {format: 'uint32x3', offset: 44, shaderLocation: 4},
          {format: 'sint8x4', offset: 40, shaderLocation: 2},
          {format: 'uint32x2', offset: 8, shaderLocation: 0},
          {format: 'sint32x4', offset: 24, shaderLocation: 5},
          {format: 'float32x2', offset: 28, shaderLocation: 6},
          {format: 'unorm8x2', offset: 8, shaderLocation: 10},
          {format: 'unorm16x2', offset: 12, shaderLocation: 13},
        ],
      },
      {arrayStride: 484, attributes: [{format: 'unorm8x2', offset: 20, shaderLocation: 3}]},
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
let buffer23 = device0.createBuffer({size: 2602, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let commandEncoder23 = device0.createCommandEncoder({});
let texture18 = device0.createTexture({
  size: {width: 15, height: 10, depthOrArrayLayers: 143},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder14.setBindGroup(1, bindGroup0, new Uint32Array(2402), 2_352, 0);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer5, 88, 565);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 0, new Float32Array(29640), 3952, 8);
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
let recycledExplicitBindGroupLayout3 = pipeline2.getBindGroupLayout(0);
let bindGroup9 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 263, resource: {buffer: buffer6, offset: 256, size: 92}},
    {binding: 48, resource: {buffer: buffer12, offset: 1280, size: 892}},
  ],
});
let commandEncoder24 = device0.createCommandEncoder();
try {
computePassEncoder16.setBindGroup(0, bindGroup1);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer1, 96); };
} catch {}
try {
computePassEncoder2.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint32', 1_896, 10_382);
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1368 */
  offset: 1368,
  buffer: buffer16,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder23.resolveQuerySet(querySet3, 87, 4, buffer4, 768);
} catch {}
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt2020', transfer: 'iec61966-2-1'} });
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 167,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 235,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let commandEncoder25 = device0.createCommandEncoder({});
let renderPassEncoder6 = commandEncoder24.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -490.0, g: 316.9, b: -740.9, a: 946.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 257728100,
});
try {
renderPassEncoder0.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(6, buffer3, 0, 139);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder25.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1854 */
  offset: 1854,
  bytesPerRow: 4864,
  buffer: buffer2,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 2},
  aspect: 'all',
}, new Uint8Array(47_163).fill(227), /* required buffer size: 47_163 */
{offset: 67, bytesPerRow: 116, rowsPerImage: 203}, {width: 1, height: 0, depthOrArrayLayers: 3});
} catch {}
try {
  await promise3;
} catch {}
let recycledExplicitBindGroupLayout4 = pipeline4.getBindGroupLayout(0);
let buffer24 = device0.createBuffer({
  size: 17493,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder26 = device0.createCommandEncoder();
let textureView16 = texture14.createView({dimension: 'cube-array', baseMipLevel: 0, arrayLayerCount: 6});
let computePassEncoder19 = commandEncoder26.beginComputePass();
let sampler19 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 69.75,
  compare: 'never',
});
try {
computePassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(3593), 165, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer8, 'uint32', 72, 522);
} catch {}
try {
commandEncoder25.clearBuffer(buffer4, 652, 408);
} catch {}
let recycledExplicitBindGroupLayout5 = pipeline0.getBindGroupLayout(0);
let bindGroup10 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [
    {binding: 263, resource: {buffer: buffer8, offset: 1792, size: 420}},
    {binding: 48, resource: {buffer: buffer8, offset: 256, size: 364}},
  ],
});
try {
computePassEncoder15.setBindGroup(0, bindGroup4, new Uint32Array(2861), 481, 0);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(1048), 40, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle3, renderBundle0]);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(5, buffer3, 0, 1_275);
} catch {}
try {
buffer23.unmap();
} catch {}
let bindGroup11 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [
    {binding: 263, resource: {buffer: buffer24, offset: 3840, size: 488}},
    {binding: 48, resource: {buffer: buffer24, offset: 2560, size: 4516}},
  ],
});
let commandBuffer0 = commandEncoder23.finish();
let texture19 = device0.createTexture({
  size: [1],
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder6.setBindGroup(2, bindGroup9);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer5, 0, 66);
} catch {}
let videoFrame2 = new VideoFrame(offscreenCanvas0, {timestamp: 0});
let texture20 = device0.createTexture({size: [3, 99, 1], mipLevelCount: 2, sampleCount: 1, format: 'rg8unorm', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder20 = commandEncoder25.beginComputePass({});
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer16, 0, 8_156);
} catch {}
try {
buffer3.unmap();
} catch {}
await gc();
try {
computePassEncoder2.setBindGroup(0, bindGroup0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer7, 392); };
} catch {}
try {
computePassEncoder20.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(3, buffer16, 0, 3_237);
} catch {}
try {
device0.queue.writeBuffer(buffer21, 4124, new BigUint64Array(18696), 296, 252);
} catch {}
let commandEncoder27 = device0.createCommandEncoder({});
try {
computePassEncoder2.setBindGroup(0, bindGroup2, new Uint32Array(893), 166, 0);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer13);
} catch {}
try {
commandEncoder27.copyTextureToTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture12,
  mipLevel: 0,
  origin: {x: 90, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer25 = device0.createBuffer({size: 8241, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder28 = device0.createCommandEncoder({});
let renderPassEncoder7 = commandEncoder27.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  depthSlice: 0,
  clearValue: { r: -33.24, g: -211.2, b: 981.7, a: 186.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 54621674,
});
let sampler20 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 41.91,
  maxAnisotropy: 1,
});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer7, 84); };
} catch {}
try {
computePassEncoder18.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup5, new Uint32Array(2036), 379, 0);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(2, buffer9, 1_236, 315);
} catch {}
let textureView17 = texture19.createView({});
let computePassEncoder21 = commandEncoder28.beginComputePass({});
try {
computePassEncoder21.setBindGroup(3, bindGroup7);
} catch {}
try {
computePassEncoder11.setBindGroup(0, bindGroup5, new Uint32Array(1397), 52, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer1, 1_224); };
} catch {}
let commandEncoder29 = device0.createCommandEncoder();
let renderPassEncoder8 = commandEncoder29.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  depthSlice: 0,
  clearValue: { r: 352.2, g: 160.6, b: -813.4, a: 89.01, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet3,
});
let sampler21 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 1,
});
try {
computePassEncoder10.setBindGroup(0, bindGroup9);
} catch {}
try {
computePassEncoder3.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 0,
  origin: {x: 0, y: 24, z: 0},
  aspect: 'all',
}, new Uint8Array(178).fill(211), /* required buffer size: 178 */
{offset: 178, bytesPerRow: 60}, {width: 0, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder20.setBindGroup(0, bindGroup5, new Uint32Array(2187), 1_105, 0);
} catch {}
try {
computePassEncoder14.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup5, []);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup1, new Uint32Array(712), 11, 0);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer16, 'uint32', 4_308, 7_572);
} catch {}
let recycledExplicitBindGroupLayout6 = pipeline1.getBindGroupLayout(0);
let textureView18 = texture2.createView({format: 'rg8sint', arrayLayerCount: 1});
try {
computePassEncoder19.setBindGroup(0, bindGroup9, new Uint32Array(2549), 15, 0);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer6, 'uint32', 100, 32);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer17, 1_032);
} catch {}
let buffer26 = device0.createBuffer({size: 28600, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView19 = texture10.createView({dimension: 'cube', format: 'rg8sint', arrayLayerCount: 6});
try {
renderPassEncoder7.setScissorRect(0, 28, 0, 3);
} catch {}
try {
renderPassEncoder2.setViewport(38.57970999260159, 0.7076943080093556, 87.64983230088411, 0.22739084474716317, 0.08201650738065802, 0.3405725038410403);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer8, 'uint32', 504, 1_030);
} catch {}
let pipeline5 = await promise1;
try {
  await promise0;
} catch {}
try {
globalThis.someLabel = externalTexture0.label;
} catch {}
let commandEncoder30 = device0.createCommandEncoder({});
let computePassEncoder22 = commandEncoder30.beginComputePass({});
try {
computePassEncoder22.setBindGroup(3, bindGroup3);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup5, new Uint32Array(49), 20, 0);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle2, renderBundle2, renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer16, 3_592, 2_680);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let textureView20 = texture3.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
let texture21 = device0.createTexture({
  size: {width: 15, height: 10, depthOrArrayLayers: 1},
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup2);
} catch {}
try {
buffer23.unmap();
} catch {}
let commandEncoder31 = device0.createCommandEncoder();
let computePassEncoder23 = commandEncoder31.beginComputePass({});
let sampler22 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat'});
try {
renderPassEncoder4.setBindGroup(1, bindGroup9, new Uint32Array(776), 5, 0);
} catch {}
try {
renderPassEncoder8.setBlendConstant({ r: -562.5, g: -504.2, b: 146.7, a: 733.0, });
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer2, 'uint32', 516, 284);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer13);
} catch {}
let texture22 = device0.createTexture({
  size: {width: 120, height: 48, depthOrArrayLayers: 44},
  dimension: '2d',
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler23 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.17,
  maxAnisotropy: 3,
});
let externalTexture3 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder22.setPipeline(pipeline3);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
try {
  await promise4;
} catch {}
let recycledExplicitBindGroupLayout7 = pipeline5.getBindGroupLayout(0);
let texture23 = device0.createTexture({
  size: [1, 49, 415],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView21 = texture16.createView({});
let externalTexture4 = device0.importExternalTexture({source: videoFrame2});
try {
computePassEncoder3.setBindGroup(0, bindGroup4, new Uint32Array(355), 30, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer16);
} catch {}
try {
computePassEncoder3.pushDebugGroup('\u0be6');
} catch {}
let buffer27 = device0.createBuffer({
  size: 11025,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let commandEncoder32 = device0.createCommandEncoder({});
try {
computePassEncoder13.setBindGroup(0, bindGroup9, new Uint32Array(538), 39, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup0, new Uint32Array(526), 71, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer20, 'uint16', 4_434, 3_926);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
commandEncoder32.copyBufferToBuffer(buffer6, 196, buffer4, 100, 0);
} catch {}
try {
commandEncoder32.copyBufferToTexture({
  /* bytesInLastRow: 34 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1956 */
  offset: 1956,
  bytesPerRow: 6912,
  buffer: buffer20,
}, {
  texture: texture12,
  mipLevel: 0,
  origin: {x: 108, y: 0, z: 0},
  aspect: 'all',
}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout7]});
let computePassEncoder24 = commandEncoder32.beginComputePass({});
try {
computePassEncoder19.setBindGroup(3, bindGroup11);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer13, 'uint32', 1_888, 600);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer3);
} catch {}
let pipeline6 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment2',
  constants: {},
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 364,
        attributes: [
          {format: 'uint16x4', offset: 72, shaderLocation: 6},
          {format: 'sint32x3', offset: 100, shaderLocation: 11},
          {format: 'float16x4', offset: 120, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', unclippedDepth: true},
});
let recycledExplicitBindGroupLayout8 = pipeline4.getBindGroupLayout(0);
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout0]});
let commandEncoder33 = device0.createCommandEncoder({});
let texture24 = device0.createTexture({
  size: {width: 3},
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder25 = commandEncoder33.beginComputePass({});
try {
renderPassEncoder2.executeBundles([renderBundle2, renderBundle2]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer5, 'uint16', 14, 428);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer12);
} catch {}
let recycledExplicitBindGroupLayout9 = pipeline6.getBindGroupLayout(0);
let buffer28 = device0.createBuffer({
  size: 4004,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder7.setBindGroup(0, bindGroup1);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
buffer6.unmap();
} catch {}
try {
  await buffer21.mapAsync(GPUMapMode.READ, 0, 440);
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [
    {binding: 263, resource: {buffer: buffer8, offset: 768, size: 4}},
    {binding: 48, resource: {buffer: buffer24, offset: 1024, size: 2280}},
  ],
});
let commandEncoder34 = device0.createCommandEncoder({});
let computePassEncoder26 = commandEncoder34.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer28, 2_024);
} catch {}
let recycledExplicitBindGroupLayout10 = pipeline0.getBindGroupLayout(0);
let commandEncoder35 = device0.createCommandEncoder({});
let textureView22 = texture14.createView({dimension: 'cube', format: 'rg8sint', baseArrayLayer: 1});
let computePassEncoder27 = commandEncoder35.beginComputePass({});
try {
computePassEncoder16.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup5, new Uint32Array(148), 9, 0);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer3, 336);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer1, 208);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer13, 'uint16', 854, 1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer9, 896, 543);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer16, 376);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer7, 120, 83);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder16.setBindGroup(0, bindGroup1, new Uint32Array(692), 99, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(3857), 2_509, 0);
} catch {}
try {
renderPassEncoder3.draw(6, 38, 0, 221_241_575);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer2, 488);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer26, 'uint32', 5_512, 3_442);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer28);
} catch {}
try {
buffer28.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
let recycledExplicitBindGroupLayout11 = pipeline2.getBindGroupLayout(0);
let sampler24 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.35,
  maxAnisotropy: 16,
});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer2, 'uint16', 244, 359);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline5);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup13 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [
    {binding: 48, resource: {buffer: buffer24, offset: 3584, size: 1648}},
    {binding: 263, resource: {buffer: buffer26, offset: 24576}},
  ],
});
let commandEncoder36 = device0.createCommandEncoder({});
let computePassEncoder28 = commandEncoder36.beginComputePass({});
try {
renderPassEncoder3.draw(0, 127, 1, 602_182_415);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer24, 900);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer2, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let externalTexture5 = device0.importExternalTexture({source: videoFrame1});
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder3.draw(5, 50, 0, 2_526_542_861);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer7, 'uint32', 192, 427);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(5, buffer5, 0, 859);
} catch {}
let commandEncoder37 = device0.createCommandEncoder({});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthStencilFormat: 'depth16unorm', depthReadOnly: true});
let renderBundle4 = renderBundleEncoder4.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer23, 716); };
} catch {}
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer7, 'uint32', 44, 118);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(7, buffer3, 216, 505);
} catch {}
let buffer29 = device0.createBuffer({
  size: 17488,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
try {
computePassEncoder20.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder1.setBindGroup(0, bindGroup7, new Uint32Array(1436), 761, 0);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup3, new Uint32Array(523), 37, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder2.setViewport(149.96662599195017, 0.591508223563852, 61.99114723602545, 0.02932543523494381, 0.9344805005103913, 0.935544405262984);
} catch {}
try {
commandEncoder19.clearBuffer(buffer8, 396, 868);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 16},
  aspect: 'all',
}, new Uint8Array(32_432).fill(145), /* required buffer size: 32_432 */
{offset: 42, bytesPerRow: 24, rowsPerImage: 21}, {width: 7, height: 6, depthOrArrayLayers: 65});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
adapter0.label = '\u0d37\uefbe\u0da5\u0def\u{1f6ec}\u4b18';
} catch {}
try {
globalThis.someLabel = computePassEncoder19.label;
} catch {}
let buffer30 = device0.createBuffer({size: 28761, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let texture25 = device0.createTexture({size: [15, 10, 23], format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
let textureView23 = texture9.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 23});
try {
computePassEncoder10.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder28.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline5);
} catch {}
let buffer31 = device0.createBuffer({
  size: 2404,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture26 = device0.createTexture({
  size: {width: 2920, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder29 = commandEncoder37.beginComputePass({});
try {
renderPassEncoder6.setBindGroup(3, bindGroup3, new Uint32Array(5577), 526, 0);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: -631.2, g: 517.2, b: -68.09, a: 410.4, });
} catch {}
try {
renderPassEncoder8.setScissorRect(0, 14, 0, 17);
} catch {}
try {
renderPassEncoder5.setViewport(1.6145600530515534, 52.61921473151131, 1.0985234128568213, 44.22135124209658, 0.84700782426366, 0.9861322359282021);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer5, 8, 406);
} catch {}
try {
buffer31.unmap();
} catch {}
try {
commandEncoder19.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2960 */
  offset: 2960,
  bytesPerRow: 13824,
  buffer: buffer0,
}, {
  texture: texture8,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 39,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {binding: 47, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 111,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 118, visibility: 0, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let bindGroup14 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout11,
  entries: [
    {binding: 48, resource: {buffer: buffer24, offset: 256, size: 2524}},
    {binding: 263, resource: {buffer: buffer13, offset: 1536}},
  ],
});
let commandEncoder38 = device0.createCommandEncoder({});
let computePassEncoder30 = commandEncoder38.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer28, 60); };
} catch {}
try {
renderPassEncoder6.draw(0, 208, 0, 531_416_428);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(5, buffer31, 0, 253);
} catch {}
try {
commandEncoder19.copyBufferToBuffer(buffer1, 996, buffer21, 2008, 576);
} catch {}
try {
commandEncoder19.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1800 */
  offset: 1800,
  bytesPerRow: 2560,
  buffer: buffer16,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer8, 1332, new DataView(new ArrayBuffer(5612)), 229, 432);
} catch {}
let commandEncoder39 = device0.createCommandEncoder({});
let texture27 = device0.createTexture({
  size: {width: 120, height: 48, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder14.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup4, new Uint32Array(2081), 365, 0);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -359.3, g: 191.0, b: 826.1, a: -190.0, });
} catch {}
try {
renderPassEncoder6.draw(4, 3, 5, 985_156_644);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint32', 2_808, 1_871);
} catch {}
try {
commandEncoder39.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1048 */
  offset: 1048,
  bytesPerRow: 41984,
  buffer: buffer3,
}, {width: 15, height: 1, depthOrArrayLayers: 0});
} catch {}
let textureView24 = texture10.createView({label: '\u6fc3\u{1f66c}\ud6c7\u8234', format: 'rg8sint', arrayLayerCount: 2});
let computePassEncoder31 = commandEncoder39.beginComputePass({});
let renderPassEncoder9 = commandEncoder19.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -322.2, g: 578.3, b: 829.0, a: 398.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder6.setBindGroup(0, bindGroup5, new Uint32Array(2041), 393, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup9, new Uint32Array(2568), 521, 0);
} catch {}
try {
renderPassEncoder5.setViewport(0.026259137128859633, 72.88741606625643, 2.1285105430582387, 0.23371826326921832, 0.2982251980355509, 0.37105465073567073);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer23, 108);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer3, 456);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
buffer3.unmap();
} catch {}
let textureView25 = texture14.createView({dimension: 'cube-array', aspect: 'all', arrayLayerCount: 6});
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer8, 24); };
} catch {}
try {
computePassEncoder31.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.draw(0, 55, 0, 441_475_119);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer2, 572);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(5, buffer9, 1_716);
} catch {}
try {
buffer13.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer4, 640, new DataView(new ArrayBuffer(3549)), 1098, 480);
} catch {}
let sampler25 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 73.64,
  lodMaxClamp: 95.66,
  compare: 'greater',
  maxAnisotropy: 13,
});
try {
renderPassEncoder6.draw(0, 61, 0, 281_793_095);
} catch {}
try {
renderPassEncoder6.drawIndexed(2, 46, 15, -2_007_715_509, 85_760_388);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer16, 3_332);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer7, 'uint16', 428, 165);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
} catch {}
let autogeneratedBindGroupLayout0 = pipeline3.getBindGroupLayout(0);
try {
renderPassEncoder2.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder6.end();
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer27, 5_020);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(5, buffer22);
} catch {}
let promise5 = shaderModule0.getCompilationInfo();
try {
  await promise5;
} catch {}
try {
computePassEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(446), 147, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup5, new Uint32Array(424), 88, 0);
} catch {}
try {
renderPassEncoder1.end();
} catch {}
try {
buffer22.unmap();
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1544 */
  offset: 1544,
  buffer: buffer0,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 2},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder14.clearBuffer(buffer3);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 948, new DataView(new ArrayBuffer(598)), 117, 68);
} catch {}
let buffer32 = device0.createBuffer({
  size: 14829,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder40 = device0.createCommandEncoder({});
let texture28 = device0.createTexture({
  size: {width: 60, height: 40, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  sampleCount: 1,
  dimension: '2d',
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder10 = commandEncoder40.beginRenderPass({
  colorAttachments: [{
  view: textureView18,
  clearValue: { r: -627.7, g: 161.8, b: 129.8, a: 266.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 136692558,
});
try {
computePassEncoder20.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(4, undefined, 0, 632_341_009);
} catch {}
try {
commandEncoder14.clearBuffer(buffer24, 2644, 84);
} catch {}
let recycledExplicitBindGroupLayout12 = pipeline6.getBindGroupLayout(0);
let bindGroup15 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 263, resource: {buffer: buffer8, offset: 0, size: 568}},
    {binding: 48, resource: {buffer: buffer12, offset: 3584, size: 192}},
  ],
});
let buffer33 = device0.createBuffer({size: 10067, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder41 = device0.createCommandEncoder({});
let texture29 = device0.createTexture({size: [16], dimension: '1d', format: 'rg8unorm', usage: GPUTextureUsage.COPY_DST});
let computePassEncoder32 = commandEncoder41.beginComputePass({});
try {
computePassEncoder13.setBindGroup(0, bindGroup11, new Uint32Array(1873), 403, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer26, 'uint16', 1_656, 7_054);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(7, buffer22, 32, 189);
} catch {}
let arrayBuffer0 = buffer21.getMappedRange(216, 44);
try {
buffer28.unmap();
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 56,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 227,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup16 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 48, resource: {buffer: buffer1, offset: 3072, size: 572}},
    {binding: 263, resource: {buffer: buffer7, offset: 256}},
  ],
});
let commandEncoder42 = device0.createCommandEncoder({});
let computePassEncoder33 = commandEncoder24.beginComputePass({});
try {
computePassEncoder33.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
await gc();
let textureView26 = texture21.createView({dimension: '2d-array', aspect: 'all'});
let computePassEncoder34 = commandEncoder42.beginComputePass();
try {
computePassEncoder32.setPipeline(pipeline0);
} catch {}
try {
buffer28.unmap();
} catch {}
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 56,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 227,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let recycledExplicitBindGroupLayout13 = pipeline0.getBindGroupLayout(0);
let buffer34 = device0.createBuffer({
  size: 4404,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder43 = device0.createCommandEncoder({});
let commandBuffer1 = commandEncoder14.finish();
let texture30 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder30.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer17, 2_480);
} catch {}
try {
computePassEncoder3.popDebugGroup();
} catch {}
let commandEncoder44 = device0.createCommandEncoder({});
let commandBuffer2 = commandEncoder43.finish();
let texture31 = device0.createTexture({size: [3, 99, 1], sampleCount: 4, format: 'rg8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let computePassEncoder35 = commandEncoder44.beginComputePass();
try {
computePassEncoder29.setPipeline(pipeline0);
} catch {}
let commandEncoder45 = device0.createCommandEncoder({});
let computePassEncoder36 = commandEncoder45.beginComputePass({});
try {
computePassEncoder26.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup4, new Uint32Array(1138), 203, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer20, 'uint32', 1_532, 2_890);
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
let bindGroup17 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout4,
  entries: [
    {binding: 48, resource: {buffer: buffer26, offset: 7680}},
    {binding: 263, resource: {buffer: buffer30, offset: 1024, size: 7056}},
  ],
});
let commandEncoder46 = device0.createCommandEncoder({});
let renderPassEncoder11 = commandEncoder46.beginRenderPass({
  colorAttachments: [{
  view: textureView18,
  clearValue: { r: -54.75, g: -429.5, b: -718.0, a: 398.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 182314442,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup2);
} catch {}
try {
computePassEncoder11.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup5);
} catch {}
let commandEncoder47 = device0.createCommandEncoder({});
let textureView27 = texture1.createView({dimension: '2d-array'});
let computePassEncoder37 = commandEncoder47.beginComputePass({});
let sampler26 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 76.56});
try {
computePassEncoder13.setBindGroup(0, bindGroup2);
} catch {}
try {
computePassEncoder37.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup2, new Uint32Array(1616), 217, 0);
} catch {}
try {
renderPassEncoder2.insertDebugMarker('\u9233');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(98_221).fill(67), /* required buffer size: 98_221 */
{offset: 328, bytesPerRow: 149, rowsPerImage: 219}, {width: 40, height: 0, depthOrArrayLayers: 4});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer35 = device0.createBuffer({size: 3459, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let commandEncoder48 = device0.createCommandEncoder({});
let texture32 = device0.createTexture({
  size: [3, 99, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder12 = commandEncoder48.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: 561.2, g: 793.1, b: 30.29, a: -360.7, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder28.setBindGroup(0, bindGroup12);
} catch {}
try {
computePassEncoder7.end();
} catch {}
try {
renderPassEncoder5.setScissorRect(0, 12, 0, 3);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer28, 'uint16', 116, 1_708);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
commandEncoder7.copyBufferToBuffer(buffer24, 3768, buffer34, 120, 552);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let computePassEncoder38 = commandEncoder7.beginComputePass({});
try {
computePassEncoder15.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder37.setBindGroup(0, bindGroup9, new Uint32Array(1271), 985, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer24, 2_328); };
} catch {}
try {
computePassEncoder38.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup2);
} catch {}
try {
commandEncoder13.label = '\u0787\ub57d\u{1f62d}\u6b44\u5bca\u670c\udb62';
} catch {}
let commandEncoder49 = device0.createCommandEncoder();
let textureView28 = texture12.createView({dimension: '2d', format: 'rg8sint', baseArrayLayer: 0});
let textureView29 = texture4.createView({aspect: 'all', baseMipLevel: 0, arrayLayerCount: 1});
let computePassEncoder39 = commandEncoder49.beginComputePass({});
try {
computePassEncoder19.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle0, renderBundle3, renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: -476.1, g: -540.3, b: 956.0, a: 276.5, });
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer16, 'uint32', 1_248, 3_124);
} catch {}
try {
buffer8.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer24, 32, new Float32Array(454), 124, 8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(113).fill(22), /* required buffer size: 113 */
{offset: 113, bytesPerRow: 224}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup18 = device0.createBindGroup({
  label: '\u1a0f\u3e4c\u7253\u146d',
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 263, resource: {buffer: buffer13, offset: 512}}],
});
let buffer36 = device0.createBuffer({
  size: 16989,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let texture33 = device0.createTexture({
  size: {width: 60, height: 40, depthOrArrayLayers: 1},
  sampleCount: 1,
  dimension: '2d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm', 'rg8unorm'],
});
try {
renderPassEncoder2.setIndexBuffer(buffer12, 'uint16', 3_236, 1_811);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let buffer37 = device0.createBuffer({size: 9107, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder50 = device0.createCommandEncoder({});
let computePassEncoder40 = commandEncoder50.beginComputePass({});
try {
renderPassEncoder8.setBindGroup(0, bindGroup8, new Uint32Array(843), 100, 0);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 263,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
try {
computePassEncoder24.setBindGroup(0, bindGroup15, []);
} catch {}
try {
computePassEncoder8.end();
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder7.setStencilReference(371);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer34, 'uint32', 3_272, 49);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let pipeline7 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}});
let bindGroup19 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [
    {binding: 48, resource: {buffer: buffer13, offset: 1280, size: 372}},
    {binding: 263, resource: {buffer: buffer8, offset: 2304, size: 400}},
  ],
});
let commandBuffer3 = commandEncoder9.finish();
let texture34 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 12},
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView30 = texture20.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder0.setScissorRect(0, 51, 1, 13);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(208).fill(209), /* required buffer size: 208 */
{offset: 208}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView31 = texture18.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer17, 1_628); };
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup5, new Uint32Array(829), 202, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer33, 'uint32', 5_432, 618);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer31, 0, 69);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let arrayBuffer1 = buffer21.getMappedRange(264, 16);
try {
device0.queue.writeBuffer(buffer1, 580, new BigUint64Array(7333), 1513, 52);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
await gc();
let commandEncoder51 = device0.createCommandEncoder({});
let externalTexture6 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder19.setBindGroup(0, bindGroup4, new Uint32Array(1165), 54, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer31, 'uint16', 560, 15);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer12);
} catch {}
try {
commandEncoder51.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5398 */
  offset: 5398,
  buffer: buffer33,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture35 = device0.createTexture({
  size: [60, 40, 1],
  sampleCount: 1,
  dimension: '2d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView32 = texture28.createView({mipLevelCount: 1});
let renderPassEncoder13 = commandEncoder51.beginRenderPass({
  colorAttachments: [{
  view: textureView32,
  clearValue: { r: 398.0, g: 379.2, b: -107.2, a: -499.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder24.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup2, new Uint32Array(1187), 832, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle1, renderBundle1, renderBundle0, renderBundle0, renderBundle1]);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let texture36 = device0.createTexture({
  size: {width: 1, height: 49, depthOrArrayLayers: 1},
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder34.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup12, new Uint32Array(1371), 32, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer7, 'uint16', 298, 123);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(4, buffer28);
} catch {}
try {
  await shaderModule2.getCompilationInfo();
} catch {}
try {
device0.queue.writeBuffer(buffer8, 364, new BigUint64Array(11815), 7827, 44);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture37 = device0.createTexture({
  size: [15, 10, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '2d',
  format: 'rg32sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler27 = device0.createSampler({
  label: '\u4e51\u3bd8\u0186\u8913\u4bf8\u5c23\u320c\ua032\u252b\u49d2\u36a2',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
});
try {
computePassEncoder35.setPipeline(pipeline2);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [
    {binding: 48, resource: {buffer: buffer4, offset: 768, size: 1020}},
    {binding: 263, resource: {buffer: buffer12, offset: 2048, size: 692}},
  ],
});
let textureView33 = texture27.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder12.setBindGroup(0, bindGroup20);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline7);
} catch {}
try {
buffer8.unmap();
} catch {}
try {
  await promise7;
} catch {}
let recycledExplicitBindGroupLayout14 = pipeline0.getBindGroupLayout(0);
let buffer38 = device0.createBuffer({size: 8641, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder52 = device0.createCommandEncoder({});
let textureView34 = texture3.createView({});
let computePassEncoder41 = commandEncoder52.beginComputePass({});
let sampler28 = device0.createSampler({minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 94.29, compare: 'not-equal'});
try {
computePassEncoder24.setBindGroup(1, bindGroup9, new Uint32Array(1306), 588, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(3, buffer13);
} catch {}
try {
  await buffer0.mapAsync(GPUMapMode.WRITE, 120, 672);
} catch {}
try {
adapter0.label = '\u03a3\u099e\u0d0e\ua046';
} catch {}
let autogeneratedBindGroupLayout1 = pipeline3.getBindGroupLayout(0);
let commandEncoder53 = device0.createCommandEncoder({});
let texture38 = device0.createTexture({
  size: {width: 1},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder42 = commandEncoder53.beginComputePass({label: '\u147f\u79af\u4c5e\u60c1\u7600\u1597\u7686'});
let sampler29 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  lodMaxClamp: 95.41,
});
let externalTexture7 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder9.setBindGroup(0, bindGroup2, new Uint32Array(660), 138, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup9, new Uint32Array(761), 34, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer9, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'film', transfer: 'bt2020_12bit'} });
let buffer39 = device0.createBuffer({size: 7580, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder54 = device0.createCommandEncoder();
let computePassEncoder43 = commandEncoder54.beginComputePass({});
try {
computePassEncoder12.setBindGroup(0, bindGroup3);
} catch {}
try {
computePassEncoder31.setBindGroup(0, bindGroup20, new Uint32Array(714), 256, 0);
} catch {}
try {
computePassEncoder43.setPipeline(pipeline3);
} catch {}
let bindGroup21 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 263, resource: {buffer: buffer8, offset: 256, size: 208}},
    {binding: 48, resource: {buffer: buffer7, offset: 256, size: 248}},
  ],
});
let commandEncoder55 = device0.createCommandEncoder({});
let texture39 = device0.createTexture({
  size: {width: 365, height: 1, depthOrArrayLayers: 1},
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder40.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer27, 'uint16', 894, 4_976);
} catch {}
let pipeline8 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule0,
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 368,
        attributes: [
          {format: 'uint32x3', offset: 60, shaderLocation: 6},
          {format: 'sint8x4', offset: 76, shaderLocation: 11},
          {format: 'unorm8x2', offset: 40, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'back', unclippedDepth: true},
});
let shaderModule3 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

diagnostic(info, xyz);

enable f16;

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

@group(0) @binding(167) var tex0: texture_2d<f32>;

struct FragmentOutput4 {
  @location(5) f0: f32,
  @location(0) @interpolate(flat, centroid) f1: vec2i,
}

var<private> vp4: mat3x3f = mat3x3f(0.00225, 0.1436, 0.3725, 0.1232, 0.3545, 0.1057, 0.3810, 0.1122, 0.09724);

struct VertexOutput3 {
  @location(11) @interpolate(perspective) f8: vec4h,
  @builtin(position) f9: vec4f,
  @location(1) f10: i32,
}

@group(0) @binding(235) var tex1: texture_2d<f32>;

var<workgroup> vw5: atomic<i32>;

struct T0 {
  @align(16) @size(256) f0: array<mat4x2f, 1>,
  @align(8) @size(432) f1: array<u32>,
}

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

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

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

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

alias vec3b = vec3<bool>;

@vertex
fn vertex3(@location(11) @interpolate(linear) a0: vec4f, @location(1) a1: u32) -> VertexOutput3 {
  var out: VertexOutput3;
  vp4 += mat3x3f(f32(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))), f32(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))), f32(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))), bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))), f32(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))), f32(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))), bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))), bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))), f32(pack2x16snorm(vec2f(unconst_f32(0.01032), unconst_f32(0.1031)))));
  var vf35: u32 = textureNumLevels(tex1);
  let vf36: i32 = reverseBits(bitcast<vec2i>(ceil(vec2f(unconst_f32(0.1236), unconst_f32(0.00809))))[1]);
  let vf37: vec2f = acos(vec2f(unconst_f32(0.3103), unconst_f32(0.02709)));
  out.f10 = i32(vf37.y);
  let vf38: vec3f = vp4[bitcast<u32>(vf36)];
  out.f10 |= i32(degrees(vec4h(unconst_f16(11049.8), unconst_f16(2910.4), unconst_f16(19366.3), unconst_f16(12830.9))).g);
  out.f9 = vf38.gbrr;
  var vf39: f32 = vf38[bitcast<u32>(vf38[u32(unconst_u32(67))])];
  var vf40: vec2f = acos(vec2f(unconst_f32(-0.4695), unconst_f32(0.2634)));
  let vf41: u32 = pack2x16unorm(vec2f(unconst_f32(0.3250), unconst_f32(0.04669)));
  let ptr66: ptr<function, vec2f> = &vf40;
  return out;
  _ = tex1;
}

@fragment
fn fragment4() -> FragmentOutput4 {
  var out: FragmentOutput4;
  let vf42: f32 = vp4[u32(unconst_u32(742))][u32(unconst_u32(69))];
  out = FragmentOutput4(unpack4x8snorm(bitcast<vec2u>(transpose(mat2x2f(unconst_f32(0.1427), unconst_f32(0.02120), unconst_f32(0.4375), unconst_f32(0.1160)))[unconst_i32(1)]).g).r, bitcast<vec2i>(unpack4x8snorm(bitcast<vec2u>(transpose(mat2x2f(unconst_f32(0.1427), unconst_f32(0.02120), unconst_f32(0.4375), unconst_f32(0.1160)))[unconst_i32(1)]).g).ra));
  out.f1 += select(vec4i(transpose(mat2x2f(unconst_f32(0.1536), unconst_f32(0.03690), unconst_f32(0.1293), unconst_f32(0.3351)))[unconst_i32(0)].xyyy), abs(vec2i(unconst_i32(-103), unconst_i32(172))).yyxx, vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true), unconst_bool(false))).aa;
  vp4 -= mat3x3f(unpack4x8snorm(u32(unconst_u32(170))).www, unpack4x8snorm(u32(unconst_u32(170))).agr, unpack4x8snorm(u32(unconst_u32(170))).zyy);
  var vf43: vec4i = select(vec4i(unconst_i32(108), unconst_i32(40), unconst_i32(693), unconst_i32(27)), vec4i(unconst_i32(59), unconst_i32(67), unconst_i32(117), unconst_i32(75)), vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false), unconst_bool(false)));
  vf43 = abs(select(vec4i(unconst_i32(450), unconst_i32(95), unconst_i32(80), unconst_i32(70)), vec4i(unconst_i32(268), unconst_i32(45), unconst_i32(66), unconst_i32(209)), vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(false))).wz).gggg;
  var vf44: vec3f = vp4[bitcast<u32>(unpack4x8snorm(u32(unconst_u32(74)))[0])];
  vf43 = vec4i(vf44.zyyy);
  vp4 += mat3x3f(bitcast<vec3f>(select(vec4i(unconst_i32(49), unconst_i32(411), unconst_i32(87), unconst_i32(37)), vec4i(unconst_i32(273), unconst_i32(143), unconst_i32(135), unconst_i32(-213)), vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true))).abg), vec3f(select(vec4i(unconst_i32(49), unconst_i32(411), unconst_i32(87), unconst_i32(37)), vec4i(unconst_i32(273), unconst_i32(143), unconst_i32(135), unconst_i32(-213)), vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true))).rrb), vec3f(select(vec4i(unconst_i32(49), unconst_i32(411), unconst_i32(87), unconst_i32(37)), vec4i(unconst_i32(273), unconst_i32(143), unconst_i32(135), unconst_i32(-213)), vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true))).raa));
  vf43 = vec4i(i32(length(f16(unconst_f16(-15264.5)))));
  let ptr67: ptr<function, vec4i> = &vf43;
  var vf45: vec4f = unpack4x8snorm(u32(unconst_u32(253)));
  return out;
}

@compute @workgroup_size(2, 1, 1)
fn compute4() {
  let vf46: u32 = textureNumLevels(tex1);
  _ = tex1;
}

@compute @workgroup_size(2, 1, 1)
fn compute5() {
  atomicXor(&vw5, i32(unconst_i32(947)));
  atomicOr(&vw5, i32(unconst_i32(113)));
  atomicSub(&vw5, i32(unconst_i32(46)));
  vp4 += mat3x3f(vec3f(pow(vec3h(unconst_f16(16815.6), unconst_f16(16398.0), unconst_f16(8046.4)), vec3h(unconst_f16(1643.7), unconst_f16(7550.2), unconst_f16(7278.9)))), vec3f(pow(vec3h(unconst_f16(16815.6), unconst_f16(16398.0), unconst_f16(8046.4)), vec3h(unconst_f16(1643.7), unconst_f16(7550.2), unconst_f16(7278.9)))), vec3f(pow(vec3h(unconst_f16(16815.6), unconst_f16(16398.0), unconst_f16(8046.4)), vec3h(unconst_f16(1643.7), unconst_f16(7550.2), unconst_f16(7278.9)))));
  vp4 = mat3x3f(bitcast<f32>(atomicExchange(&(*&vw5), i32(unconst_i32(565)))), f32(atomicExchange(&(*&vw5), i32(unconst_i32(565)))), f32(atomicExchange(&(*&vw5), i32(unconst_i32(565)))), bitcast<f32>(atomicExchange(&(*&vw5), i32(unconst_i32(565)))), f32(atomicExchange(&(*&vw5), i32(unconst_i32(565)))), f32(atomicExchange(&(*&vw5), i32(unconst_i32(565)))), bitcast<f32>(atomicExchange(&(*&vw5), i32(unconst_i32(565)))), bitcast<f32>(atomicExchange(&(*&vw5), i32(unconst_i32(565)))), bitcast<f32>(atomicExchange(&(*&vw5), i32(unconst_i32(565)))));
  var vf47: i32 = atomicExchange(&vw5, i32(unconst_i32(92)));
  vf47 = i32(textureNumLevels(tex1));
  let vf48: u32 = pack4xI8(vec4i(i32(vp4[u32(unconst_u32(448))][u32(unconst_u32(13))])));
  let ptr68: ptr<function, i32> = &vf47;
  let vf49: vec3f = atan(vec3f(unconst_f32(0.2768), unconst_f32(0.8818), unconst_f32(0.2320)));
  var vf50: vec2u = textureDimensions(tex1);
  let vf51: u32 = pack4xI8(vec4i(unconst_i32(202), unconst_i32(535), unconst_i32(26), unconst_i32(53)));
  atomicCompareExchangeWeak(&vw5, unconst_i32(61), unconst_i32(29));
  let vf52: vec2f = saturate(unpack2x16float(textureNumLevels(tex0)));
  vf50 |= vec2u(u32(vf49[u32(unconst_u32(78))]));
  vf47 = vec2i(textureDimensions(tex1, i32(unconst_i32(74)))).x;
  vf50 |= bitcast<vec2u>(vp4[u32(unconst_u32(469))].gg);
  var vf53: vec4f = textureLoad(tex0, vec2i(unconst_i32(384), unconst_i32(173)), i32(unconst_i32(252)));
  atomicXor(&vw5, i32(unconst_i32(266)));
  _ = tex1;
  _ = tex0;
}`,
});
let buffer40 = device0.createBuffer({
  size: 6446,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder56 = device0.createCommandEncoder({label: '\u{1f9fe}\u759f'});
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 677});
let textureView35 = texture32.createView({dimension: '2d-array'});
let computePassEncoder44 = commandEncoder55.beginComputePass({});
try {
computePassEncoder14.setBindGroup(2, bindGroup9);
} catch {}
try {
computePassEncoder13.setBindGroup(0, bindGroup4, new Uint32Array(307), 1, 0);
} catch {}
try {
computePassEncoder39.setPipeline(pipeline0);
} catch {}
try {
buffer16.unmap();
} catch {}
let commandEncoder57 = device0.createCommandEncoder({});
let externalTexture8 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'});
try {
computePassEncoder44.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup2, new Uint32Array(718), 74, 0);
} catch {}
try {
buffer39.unmap();
} catch {}
try {
commandEncoder57.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1340 */
  offset: 1340,
  bytesPerRow: 512,
  buffer: buffer24,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 15, y: 14, z: 0},
  aspect: 'all',
}, {width: 5, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(145).fill(125), /* required buffer size: 145 */
{offset: 145}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise8 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment2',
  constants: {},
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 12,
        attributes: [
          {format: 'float32x3', offset: 0, shaderLocation: 9},
          {format: 'sint32x2', offset: 0, shaderLocation: 11},
          {format: 'uint32', offset: 0, shaderLocation: 6},
        ],
      },
    ],
  },
});
let textureView36 = texture23.createView({});
let computePassEncoder45 = commandEncoder56.beginComputePass({});
try {
computePassEncoder20.setBindGroup(1, bindGroup19, []);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup1, new Uint32Array(1554), 461, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer34, 'uint32', 1_556, 646);
} catch {}
try {
commandEncoder57.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 508 */
  offset: 508,
  bytesPerRow: 19456,
  buffer: buffer33,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline9 = await promise8;
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise6;
} catch {}
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 314});
let textureView37 = texture1.createView({dimension: '2d-array', format: 'rg8sint', mipLevelCount: 1});
let sampler30 = device0.createSampler({
  label: '\u{1fadf}\u{1ff4b}\u8934\u{1f627}\u4982\uf02d\uac51\u{1fcd8}',
  addressModeW: 'repeat',
  lodMaxClamp: 74.67,
});
try {
computePassEncoder45.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup5, new Uint32Array(2046), 118, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer8, 'uint32', 2_584, 219);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline5);
} catch {}
let arrayBuffer2 = buffer0.getMappedRange(176, 56);
try {
buffer16.unmap();
} catch {}
let commandEncoder58 = device0.createCommandEncoder({});
let texture40 = device0.createTexture({
  size: [30, 20, 32],
  mipLevelCount: 1,
  format: 'rg16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture41 = device0.createTexture({
  size: {width: 30, height: 20, depthOrArrayLayers: 15},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let computePassEncoder46 = commandEncoder57.beginComputePass({});
let sampler31 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 78.11,
  maxAnisotropy: 16,
});
try {
computePassEncoder28.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder41.setBindGroup(2, bindGroup12, new Uint32Array(509), 240, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer5, 224); };
} catch {}
try {
computePassEncoder44.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder41.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup20, new Uint32Array(1284), 36, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer6, 'uint32', 100, 109);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline5);
} catch {}
try {
commandEncoder58.copyBufferToTexture({
  /* bytesInLastRow: 26 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 978 */
  offset: 978,
  bytesPerRow: 6656,
  buffer: buffer27,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 10, y: 1, z: 0},
  aspect: 'all',
}, {width: 13, height: 24, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer41 = device0.createBuffer({size: 1959, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder59 = device0.createCommandEncoder({});
let querySet7 = device0.createQuerySet({type: 'occlusion', count: 323});
let texture42 = device0.createTexture({
  size: [3, 99, 1],
  dimension: '2d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView38 = texture3.createView({dimension: '1d'});
let computePassEncoder47 = commandEncoder58.beginComputePass();
let renderPassEncoder14 = commandEncoder59.beginRenderPass({
  colorAttachments: [{
  view: textureView18,
  clearValue: { r: 981.5, g: 184.4, b: 985.0, a: -36.24, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder14.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder11.setViewport(180.73645023968336, 0.21103925579305816, 166.83830987771273, 0.012443942105900687, 0.7709695986022418, 0.919086547851007);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(3, buffer13, 804);
} catch {}
try {
device0.queue.writeBuffer(buffer36, 336, new Int16Array(9517), 136, 2800);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture43 = device0.createTexture({
  size: {width: 1460, height: 1, depthOrArrayLayers: 44},
  mipLevelCount: 3,
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture44 = device0.createTexture({
  size: [12, 396, 1],
  sampleCount: 4,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder12.setBindGroup(0, bindGroup10);
} catch {}
try {
computePassEncoder47.setBindGroup(0, bindGroup10, new Uint32Array(2308), 180, 0);
} catch {}
try {
computePassEncoder46.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle2, renderBundle2]);
} catch {}
let commandEncoder60 = device0.createCommandEncoder({});
let texture45 = device0.createTexture({
  size: {width: 1460, height: 1, depthOrArrayLayers: 1},
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder48 = commandEncoder60.beginComputePass();
try {
device0.queue.submit([commandBuffer3]);
} catch {}
let texture46 = device0.createTexture({
  size: [365, 1, 104],
  format: 'r32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture47 = device0.createTexture({
  size: {width: 15, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler32 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', mipmapFilter: 'linear'});
try {
computePassEncoder48.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(37);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle2]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 13},
  aspect: 'all',
}, new Uint8Array(907_120).fill(80), /* required buffer size: 907_120 */
{offset: 108, bytesPerRow: 196, rowsPerImage: 74}, {width: 60, height: 40, depthOrArrayLayers: 63});
} catch {}
let textureView39 = texture43.createView({dimension: '2d', mipLevelCount: 1});
let textureView40 = texture20.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder4.setBindGroup(0, bindGroup15, []);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer22, 'uint16', 236, 98);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder43.insertDebugMarker('\u0578');
} catch {}
let recycledExplicitBindGroupLayout15 = pipeline2.getBindGroupLayout(0);
let bindGroup22 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout4,
  entries: [
    {binding: 48, resource: {buffer: buffer7, offset: 0}},
    {binding: 263, resource: {buffer: buffer41, offset: 0, size: 292}},
  ],
});
let buffer42 = device0.createBuffer({
  size: 21264,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture48 = device0.createTexture({
  size: [120, 48, 1],
  sampleCount: 1,
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture49 = device0.createTexture({
  size: {width: 60},
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView41 = texture22.createView({dimension: '2d'});
try {
computePassEncoder47.setPipeline(pipeline7);
} catch {}
let commandEncoder61 = device0.createCommandEncoder();
let textureView42 = texture48.createView({mipLevelCount: 1});
let textureView43 = texture38.createView({format: 'rg8unorm'});
let renderPassEncoder15 = commandEncoder61.beginRenderPass({
  colorAttachments: [{
  view: textureView18,
  clearValue: { r: 562.2, g: -235.1, b: -648.6, a: -806.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 218435839,
});
try {
computePassEncoder24.setBindGroup(3, bindGroup2);
} catch {}
try {
computePassEncoder30.setBindGroup(0, bindGroup1, new Uint32Array(1315), 88, 0);
} catch {}
try {
renderPassEncoder13.setViewport(21.175590224139334, 15.140871118704528, 6.100790788073764, 17.41203018868719, 0.7817368231407547, 0.970036931519534);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let canvas0 = document.createElement('canvas');
let commandEncoder62 = device0.createCommandEncoder();
let texture50 = device0.createTexture({
  size: [120, 48, 1],
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder49 = commandEncoder62.beginComputePass();
try {
computePassEncoder19.setBindGroup(0, bindGroup19, new Uint32Array(7395), 358, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup8, new Uint32Array(1514), 1_096, 0);
} catch {}
try {
renderPassEncoder5.beginOcclusionQuery(53);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer12);
} catch {}
let bindGroup23 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 48, resource: {buffer: buffer26, offset: 0}},
    {binding: 263, resource: {buffer: buffer41, offset: 0, size: 472}},
  ],
});
let texture51 = device0.createTexture({
  size: [16, 16, 12],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder4.setIndexBuffer(buffer20, 'uint16', 27_644, 951);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, undefined, 0);
} catch {}
let arrayBuffer3 = buffer21.getMappedRange(280, 32);
document.body.prepend(canvas0);
let textureView44 = texture0.createView({aspect: 'depth-only', baseArrayLayer: 8, arrayLayerCount: 48});
let externalTexture9 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder21.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder13.end();
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer6, 'uint32', 320, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup3, new Uint32Array(105), 6, 0);
} catch {}
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 296 */
  offset: 296,
  bytesPerRow: 40960,
  rowsPerImage: 274,
  buffer: buffer38,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup24 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout9,
  entries: [
    {binding: 263, resource: {buffer: buffer1, offset: 3072, size: 536}},
    {binding: 48, resource: {buffer: buffer42, offset: 2048, size: 7648}},
  ],
});
let computePassEncoder50 = commandEncoder13.beginComputePass({});
try {
computePassEncoder42.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup2, new Uint32Array(887), 711, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer2);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup21);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer42, 'uint16', 5_786, 3_837);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline8);
} catch {}
let gpuCanvasContext1 = canvas0.getContext('webgpu');
let autogeneratedBindGroupLayout2 = pipeline7.getBindGroupLayout(0);
let buffer43 = device0.createBuffer({size: 10801, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView45 = texture45.createView({});
try {
computePassEncoder15.setBindGroup(0, bindGroup21);
} catch {}
try {
computePassEncoder47.setBindGroup(2, bindGroup19, new Uint32Array(798), 19, 0);
} catch {}
try {
computePassEncoder50.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(101);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup1, []);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(6, buffer5, 0, 103);
} catch {}
try {
  await buffer25.mapAsync(GPUMapMode.READ, 368, 1356);
} catch {}
let img0 = await imageWithData(60, 6, '#10101010', '#20202020');
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 39,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {binding: 47, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 111,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 118, visibility: 0, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout11]});
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroupsIndirect(buffer17, 616); };
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup24, new Uint32Array(4884), 586, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline5);
} catch {}
let autogeneratedBindGroupLayout3 = pipeline3.getBindGroupLayout(0);
let commandEncoder63 = device0.createCommandEncoder({});
let texture52 = device0.createTexture({
  size: [60],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView46 = texture1.createView({dimension: '2d-array', aspect: 'all'});
try {
computePassEncoder20.setBindGroup(0, bindGroup7, new Uint32Array(1823), 113, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(6, buffer9, 280, 220);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup12);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
let canvas1 = document.createElement('canvas');
let textureView47 = texture32.createView({dimension: '2d-array'});
try {
renderPassEncoder5.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup21);
} catch {}
try {
commandEncoder63.copyBufferToBuffer(buffer2, 148, buffer40, 1132, 176);
} catch {}
try {
commandEncoder63.copyBufferToTexture({
  /* bytesInLastRow: 240 widthInBlocks: 120 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1144 */
  offset: 1144,
  buffer: buffer3,
}, {
  texture: texture50,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'depth-only',
}, {width: 120, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
try {
device0.queue.writeBuffer(buffer12, 5308, new BigUint64Array(21367), 3927, 568);
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
let commandEncoder64 = device0.createCommandEncoder({});
let texture53 = device0.createTexture({
  size: {width: 12, height: 396, depthOrArrayLayers: 126},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle5 = renderBundleEncoder5.finish({});
try {
computePassEncoder42.setBindGroup(2, bindGroup8);
} catch {}
try {
computePassEncoder49.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer13, 'uint16', 1_486, 1_321);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline9);
} catch {}
try {
commandEncoder64.copyBufferToBuffer(buffer38, 1652, buffer40, 888, 220);
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet5, 272, 71, buffer2, 256);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder65 = device0.createCommandEncoder({});
let computePassEncoder51 = commandEncoder64.beginComputePass({});
let sampler33 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 91.83, compare: 'less-equal'});
let externalTexture10 = device0.importExternalTexture({source: videoFrame2});
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
let buffer44 = device0.createBuffer({
  size: 3616,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView48 = texture45.createView({dimension: '2d-array'});
try {
renderPassEncoder5.setBindGroup(0, bindGroup24);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let recycledExplicitBindGroupLayout16 = pipeline2.getBindGroupLayout(0);
let commandEncoder66 = device0.createCommandEncoder({});
let renderPassEncoder16 = commandEncoder65.beginRenderPass({colorAttachments: [{view: textureView27, loadOp: 'clear', storeOp: 'discard'}]});
try {
computePassEncoder24.setBindGroup(0, bindGroup24, new Uint32Array(957), 173, 0);
} catch {}
try {
renderPassEncoder4.setBlendConstant({ r: -857.3, g: -618.5, b: -729.2, a: -386.0, });
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer40, 0, 92);
} catch {}
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 5, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4552 */
  offset: 4552,
  bytesPerRow: 2048,
  rowsPerImage: 571,
  buffer: buffer2,
}, {width: 0, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 40});
let textureView49 = texture44.createView({});
try {
computePassEncoder21.setBindGroup(0, bindGroup1, new Uint32Array(191), 3, 0);
} catch {}
try {
computePassEncoder51.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup24, new Uint32Array(238), 0, 0);
} catch {}
try {
renderPassEncoder11.setBlendConstant({ r: -938.0, g: 170.2, b: 794.2, a: -424.9, });
} catch {}
try {
renderPassEncoder9.setVertexBuffer(2, buffer9);
} catch {}
let imageData1 = new ImageData(148, 4);
let recycledExplicitBindGroupLayout17 = pipeline4.getBindGroupLayout(0);
let buffer45 = device0.createBuffer({
  size: 6739,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
let commandEncoder68 = device0.createCommandEncoder({});
let texture54 = device0.createTexture({
  size: {width: 3},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView50 = texture16.createView({baseMipLevel: 0, arrayLayerCount: 1});
let computePassEncoder52 = commandEncoder63.beginComputePass({});
try {
computePassEncoder28.setBindGroup(0, bindGroup22, new Uint32Array(211), 19, 0);
} catch {}
try {
computePassEncoder52.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle3, renderBundle3]);
} catch {}
try {
commandEncoder68.resolveQuerySet(querySet2, 0, 8, buffer5, 0);
} catch {}
let buffer46 = device0.createBuffer({size: 3115, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder69 = device0.createCommandEncoder();
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 86});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({
  colorFormats: ['rg8unorm'],
  depthStencilFormat: 'depth16unorm',
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle6 = renderBundleEncoder6.finish({});
let sampler34 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.27,
});
let externalTexture11 = device0.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder16.setBindGroup(1, bindGroup23);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline5);
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

enable f16;

requires packed_4x8_integer_dot_product;

struct T2 {
  @align(32) @size(8192) f0: array<mat4x2f>,
}

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

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

var<workgroup> vw11: S2;

struct T0 {
  f0: f32,
}

struct S2 {
  @location(5) @interpolate(flat, sample) f0: vec2u,
  @builtin(instance_index) f1: u32,
  @location(3) f2: vec4f,
  @location(1) f3: vec2f,
  @location(9) f4: vec2f,
}

fn fn1() -> vec4f {
  var out: vec4f;
  var vf55: vec3f = quantizeToF16(vec3f(unconst_f32(0.03770), unconst_f32(0.3386), unconst_f32(0.07088)));
  var vf56: f16 = vp5[u32(unconst_u32(289))][u32(unconst_u32(8))];
  vf56 += cross(vec3h(unconst_f16(17365.0), unconst_f16(9430.0), unconst_f16(13383.6)), vec3h(unconst_f16(229.4), unconst_f16(4027.2), unconst_f16(5972.8)))[2];
  var vf57: vec4h = fma(vec4h(unconst_f16(5272.8), unconst_f16(1802.7), unconst_f16(9101.5), unconst_f16(2449.0)), vec4h(unconst_f16(-2887.0), unconst_f16(3101.4), unconst_f16(9959.2), unconst_f16(8648.4)), vec4h(unconst_f16(7700.2), unconst_f16(30748.0), unconst_f16(14336.6), unconst_f16(14610.1)));
  vf57 = vp5[u32(unconst_u32(232))].rgbr;
  let vf58: vec3h = inverseSqrt(vec3h(unconst_f16(5493.6), unconst_f16(16698.7), unconst_f16(6365.1)));
  let vf59: u32 = pack2x16unorm(vec2f(unconst_f32(0.06674), unconst_f32(0.1939)));
  vp6 = vec2<bool>(bool(pack4xU8(vec4u(unconst_u32(550), unconst_u32(333), unconst_u32(257), unconst_u32(5)))));
  var vf60: vec4f = atan(vec4f(unconst_f32(0.1449), unconst_f32(0.01063), unconst_f32(0.4013), unconst_f32(0.06302)));
  discard;
  vp6 = vec2<bool>(bool(pack2x16unorm(vec2f(unconst_f32(0.08445), unconst_f32(0.04007)))));
  let vf61: vec4u = countOneBits(vec4u(unconst_u32(30), unconst_u32(7), unconst_u32(102), unconst_u32(130)));
  let ptr69: ptr<private, vec2<bool>> = &vp6;
  return out;
}

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

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

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

var<workgroup> vw9: VertexOutput4;

var<workgroup> vw6: VertexOutput4;

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

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

var<private> vp5: mat3x3h = mat3x3h(10723.5, -5330.8, -26505.5, 9365.9, 24269.2, 40563.5, 6035.6, 4209.9, 4756.5);

var<workgroup> vw13: vec4f;

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

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

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

var<workgroup> vw12: array<T0, 49>;

var<workgroup> vw7: array<T0, 9>;

alias vec3b = vec3<bool>;

var<workgroup> vw10: atomic<u32>;

@group(0) @binding(235) var tex3: texture_2d<f32>;

fn fn0(a0: ptr<function, array<VertexOutput5, 1>>, a1: S2) -> array<array<array<T0, 8>, 1>, 1> {
  var out: array<array<array<T0, 8>, 1>, 1>;
  (*a0)[u32(unconst_u32(300))] = VertexOutput5(vec4f(fma(vec3h(unconst_f16(19476.8), unconst_f16(17992.8), unconst_f16(1532.8)), vec3h(unconst_f16(4246.1), unconst_f16(695.2), unconst_f16(414.5)), vec3h(unconst_f16(33635.4), unconst_f16(221.8), unconst_f16(2115.5))).rrrb));
  var vf54: vec4f = unpack4x8unorm(u32(unconst_u32(264)));
  out[u32(unconst_u32(172))][u32(unconst_u32(2))][u32(unconst_u32(161))] = T0(bitcast<f32>(pack4xI8Clamp(vec4i(unconst_i32(168), unconst_i32(126), unconst_i32(233), unconst_i32(253)))));
  out[u32(unconst_u32(141))][bitcast<vec2u>(round(vec2f(unconst_f32(0.07717), unconst_f32(0.03716))))[0]][u32(unconst_u32(46))] = T0(vf54[u32(unconst_u32(283))]);
  (*a0)[u32(unconst_u32(214))] = VertexOutput5(vec4f(a1.f2[u32(unconst_u32(471))]));
  return out;
}

@vertex
fn vertex4(a0: S2, @location(10) a1: vec2h) -> VertexOutput4 {
  var out: VertexOutput4;
  out.f11 = a0.f3.xyyy;
  var vf62: u32 = a0.f0[u32(unconst_u32(237))];
  out.f11 = vec4f(f32(vp5[bitcast<u32>(a0.f3[u32(unconst_u32(317))])][u32(unconst_u32(26))]));
  return out;
}

@vertex
fn vertex5() -> VertexOutput5 {
  var out: VertexOutput5;
  vp6 = vec2<bool>(bool(pack4xI8(vec4i(unconst_i32(85), unconst_i32(99), unconst_i32(958), unconst_i32(302)))));
  vp6 = vec2<bool>(faceForward(vec4h(unconst_f16(1857.8), unconst_f16(5436.3), unconst_f16(815.6), unconst_f16(22749.9)), vec4h(unconst_f16(14843.4), unconst_f16(5226.3), unconst_f16(469.3), unconst_f16(15726.9)), vec4h(unconst_f16(28677.3), unconst_f16(4256.3), unconst_f16(5811.0), unconst_f16(10273.1))).bb);
  var vf63: vec3h = vp5[u32(unconst_u32(70))];
  vf63 *= vec3h(unpack4xI8(u32(unconst_u32(64))).rga);
  var vf64: u32 = pack2x16unorm(vec2f(unconst_f32(0.1818), unconst_f32(-0.00563)));
  let vf65: u32 = pack2x16unorm(vec2f(unconst_f32(0.1216), unconst_f32(0.01792)));
  out.f12 = textureLoad(tex3, vec2i(unconst_i32(51), unconst_i32(26)), i32(unconst_i32(239)));
  vf64 >>= pack2x16float(vec2f(unconst_f32(-0.09714), unconst_f32(0.1125)));
  vp5 += mat3x3h(vp5[bitcast<vec2u>(acosh(vec2f(unconst_f32(0.09548), unconst_f32(-0.08734))))[0]], vp5[bitcast<vec2u>(acosh(vec2f(unconst_f32(0.09548), unconst_f32(-0.08734))))[0]], vp5[bitcast<vec2u>(acosh(vec2f(unconst_f32(0.09548), unconst_f32(-0.08734))))[0]]);
  vp5 = mat3x3h(vec3h(textureDimensions(tex3).xyy), vec3h(textureDimensions(tex3).ggg), vec3h(textureDimensions(tex3).rrg));
  out.f12 -= vec4f(f32(any(vec2<bool>(unconst_bool(false), unconst_bool(false)))));
  vf63 += exp(vec4h(unconst_f16(5989.3), unconst_f16(19027.0), unconst_f16(9029.3), unconst_f16(9653.1))).rbb;
  vp6 = vec2<bool>(bool(pack4xU8(vec4u(unconst_u32(30), unconst_u32(180), unconst_u32(59), unconst_u32(75)))));
  vp6 = vec2<bool>(asin(vec2h(unconst_f16(3490.7), unconst_f16(5149.5))));
  let vf66: vec2u = textureDimensions(tex3, i32(unconst_i32(4)));
  let vf67: vec2h = asin(vec2h(vp6));
  let vf68: vec3f = select(vec3f(unconst_f32(0.08754), unconst_f32(0.01527), unconst_f32(-0.08145)), vec3f(unconst_f32(0.01001), unconst_f32(0.04012), unconst_f32(0.2832)), vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false)));
  out.f12 = vec4f(bitcast<f32>(pack4xI8(vec4i(unconst_i32(-95), unconst_i32(-532), unconst_i32(208), unconst_i32(300)))));
  return out;
  _ = tex3;
}

@compute @workgroup_size(2, 1, 1)
fn compute6(@builtin(workgroup_id) a0: vec3u, @builtin(global_invocation_id) a1: vec3u) {
  vp5 += mat3x3h(f16(vw12[u32(unconst_u32(329))].f0), f16(vw12[u32(unconst_u32(329))].f0), f16(vw12[u32(unconst_u32(329))].f0), f16(vw12[u32(unconst_u32(329))].f0), f16(vw12[u32(unconst_u32(329))].f0), f16(vw12[u32(unconst_u32(329))].f0), f16(vw12[u32(unconst_u32(329))].f0), f16(vw12[u32(unconst_u32(329))].f0), f16(vw12[u32(unconst_u32(329))].f0));
  let ptr70: ptr<workgroup, f32> = &vw7[8].f0;
  vw7[u32(unconst_u32(127))].f0 = vw11.f2[u32(unconst_u32(24))];
  let ptr71: ptr<workgroup, vec4f> = &(*&vw6).f11;
  let ptr72: ptr<workgroup, f32> = &(*&vw12)[u32(unconst_u32(114))].f0;
  vw11 = S2(vec2u(u32(vw7[8].f0)), bitcast<u32>(vw7[8].f0), vec4f(vw7[8].f0), vec2f(vw7[8].f0), vec2f(vw7[8].f0));
  vw7[8] = T0(vw9.f11[3]);
}`,
});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer8, 100); };
} catch {}
try {
commandEncoder67.copyBufferToBuffer(buffer27, 1344, buffer2, 632, 832);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle0, renderBundle2, renderBundle5, renderBundle0, renderBundle5]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 2_054, 148);
} catch {}
let pipeline10 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}});
document.body.prepend(canvas1);
let texture55 = device0.createTexture({
  size: [3, 99, 51],
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder4.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(4, buffer5, 1_520);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer8, 160, new BigUint64Array(6136), 1693, 188);
} catch {}
document.body.prepend(img0);
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt2020', transfer: 'gamma22curve'} });
let commandEncoder70 = device0.createCommandEncoder();
let computePassEncoder53 = commandEncoder67.beginComputePass({});
let renderPassEncoder17 = commandEncoder70.beginRenderPass({
  colorAttachments: [{view: textureView27, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet5,
  maxDrawCount: 193147716,
});
let sampler35 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.88,
  maxAnisotropy: 11,
});
try {
computePassEncoder22.setBindGroup(3, bindGroup0, new Uint32Array(1927), 36, 0);
} catch {}
try {
computePassEncoder53.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline9);
} catch {}
let pipeline11 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x28cab876},
  fragment: {module: shaderModule2, entryPoint: 'fragment3', targets: [{format: 'rg8unorm'}]},
  depthStencil: {
    format: 'depth16unorm',
    depthWriteEnabled: true,
    depthCompare: 'greater-equal',
    stencilReadMask: 585252033,
  },
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex3',
    buffers: [
      {
        arrayStride: 396,
        attributes: [
          {format: 'unorm16x2', offset: 12, shaderLocation: 11},
          {format: 'uint32x4', offset: 168, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw'},
});
let autogeneratedBindGroupLayout4 = pipeline11.getBindGroupLayout(0);
let buffer47 = device0.createBuffer({
  size: 12596,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let textureView51 = texture24.createView({});
try {
renderPassEncoder13.setIndexBuffer(buffer20, 'uint16', 1_160, 6_379);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer40, 0, 151);
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1224 */
  offset: 1192,
  buffer: buffer16,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 7},
  aspect: 'depth-only',
}, {width: 16, height: 1, depthOrArrayLayers: 1});
} catch {}
let buffer48 = device0.createBuffer({size: 5033, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let querySet10 = device0.createQuerySet({type: 'occlusion', count: 298});
let texture56 = device0.createTexture({
  size: [30, 12, 1],
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView52 = texture32.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1});
let computePassEncoder54 = commandEncoder69.beginComputePass();
try {
computePassEncoder36.setBindGroup(0, bindGroup9);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder9.setViewport(324.7138053562647, 0.08383319397485567, 24.376110470107196, 0.4528830339191705, 0.4493027240793098, 0.6661325384998675);
} catch {}
let imageBitmap0 = await createImageBitmap(videoFrame0);
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout17]});
let commandEncoder71 = device0.createCommandEncoder({});
let texture57 = device0.createTexture({
  size: {width: 2920, height: 1, depthOrArrayLayers: 33},
  mipLevelCount: 3,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder54.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup3, new Uint32Array(1697), 34, 0);
} catch {}
try {
commandEncoder71.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1678 */
  offset: 1678,
  bytesPerRow: 22016,
  rowsPerImage: 387,
  buffer: buffer2,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 48, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 49, y: 25, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer49 = device0.createBuffer({
  size: 454,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture58 = device0.createTexture({
  size: {width: 3, height: 99, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder55 = commandEncoder68.beginComputePass({});
try {
computePassEncoder1.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder55.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer22, 'uint16', 414, 7);
} catch {}
let bindGroup25 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout12,
  entries: [
    {binding: 48, resource: {buffer: buffer40, offset: 2304, size: 244}},
    {binding: 263, resource: {buffer: buffer37, offset: 2048, size: 236}},
  ],
});
let commandEncoder72 = device0.createCommandEncoder({});
try {
computePassEncoder51.setBindGroup(0, bindGroup20, new Uint32Array(558), 29, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup0, new Uint32Array(2223), 318, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle1]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(187).fill(2), /* required buffer size: 187 */
{offset: 187, bytesPerRow: 242}, {width: 120, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 49, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let commandEncoder73 = device0.createCommandEncoder({});
let computePassEncoder56 = commandEncoder72.beginComputePass({});
try {
computePassEncoder12.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline0);
} catch {}
try {
commandEncoder73.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2362 */
  offset: 2362,
  bytesPerRow: 20480,
  rowsPerImage: 428,
  buffer: buffer43,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 51},
  aspect: 'all',
}, {width: 6, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer44, 44, new BigUint64Array(65536), 16021, 36);
} catch {}
try {
  await promise10;
} catch {}
let buffer50 = device0.createBuffer({
  size: 24376,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandBuffer4 = commandEncoder71.finish();
try {
computePassEncoder37.setBindGroup(0, bindGroup2, []);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup21, new Uint32Array(915), 123, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer49, 'uint16', 56, 154);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer28, 592, 1_200);
} catch {}
document.body.prepend(canvas0);
let buffer51 = device0.createBuffer({
  size: 2151,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let computePassEncoder57 = commandEncoder73.beginComputePass();
try {
computePassEncoder32.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup22, new Uint32Array(1099), 109, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer5, 'uint16', 90, 143);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer46, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'unspecified', transfer: 'gamma28curve'} });
let commandEncoder74 = device0.createCommandEncoder();
let computePassEncoder58 = commandEncoder66.beginComputePass({label: '\u194f\u14bc\u{1f61b}\u060d\u{1fc43}\u{1fae9}\u7ceb\ud5a5\u83bb\u{1ff0b}\u{1f71e}'});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder2.setIndexBuffer(buffer32, 'uint32', 496, 952);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup19);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup21, new Uint32Array(934), 252, 0);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer26, 'uint16', 200, 470);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(4, buffer34);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
await gc();
let buffer52 = device0.createBuffer({
  size: 19497,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder75 = device0.createCommandEncoder({});
let textureView53 = texture34.createView({dimension: '2d', aspect: 'depth-only', baseMipLevel: 0, baseArrayLayer: 1});
let computePassEncoder59 = commandEncoder75.beginComputePass();
let sampler36 = device0.createSampler({addressModeW: 'repeat', magFilter: 'nearest'});
try {
computePassEncoder9.setBindGroup(0, bindGroup4, new Uint32Array(1205), 209, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer50, 7_268); };
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup24);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup21, new Uint32Array(6), 2, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 14, z: 0},
  aspect: 'depth-only',
}, new Uint8Array(210_216).fill(252), /* required buffer size: 210_216 */
{offset: 426, bytesPerRow: 270, rowsPerImage: 37}, {width: 120, height: 0, depthOrArrayLayers: 22});
} catch {}
try {
  await promise11;
} catch {}
let recycledExplicitBindGroupLayout18 = pipeline6.getBindGroupLayout(0);
let renderPassEncoder18 = commandEncoder74.beginRenderPass({
  colorAttachments: [{
  view: textureView18,
  clearValue: { r: 157.9, g: 275.6, b: 892.8, a: 982.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet4,
  maxDrawCount: 138504551,
});
let sampler37 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 66.22,
  compare: 'less-equal',
  maxAnisotropy: 9,
});
try {
renderPassEncoder15.setBindGroup(2, bindGroup8, new Uint32Array(1311), 266, 0);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline9);
} catch {}
let imageData2 = new ImageData(12, 64);
try {
computePassEncoder10.setBindGroup(0, bindGroup22, []);
} catch {}
try {
computePassEncoder50.setBindGroup(3, bindGroup24, new Uint32Array(1600), 349, 0);
} catch {}
try {
renderPassEncoder15.setBlendConstant({ r: 465.7, g: -31.81, b: -689.2, a: 737.2, });
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer33, 'uint32', 1_584, 413);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup9, new Uint32Array(189), 6, 0);
} catch {}
let pipeline12 = await device0.createComputePipelineAsync({layout: pipelineLayout4, compute: {module: shaderModule0, constants: {}}});
let texture59 = device0.createTexture({
  size: [7, 5, 47],
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthStencilFormat: 'depth16unorm'});
try {
computePassEncoder44.setBindGroup(3, bindGroup1, new Uint32Array(1643), 86, 0);
} catch {}
try {
computePassEncoder59.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder9.setViewport(180.75820117268003, 0.5973067318945854, 8.618160793727995, 0.0674291639822119, 0.6363610029149402, 0.8295020991191421);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer17, 380, 882);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup2, new Uint32Array(4885), 3_810, 0);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(4, buffer47, 0);
} catch {}
let querySet11 = device0.createQuerySet({type: 'occlusion', count: 10});
let textureView54 = texture39.createView({});
try {
computePassEncoder48.setBindGroup(0, bindGroup9);
} catch {}
try {
computePassEncoder54.setBindGroup(0, bindGroup0, new Uint32Array(132), 3, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup15);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup25, new Uint32Array(1278), 251, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer42, 'uint32', 4_280, 3_636);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(7, buffer46, 352, 243);
} catch {}
let commandEncoder76 = device0.createCommandEncoder({});
let computePassEncoder60 = commandEncoder76.beginComputePass({});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], sampleCount: 1, stencilReadOnly: false});
let renderBundle7 = renderBundleEncoder9.finish({});
try {
computePassEncoder55.setBindGroup(0, bindGroup15, new Uint32Array(3753), 104, 0);
} catch {}
try {
computePassEncoder58.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer33, 'uint16', 190, 2_467);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer52, 'uint16', 214, 4_660);
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageBitmap1 = await createImageBitmap(imageData0);
let imageData3 = new ImageData(4, 12);
let renderBundle8 = renderBundleEncoder7.finish();
try {
computePassEncoder36.setBindGroup(3, bindGroup20, new Uint32Array(432), 12, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup15, new Uint32Array(2315), 102, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer5, 256);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(4, undefined, 503_321_967, 1_122_070_140);
} catch {}
try {
buffer3.unmap();
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
let textureView55 = texture40.createView({dimension: '2d', aspect: 'all'});
let computePassEncoder61 = commandEncoder77.beginComputePass({label: '\u7611\u3009\u9f4a'});
let renderBundle9 = renderBundleEncoder8.finish({});
try {
computePassEncoder52.setBindGroup(0, bindGroup5, new Uint32Array(46), 3, 0);
} catch {}
try {
computePassEncoder61.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup23);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let imageData4 = new ImageData(8, 24);
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'logSqrt'} });
let buffer53 = device0.createBuffer({size: 8337, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let commandEncoder78 = device0.createCommandEncoder({});
let texture60 = device0.createTexture({
  size: {width: 60, height: 24, depthOrArrayLayers: 37},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView56 = texture57.createView({
  label: '\u6911\u{1fbb9}\u02f2\u{1fc18}\uea94\u{1fd98}',
  aspect: 'depth-only',
  mipLevelCount: 1,
  baseArrayLayer: 5,
  arrayLayerCount: 3,
});
let computePassEncoder62 = commandEncoder78.beginComputePass({});
try {
computePassEncoder52.setBindGroup(0, bindGroup1, new Uint32Array(1329), 177, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder57.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup3, new Uint32Array(338), 27, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer49);
} catch {}
document.body.append(img0);
let img1 = await imageWithData(117, 43, '#10101010', '#20202020');
let bindGroup26 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [
    {binding: 263, resource: {buffer: buffer44, offset: 768}},
    {binding: 48, resource: {buffer: buffer8, offset: 0, size: 552}},
  ],
});
try {
renderPassEncoder17.setBindGroup(1, bindGroup1, new Uint32Array(2495), 351, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline6);
} catch {}
let autogeneratedBindGroupLayout5 = pipeline11.getBindGroupLayout(0);
let bindGroup27 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 235, resource: textureView6}, {binding: 167, resource: textureView3}],
});
let textureView57 = texture31.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder15.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup1, new Uint32Array(4763), 414, 0);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(7, buffer3, 0, 249);
} catch {}
let texture61 = device0.createTexture({
  size: [730, 1, 30],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder50.setBindGroup(2, bindGroup4);
} catch {}
try {
computePassEncoder62.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer2, 'uint32', 448, 1_035);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline5);
} catch {}
let pipeline13 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule1, constants: {}}});
let texture62 = device0.createTexture({
  size: {width: 15, height: 6, depthOrArrayLayers: 71},
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder60.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle0, renderBundle0]);
} catch {}
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 167,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 235,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let bindGroup28 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [
    {binding: 48, resource: {buffer: buffer6, offset: 0}},
    {binding: 263, resource: {buffer: buffer41, offset: 0, size: 8}},
  ],
});
let commandEncoder79 = device0.createCommandEncoder({});
let texture63 = device0.createTexture({size: [15], dimension: '1d', format: 'rg8unorm', usage: GPUTextureUsage.COPY_DST});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthStencilFormat: 'depth16unorm', sampleCount: 1, stencilReadOnly: true});
try {
computePassEncoder36.setBindGroup(1, bindGroup25, new Uint32Array(1418), 1, 0);
} catch {}
try {
renderPassEncoder18.end();
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
try {
  await promise12;
} catch {}
let bindGroup29 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout10,
  entries: [
    {binding: 48, resource: {buffer: buffer4, offset: 512, size: 3500}},
    {binding: 263, resource: {buffer: buffer24, offset: 0, size: 1704}},
  ],
});
let renderPassEncoder19 = commandEncoder79.beginRenderPass({
  colorAttachments: [{
  view: textureView10,
  depthSlice: 0,
  clearValue: { r: -190.6, g: 436.5, b: 72.72, a: 3.489, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 209941767,
});
try {
computePassEncoder38.setBindGroup(0, bindGroup24, new Uint32Array(204), 39, 0);
} catch {}
try {
computePassEncoder2.end();
} catch {}
try {
renderPassEncoder11.setBlendConstant({ r: 609.6, g: 695.9, b: 840.2, a: 218.0, });
} catch {}
try {
renderBundleEncoder10.setBindGroup(3, bindGroup15);
} catch {}
try {
buffer25.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer36, 228, new Float32Array(2470), 200, 272);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 396, depthOrArrayLayers: 126}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 0, y: 46, z: 89},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder80 = device0.createCommandEncoder({});
let computePassEncoder63 = commandEncoder74.beginComputePass({});
let sampler38 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMinClamp: 6.377});
try {
renderPassEncoder0.setBindGroup(0, bindGroup20, new Uint32Array(175), 6, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer8, 'uint16', 216, 414);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(5, undefined, 76_951_517, 186_077_650);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(3, buffer5);
} catch {}
try {
commandEncoder5.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4164 */
  offset: 4164,
  rowsPerImage: 945,
  buffer: buffer8,
}, {width: 15, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(45_181).fill(18), /* required buffer size: 45_181 */
{offset: 37, bytesPerRow: 209, rowsPerImage: 72}, {width: 52, height: 0, depthOrArrayLayers: 4});
} catch {}
let computePassEncoder64 = commandEncoder5.beginComputePass({});
let renderPassEncoder20 = commandEncoder80.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: 583.8, g: -322.0, b: 944.0, a: -792.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 263533014,
});
try {
computePassEncoder30.setBindGroup(0, bindGroup23, new Uint32Array(151), 13, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'depth-only',
}, new Uint8Array(255).fill(10), /* required buffer size: 255 */
{offset: 255}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext2 = canvas1.getContext('webgpu');
let buffer54 = device0.createBuffer({
  size: 1974,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture64 = device0.createTexture({
  size: {width: 6, height: 198, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder10.setPipeline(pipeline11);
} catch {}
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'smpte170m'} });
let bindGroup30 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 235, resource: textureView3}, {binding: 167, resource: textureView3}],
});
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 1345});
let textureView58 = texture48.createView({dimension: '2d-array'});
let sampler39 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 72.75,
  maxAnisotropy: 2,
});
try {
computePassEncoder33.setBindGroup(0, bindGroup24);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup3, new Uint32Array(452), 92, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer34, 'uint32', 288, 480);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup24);
} catch {}
try {
renderBundleEncoder10.setBindGroup(2, bindGroup15, new Uint32Array(2145), 32, 0);
} catch {}
let promise13 = shaderModule3.getCompilationInfo();
try {
buffer39.unmap();
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(img1);
let textureView59 = texture29.createView({aspect: 'all'});
let renderBundle10 = renderBundleEncoder10.finish({});
try {
computePassEncoder30.end();
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup3, new Uint32Array(302), 170, 0);
} catch {}
try {
buffer41.unmap();
} catch {}
try {
commandEncoder38.copyBufferToBuffer(buffer6, 412, buffer1, 636, 120);
} catch {}
let textureView60 = texture6.createView({label: '\u06e3\u66ca', dimension: '1d', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder6.end();
} catch {}
try {
computePassEncoder64.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup23, new Uint32Array(1876), 441, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer49, 32, 202);
} catch {}
try {
commandEncoder2.resolveQuerySet(querySet0, 95, 20, buffer16, 7936);
} catch {}
try {
  await promise9;
} catch {}
let computePassEncoder65 = commandEncoder2.beginComputePass({});
let sampler40 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat'});
try {
computePassEncoder16.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup27, new Uint32Array(2017), 317, 0);
} catch {}
try {
renderPassEncoder9.end();
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer27, 'uint16', 5_762, 994);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(7, buffer44, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 1760, new BigUint64Array(3721), 934, 20);
} catch {}
let pipeline14 = device0.createRenderPipeline({
  layout: pipelineLayout5,
  fragment: {module: shaderModule2, entryPoint: 'fragment2', targets: [{format: 'rg8sint', writeMask: 0}]},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 72,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x4', offset: 0, shaderLocation: 8},
          {format: 'sint8x2', offset: 2, shaderLocation: 15},
          {format: 'unorm8x2', offset: 18, shaderLocation: 12},
          {format: 'snorm16x4', offset: 12, shaderLocation: 10},
          {format: 'sint32', offset: 20, shaderLocation: 14},
          {format: 'float32x3', offset: 8, shaderLocation: 7},
          {format: 'sint32x3', offset: 4, shaderLocation: 2},
          {format: 'float32x4', offset: 0, shaderLocation: 6},
          {format: 'uint32x4', offset: 0, shaderLocation: 0},
          {format: 'uint16x4', offset: 16, shaderLocation: 11},
          {format: 'sint16x4', offset: 12, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 3},
          {format: 'uint8x4', offset: 4, shaderLocation: 4},
          {format: 'sint32x3', offset: 8, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 184,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 76, shaderLocation: 13},
          {format: 'uint16x2', offset: 28, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let bindGroup31 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 263, resource: {buffer: buffer7, offset: 0, size: 244}},
    {binding: 48, resource: {buffer: buffer37, offset: 1024, size: 3544}},
  ],
});
let textureView61 = texture42.createView({dimension: '2d-array'});
let computePassEncoder66 = commandEncoder19.beginComputePass();
let renderPassEncoder21 = commandEncoder38.beginRenderPass({
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: 512.7, g: 92.42, b: 993.7, a: 863.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler41 = device0.createSampler({addressModeU: 'repeat', magFilter: 'linear'});
try {
computePassEncoder52.end();
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup28);
} catch {}
try {
renderPassEncoder10.setBlendConstant({ r: -208.3, g: -985.0, b: -11.31, a: -721.9, });
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer45, 'uint32', 1_616, 265);
} catch {}
document.body.append(img0);
await gc();
let bindGroup32 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 263, resource: {buffer: buffer44, offset: 768, size: 1252}},
    {binding: 48, resource: {buffer: buffer6, offset: 0, size: 664}},
  ],
});
let texture65 = device0.createTexture({
  size: {width: 1, height: 49, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder27.setBindGroup(0, bindGroup28);
} catch {}
try {
computePassEncoder28.setBindGroup(0, bindGroup10, new Uint32Array(1364), 222, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder1.end();
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline8);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
try {
globalThis.someLabel = externalTexture9.label;
} catch {}
let recycledExplicitBindGroupLayout19 = pipeline13.getBindGroupLayout(0);
let commandEncoder81 = device0.createCommandEncoder({});
let textureView62 = texture20.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder67 = commandEncoder81.beginComputePass();
try {
computePassEncoder65.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup23, new Uint32Array(1181), 91, 0);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle0]);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder63.copyTextureToTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 1},
  aspect: 'all',
},
{
  texture: texture12,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder68 = commandEncoder1.beginComputePass({});
let renderPassEncoder22 = commandEncoder63.beginRenderPass({
  colorAttachments: [{
  view: textureView28,
  clearValue: { r: 809.0, g: 280.5, b: 446.0, a: -296.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder12.end();
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup22, new Uint32Array(1695), 645, 0);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'depth-only',
},
{
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder8.clearBuffer(buffer44, 768);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let commandBuffer5 = commandEncoder8.finish();
let texture66 = device0.createTexture({
  size: {width: 120},
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView63 = texture9.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 9});
try {
computePassEncoder68.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup23, []);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(3, buffer22, 200);
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let recycledExplicitBindGroupLayout20 = pipeline13.getBindGroupLayout(0);
let buffer55 = device0.createBuffer({
  size: 12159,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder4.insertDebugMarker('\ua421');
} catch {}
let imageData5 = new ImageData(4, 124);
let buffer56 = device0.createBuffer({size: 2834, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture67 = device0.createTexture({
  size: {width: 15, height: 6, depthOrArrayLayers: 9},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler42 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.63,
});
try {
computePassEncoder66.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer31, 'uint32', 520, 460);
} catch {}
let bindGroup33 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 48, resource: {buffer: buffer12, offset: 6656, size: 12804}},
    {binding: 263, resource: {buffer: buffer6, offset: 0}},
  ],
});
let commandEncoder82 = device0.createCommandEncoder({});
let querySet13 = device0.createQuerySet({type: 'occlusion', count: 286});
let computePassEncoder69 = commandEncoder82.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup24);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle2, renderBundle7, renderBundle8, renderBundle2]);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer20, 'uint32', 13_896, 5_717);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, undefined, 0, 139_159_906);
} catch {}
let recycledExplicitBindGroupLayout21 = pipeline5.getBindGroupLayout(0);
let buffer57 = device0.createBuffer({
  size: 22856,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder83 = device0.createCommandEncoder({});
let textureView64 = texture60.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 5});
let computePassEncoder70 = commandEncoder83.beginComputePass({});
try {
computePassEncoder70.setPipeline(pipeline2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture61,
  mipLevel: 1,
  origin: {x: 21, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(3_841).fill(8), /* required buffer size: 3_841 */
{offset: 49, bytesPerRow: 48, rowsPerImage: 79}, {width: 15, height: 0, depthOrArrayLayers: 2});
} catch {}
let texture68 = device0.createTexture({
  size: [1],
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler43 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.03,
});
try {
computePassEncoder50.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer45, 'uint32', 880, 606);
} catch {}
let arrayBuffer4 = buffer21.getMappedRange(0, 8);
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(388).fill(37), /* required buffer size: 388 */
{offset: 388, bytesPerRow: 3, rowsPerImage: 48}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
let buffer58 = device0.createBuffer({
  size: 1523,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture69 = device0.createTexture({
  size: {width: 1460, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
} catch {}
let buffer59 = device0.createBuffer({size: 3708, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView65 = texture29.createView({dimension: '1d'});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true});
let renderBundle11 = renderBundleEncoder11.finish({});
let sampler44 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.16,
  maxAnisotropy: 15,
});
try {
computePassEncoder65.setBindGroup(0, bindGroup5);
} catch {}
try {
buffer59.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 14, z: 0},
  aspect: 'all',
}, new Uint8Array(81).fill(115), /* required buffer size: 81 */
{offset: 81, bytesPerRow: 58}, {width: 0, height: 22, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 9, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder9.end();
} catch {}
try {
computePassEncoder67.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline9);
} catch {}
await gc();
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: []});
try {
computePassEncoder70.setBindGroup(0, bindGroup3, new Uint32Array(548), 299, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer8, 184); };
} catch {}
try {
computePassEncoder69.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(23);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer34);
} catch {}
try {
commandEncoder10.clearBuffer(buffer40, 108, 1912);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 1},
  aspect: 'depth-only',
}, new Uint8Array(1_199_184).fill(208), /* required buffer size: 1_199_184 */
{offset: 113, bytesPerRow: 283, rowsPerImage: 223}, {width: 120, height: 0, depthOrArrayLayers: 20});
} catch {}
let commandEncoder84 = device0.createCommandEncoder({});
let textureView66 = texture43.createView({label: '\ub0da\u1cc8\u06a0\u0494\u36fa', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 17});
let computePassEncoder71 = commandEncoder84.beginComputePass();
try {
computePassEncoder3.setBindGroup(0, bindGroup25, new Uint32Array(1924), 136, 0);
} catch {}
try {
computePassEncoder55.setPipeline(pipeline7);
} catch {}
try {
computePassEncoder71.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder15.setScissorRect(51, 0, 33, 0);
} catch {}
try {
buffer26.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer4, 1900, new BigUint64Array(4182), 336, 236);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture39,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, new Uint8Array(95).fill(180), /* required buffer size: 95 */
{offset: 95, bytesPerRow: 735}, {width: 365, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder50.setBindGroup(0, bindGroup29);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder65); computePassEncoder65.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer5, 'uint32', 1_656, 4);
} catch {}
try {
commandEncoder10.copyTextureToBuffer({
  texture: texture54,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1488 */
  offset: 1488,
  bytesPerRow: 15616,
  buffer: buffer4,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline15 = await device0.createComputePipelineAsync({
  label: '\ubde7\u0ab1\u7fe1\u0d8e\ue21f',
  layout: pipelineLayout6,
  compute: {module: shaderModule2, entryPoint: 'compute3', constants: {}},
});
let commandEncoder85 = device0.createCommandEncoder();
let commandBuffer6 = commandEncoder10.finish({});
let computePassEncoder72 = commandEncoder85.beginComputePass({});
try {
computePassEncoder59.setBindGroup(0, bindGroup8, new Uint32Array(459), 14, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer28, 'uint16', 186, 173);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer13);
} catch {}
let commandEncoder86 = device0.createCommandEncoder({});
let textureView67 = texture11.createView({dimension: '3d', mipLevelCount: 1});
let computePassEncoder73 = commandEncoder86.beginComputePass({});
let sampler45 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 42.42,
  lodMaxClamp: 93.71,
});
let externalTexture12 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'srgb'});
try {
computePassEncoder10.setBindGroup(0, bindGroup9, new Uint32Array(604), 7, 0);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer5, 'uint16', 638, 6);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer17, 300, 497);
} catch {}
let pipeline16 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x27b12d35},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{
  format: 'rg8sint',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {module: shaderModule4, entryPoint: 'vertex5', constants: {}, buffers: []},
  primitive: {topology: 'triangle-list', cullMode: 'front'},
});
let recycledExplicitBindGroupLayout22 = pipeline0.getBindGroupLayout(0);
let bindGroup34 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [
    {binding: 235, resource: textureView6},
    {binding: 48, resource: {buffer: buffer8, offset: 512, size: 556}},
    {binding: 263, resource: {buffer: buffer29, offset: 3840, size: 6308}},
  ],
});
let commandEncoder87 = device0.createCommandEncoder();
let texture70 = gpuCanvasContext1.getCurrentTexture();
let sampler46 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat'});
try {
computePassEncoder67.setBindGroup(3, bindGroup33, new Uint32Array(84), 3, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer3, 128); };
} catch {}
try {
computePassEncoder72.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup24, new Uint32Array(261), 18, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer47, 1_376, 1_767);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let arrayBuffer5 = buffer0.getMappedRange(152, 4);
try {
commandEncoder87.copyBufferToTexture({
  /* bytesInLastRow: 84 widthInBlocks: 42 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3602 */
  offset: 3602,
  buffer: buffer27,
}, {
  texture: texture66,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 42, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder87.copyTextureToBuffer({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 764 */
  offset: 764,
  bytesPerRow: 8192,
  buffer: buffer25,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder88 = device0.createCommandEncoder({});
let computePassEncoder74 = commandEncoder88.beginComputePass({});
let sampler47 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', magFilter: 'linear'});
try {
computePassEncoder49.setBindGroup(2, bindGroup25);
} catch {}
try {
computePassEncoder19.end();
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup34, new Uint32Array(4605), 348, 0);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(18);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer31, 'uint16', 64, 588);
} catch {}
try {
buffer59.unmap();
} catch {}
try {
commandEncoder87.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 6528 */
  offset: 6528,
  bytesPerRow: 41728,
  buffer: buffer4,
}, {width: 15, height: 10, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let buffer60 = device0.createBuffer({size: 14055, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder89 = device0.createCommandEncoder({});
let computePassEncoder75 = commandEncoder89.beginComputePass({});
let renderPassEncoder23 = commandEncoder26.beginRenderPass({
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: -945.6, g: -932.9, b: -367.4, a: -474.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet10,
});
let sampler48 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 88.26});
try {
computePassEncoder50.setBindGroup(1, bindGroup15, new Uint32Array(1453), 66, 0);
} catch {}
try {
computePassEncoder75.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup21, new Uint32Array(241), 138, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
let bindGroup35 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [{binding: 167, resource: textureView6}, {binding: 235, resource: textureView3}],
});
let buffer61 = device0.createBuffer({
  size: 6940,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder90 = device0.createCommandEncoder({});
let sampler49 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMaxClamp: 53.52,
  compare: 'never',
});
try {
computePassEncoder70.setBindGroup(0, bindGroup24, new Uint32Array(3089), 519, 0);
} catch {}
try {
computePassEncoder65.end();
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer33, 'uint16', 1_224, 2_253);
} catch {}
try {
commandEncoder87.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1056 */
  offset: 1056,
  bytesPerRow: 24832,
  rowsPerImage: 156,
  buffer: buffer61,
}, {
  texture: texture11,
  mipLevel: 1,
  origin: {x: 0, y: 7, z: 0},
  aspect: 'all',
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let pipeline17 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rg8sint'}]},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 348,
        attributes: [
          {format: 'sint32x2', offset: 64, shaderLocation: 14},
          {format: 'sint32', offset: 176, shaderLocation: 9},
          {format: 'float32x2', offset: 48, shaderLocation: 13},
          {format: 'float16x2', offset: 48, shaderLocation: 6},
          {format: 'uint8x4', offset: 8, shaderLocation: 0},
          {format: 'uint32x2', offset: 28, shaderLocation: 1},
          {format: 'sint8x2', offset: 116, shaderLocation: 2},
          {format: 'uint32x4', offset: 8, shaderLocation: 11},
          {format: 'sint8x4', offset: 32, shaderLocation: 8},
          {format: 'float32', offset: 36, shaderLocation: 3},
          {format: 'unorm16x4', offset: 84, shaderLocation: 12},
          {format: 'float16x2', offset: 48, shaderLocation: 7},
          {format: 'snorm16x2', offset: 168, shaderLocation: 10},
          {format: 'uint16x2', offset: 12, shaderLocation: 4},
          {format: 'sint8x4', offset: 172, shaderLocation: 15},
          {format: 'sint32', offset: 204, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let commandEncoder91 = device0.createCommandEncoder({});
let textureView68 = texture46.createView({dimension: '2d', baseArrayLayer: 18});
let textureView69 = texture27.createView({dimension: '2d-array', mipLevelCount: 1});
let renderPassEncoder24 = commandEncoder2.beginRenderPass({
  colorAttachments: [{
  view: textureView28,
  clearValue: { r: 366.7, g: 213.1, b: 177.8, a: 427.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 142469366,
});
try {
computePassEncoder14.setBindGroup(0, bindGroup21);
} catch {}
try {
computePassEncoder73.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer33, 'uint32', 148, 1_048);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 2, y: 4 },
  flipY: false,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 16, depthOrArrayLayers: 0});
} catch {}
let commandEncoder92 = device0.createCommandEncoder({});
let textureView70 = texture36.createView({});
try {
computePassEncoder74.setBindGroup(3, bindGroup21, new Uint32Array(2766), 250, 0);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup33);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let autogeneratedBindGroupLayout6 = pipeline16.getBindGroupLayout(0);
let bindGroup36 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 235, resource: textureView6}, {binding: 167, resource: textureView3}],
});
let buffer62 = device0.createBuffer({size: 3024, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder93 = device0.createCommandEncoder({});
let computePassEncoder76 = commandEncoder91.beginComputePass({});
try {
computePassEncoder18.setBindGroup(0, bindGroup19);
} catch {}
try {
computePassEncoder76.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup27, new Uint32Array(3192), 224, 0);
} catch {}
try {
computePassEncoder58.insertDebugMarker('\u1f33');
} catch {}
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt709', transfer: 'bt709'} });
let buffer63 = device0.createBuffer({
  size: 8487,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture71 = device0.createTexture({
  size: {width: 365, height: 1, depthOrArrayLayers: 1},
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView71 = texture61.createView({label: '\ub8a5\u5941\uf73f\u{1f9f6}', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1});
let computePassEncoder77 = commandEncoder92.beginComputePass();
try {
computePassEncoder10.setBindGroup(0, bindGroup8, []);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline6);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 0, y: 5, z: 43},
  aspect: 'all',
}, new Uint8Array(3_852).fill(113), /* required buffer size: 3_852 */
{offset: 176, bytesPerRow: 127, rowsPerImage: 4}, {width: 60, height: 1, depthOrArrayLayers: 8});
} catch {}
document.body.prepend(canvas0);
let imageData6 = new ImageData(32, 8);
let autogeneratedBindGroupLayout7 = pipeline7.getBindGroupLayout(0);
let buffer64 = device0.createBuffer({size: 3014, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder94 = device0.createCommandEncoder({});
let querySet14 = device0.createQuerySet({type: 'occlusion', count: 195});
try {
computePassEncoder11.setBindGroup(1, bindGroup30, new Uint32Array(1957), 591, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder70); computePassEncoder70.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder15.end();
} catch {}
try {
renderPassEncoder23.beginOcclusionQuery(95);
} catch {}
try {
renderPassEncoder5.setStencilReference(930);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline17);
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 396, depthOrArrayLayers: 126}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 1, y: 18, z: 38},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder95 = device0.createCommandEncoder({});
let textureView72 = texture45.createView({});
let computePassEncoder78 = commandEncoder94.beginComputePass({});
let sampler50 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 89.87});
try {
computePassEncoder33.setBindGroup(0, bindGroup23);
} catch {}
try {
computePassEncoder68.setBindGroup(0, bindGroup29, new Uint32Array(229), 74, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup28);
} catch {}
try {
renderPassEncoder2.setViewport(215.30575508440953, 0.8506054637069844, 148.0311669162695, 0.14653766420222133, 0.9670948540036283, 0.9710555835893574);
} catch {}
let arrayBuffer6 = buffer21.getMappedRange(8, 8);
try {
commandEncoder93.copyBufferToBuffer(buffer33, 1764, buffer21, 2300, 56);
} catch {}
try {
adapter0.label = '\ufe50\u74cf\uf657\u0016\u{1fc70}\ucf06\u8363';
} catch {}
let renderPassEncoder25 = commandEncoder87.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -97.88, g: -458.1, b: -758.0, a: -876.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let externalTexture13 = device0.importExternalTexture({source: videoFrame8});
try {
computePassEncoder17.setBindGroup(0, bindGroup32);
} catch {}
try {
computePassEncoder77.setBindGroup(1, bindGroup3, new Uint32Array(731), 76, 0);
} catch {}
try {
computePassEncoder10.end();
} catch {}
try {
renderPassEncoder23.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder13.setBlendConstant({ r: -952.2, g: 833.2, b: -615.1, a: -510.5, });
} catch {}
document.body.prepend(img1);
let recycledExplicitBindGroupLayout23 = pipeline4.getBindGroupLayout(0);
let bindGroup37 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout14,
  entries: [
    {binding: 48, resource: {buffer: buffer29, offset: 0, size: 508}},
    {binding: 263, resource: {buffer: buffer58, offset: 0, size: 196}},
  ],
});
let texture72 = device0.createTexture({
  size: {width: 12, height: 396, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder79 = commandEncoder90.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer42, 9_100); };
} catch {}
try {
computePassEncoder78.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle2, renderBundle11]);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer2);
} catch {}
try {
commandEncoder11.copyBufferToBuffer(buffer27, 1856, buffer36, 880, 44);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer44, 4, new DataView(new ArrayBuffer(1563)), 372, 64);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let bindGroup38 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout20,
  entries: [
    {binding: 263, resource: {buffer: buffer58, offset: 0, size: 132}},
    {binding: 48, resource: {buffer: buffer7, offset: 0}},
  ],
});
let commandEncoder96 = device0.createCommandEncoder({});
let commandBuffer7 = commandEncoder11.finish();
let texture73 = device0.createTexture({
  size: [15, 10, 101],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder80 = commandEncoder96.beginComputePass();
try {
computePassEncoder21.setBindGroup(3, bindGroup30, new Uint32Array(1990), 516, 0);
} catch {}
try {
computePassEncoder38.end();
} catch {}
try {
computePassEncoder80.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup21, new Uint32Array(5710), 1_731, 0);
} catch {}
try {
renderPassEncoder16.setBlendConstant({ r: -164.8, g: 936.3, b: 173.4, a: 430.7, });
} catch {}
try {
renderPassEncoder5.draw(1, 237, 9, 189_189_914);
} catch {}
try {
renderPassEncoder5.drawIndexed(59, 77, 19, 379_664_946, 412_516_442);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer8, 692);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer50, 1_040);
} catch {}
try {
commandEncoder15.resolveQuerySet(querySet3, 89, 172, buffer57, 512);
} catch {}
try {
device0.queue.submit([commandBuffer7]);
} catch {}
let autogeneratedBindGroupLayout8 = pipeline7.getBindGroupLayout(0);
let buffer65 = device0.createBuffer({size: 458, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let computePassEncoder81 = commandEncoder93.beginComputePass();
let renderPassEncoder26 = commandEncoder15.beginRenderPass({colorAttachments: [{view: textureView67, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}]});
try {
renderPassEncoder7.setBindGroup(0, bindGroup9, []);
} catch {}
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer31, 620, 171);
} catch {}
try {
commandEncoder6.copyBufferToBuffer(buffer2, 292, buffer63, 648, 1004);
} catch {}
let bindGroup39 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [
    {binding: 48, resource: {buffer: buffer61, offset: 3840}},
    {binding: 263, resource: {buffer: buffer61, offset: 768}},
  ],
});
let commandEncoder97 = device0.createCommandEncoder();
let renderPassEncoder27 = commandEncoder95.beginRenderPass({
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: -586.0, g: -825.0, b: -454.6, a: 567.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet5,
  maxDrawCount: 72402362,
});
let sampler51 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', mipmapFilter: 'linear', compare: 'never'});
try {
computePassEncoder77.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup34);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer34, 'uint32', 3_016, 86);
} catch {}
try {
commandEncoder97.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2684 */
  offset: 2684,
  buffer: buffer56,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder97.copyTextureToTexture({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture63,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(250).fill(172), /* required buffer size: 250 */
{offset: 250, rowsPerImage: 4}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder98 = device0.createCommandEncoder({});
let computePassEncoder82 = commandEncoder6.beginComputePass({});
try {
renderPassEncoder24.setBindGroup(3, bindGroup23);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline8);
} catch {}
let computePassEncoder83 = commandEncoder98.beginComputePass({});
try {
renderPassEncoder22.executeBundles([renderBundle1, renderBundle11]);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(5, undefined);
} catch {}
try {
commandEncoder97.copyBufferToBuffer(buffer38, 508, buffer52, 7348, 432);
} catch {}
let promise16 = device0.createRenderPipelineAsync({
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule0,
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {arrayStride: 268, attributes: [{format: 'unorm16x2', offset: 88, shaderLocation: 9}]},
      {
        arrayStride: 120,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 16, shaderLocation: 11},
          {format: 'uint32x3', offset: 48, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {unclippedDepth: true},
});
let imageBitmap2 = await createImageBitmap(canvas0);
let commandEncoder99 = device0.createCommandEncoder();
let texture74 = device0.createTexture({size: [15, 10, 1], format: 'depth16unorm', usage: GPUTextureUsage.TEXTURE_BINDING});
let computePassEncoder84 = commandEncoder99.beginComputePass({});
let sampler52 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  lodMaxClamp: 50.32,
  compare: 'less',
});
try {
computePassEncoder17.setBindGroup(1, bindGroup27, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer40, 1_228); };
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(15);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer12, 664, 231);
} catch {}
try {
commandEncoder7.copyBufferToTexture({
  /* bytesInLastRow: 730 widthInBlocks: 365 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 792 */
  offset: 792,
  buffer: buffer54,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 365, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer31, 132, new BigUint64Array(20225), 1784, 0);
} catch {}
let sampler53 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 82.53,
});
try {
renderPassEncoder24.executeBundles([renderBundle0]);
} catch {}
let textureView73 = texture23.createView({});
let computePassEncoder85 = commandEncoder97.beginComputePass({});
let externalTexture14 = device0.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder20.setBlendConstant({ r: 384.0, g: 395.2, b: -473.6, a: -575.6, });
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline16);
} catch {}
try {
commandEncoder7.copyBufferToBuffer(buffer59, 292, buffer25, 1480, 240);
} catch {}
let bindGroup40 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [
    {binding: 235, resource: textureView70},
    {binding: 263, resource: {buffer: buffer44, offset: 512, size: 152}},
    {binding: 48, resource: {buffer: buffer44, offset: 1792, size: 364}},
  ],
});
let buffer66 = device0.createBuffer({
  size: 9325,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandBuffer8 = commandEncoder7.finish();
let sampler54 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMaxClamp: 94.80,
  maxAnisotropy: 1,
});
try {
computePassEncoder64.setBindGroup(0, bindGroup22);
} catch {}
try {
computePassEncoder34.setBindGroup(3, bindGroup4, new Uint32Array(1346), 29, 0);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup15, new Uint32Array(787), 139, 0);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle0, renderBundle11, renderBundle0, renderBundle11, renderBundle7, renderBundle7, renderBundle7, renderBundle7, renderBundle11, renderBundle2]);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer20, 'uint32', 244, 1_108);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, undefined);
} catch {}
let bindGroup41 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout13,
  entries: [
    {binding: 263, resource: {buffer: buffer13, offset: 0, size: 228}},
    {binding: 48, resource: {buffer: buffer8, offset: 2816, size: 192}},
  ],
});
let textureView74 = texture43.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 10, arrayLayerCount: 16});
try {
computePassEncoder79.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder25.executeBundles([renderBundle0, renderBundle8]);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let buffer67 = device0.createBuffer({
  size: 19278,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler55 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 86.29});
try {
computePassEncoder75.setBindGroup(3, bindGroup11, new Uint32Array(5158), 0, 0);
} catch {}
try {
device0.queue.submit([commandBuffer6]);
} catch {}
let imageData7 = new ImageData(52, 16);
let buffer68 = device0.createBuffer({
  size: 13521,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let texture75 = device0.createTexture({
  size: {width: 1, height: 49, depthOrArrayLayers: 1},
  format: 'depth16unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({
  label: '\u0939\u0a4c\u01c5\uad9d\u04f3\u{1f919}',
  colorFormats: ['rg8unorm'],
  depthStencilFormat: 'depth16unorm',
});
let renderBundle12 = renderBundleEncoder12.finish({});
try {
computePassEncoder74.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer22, 'uint16', 442, 71);
} catch {}
let texture76 = device0.createTexture({
  size: [120, 48, 1],
  sampleCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true});
try {
computePassEncoder77.setBindGroup(0, bindGroup11, new Uint32Array(2081), 72, 0);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle11, renderBundle3]);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup29);
} catch {}
document.body.append(img0);
let querySet15 = device0.createQuerySet({type: 'occlusion', count: 1352});
let texture77 = device0.createTexture({
  size: [1, 49, 1],
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder47.setBindGroup(0, bindGroup22, []);
} catch {}
try {
computePassEncoder84.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer5, 'uint16', 32, 445);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup27);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let renderBundle13 = renderBundleEncoder13.finish({});
let sampler56 = device0.createSampler({addressModeU: 'mirror-repeat', magFilter: 'linear', mipmapFilter: 'linear', compare: 'less'});
try {
computePassEncoder51.setBindGroup(0, bindGroup41);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(1, buffer9);
} catch {}
let autogeneratedBindGroupLayout9 = pipeline9.getBindGroupLayout(0);
let buffer69 = device0.createBuffer({size: 23169, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView75 = texture77.createView({baseMipLevel: 1, mipLevelCount: 1});
let sampler57 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 97.52, maxAnisotropy: 1});
try {
{ clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer16, 740); };
} catch {}
try {
computePassEncoder82.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup24, new Uint32Array(1848), 444, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(1, buffer63, 0, 206);
} catch {}
let commandEncoder100 = device0.createCommandEncoder({});
let renderPassEncoder28 = commandEncoder100.beginRenderPass({
  colorAttachments: [{
  view: textureView28,
  clearValue: { r: 848.6, g: -263.4, b: -627.2, a: -663.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 51191750,
});
let sampler58 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.61,
});
try {
computePassEncoder61.setBindGroup(3, bindGroup11, new Uint32Array(1921), 36, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer24, 1_576); };
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup36, new Uint32Array(1132), 180, 0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(1, buffer34, 0, 1_318);
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

@group(0) @binding(235) var tex5: texture_2d<f32>;

alias vec3b = vec3<bool>;

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

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

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

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

struct VertexOutput6 {
  @builtin(position) f13: vec4f,
  @location(13) f14: f32,
  @location(11) @interpolate(flat, centroid) f15: f32,
  @location(3) f16: u32,
}

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

struct T1 {
  @size(8) f0: u32,
}

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

var<workgroup> vw14: atomic<u32>;

@vertex
fn vertex6() -> VertexOutput6 {
  var out: VertexOutput6;
  var vf69: vec4h = refract(vec4h(unconst_f16(1342.7), unconst_f16(30558.9), unconst_f16(7694.9), unconst_f16(14894.1)), vec4h(unconst_f16(13081.9), unconst_f16(13840.0), unconst_f16(2525.3), unconst_f16(4642.8)), f16(unconst_f16(38610.7)));
  let vf70: u32 = textureNumLevels(tex5);
  out.f16 += u32(vf69[u32(unconst_u32(0))]);
  let vf71: f32 = degrees(f32(unconst_f32(0.08255)));
  out.f13 -= vec4f(textureDimensions(tex5).ggrg);
  return out;
  _ = tex5;
}

@compute @workgroup_size(1, 1, 1)
fn compute7() {
  var vf72: u32 = atomicLoad(&(*&vw14));
  var vf73: vec2u = textureDimensions(tex5);
  vf73 &= vec2u(atomicLoad(&vw14));
  let ptr73: ptr<workgroup, atomic<u32>> = &vw14;
  let vf74: vec2u = textureDimensions(tex5);
  var vf75: vec2u = vf74;
  let vf76: vec3u = countTrailingZeros(vf75.grr);
  vf75 = vec2u(vf76[u32(unconst_u32(24))]);
  var vf77: vec4f = unpack4x8unorm(u32(unconst_u32(111)));
  vf77 = vec4f(textureDimensions(tex5, i32(unconst_i32(5))).yyyx);
  let vf78: u32 = vf74[u32(unconst_u32(207))];
  vf72 *= bitcast<u32>(vf77[2]);
  var vf79: vec2u = textureDimensions(tex5);
  let ptr74: ptr<function, u32> = &vf72;
  vf79 -= vec2u(u32(any(vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true)))));
  vf75 |= vf79;
  vf72 *= vf74.x;
  _ = tex5;
}`,
});
let commandEncoder101 = device0.createCommandEncoder({});
let computePassEncoder86 = commandEncoder101.beginComputePass({});
try {
computePassEncoder71.setBindGroup(0, bindGroup4, new Uint32Array(376), 63, 0);
} catch {}
try {
computePassEncoder83.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup5);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup25, new Uint32Array(902), 146, 0);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline6);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470m', transfer: 'smpteSt4281'} });
let bindGroup42 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout5,
  entries: [
    {binding: 263, resource: {buffer: buffer58, offset: 0, size: 104}},
    {binding: 48, resource: {buffer: buffer26, offset: 3584}},
  ],
});
let buffer70 = device0.createBuffer({size: 5096, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView76 = texture66.createView({format: 'rg8unorm'});
let texture78 = gpuCanvasContext2.getCurrentTexture();
let textureView77 = texture49.createView({baseMipLevel: 0});
try {
computePassEncoder86.setPipeline(pipeline7);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST, alphaMode: 'premultiplied'});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 152,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 229,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 366,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder102 = device0.createCommandEncoder({});
let sampler59 = device0.createSampler({
  label: '\u1ba2\u8ea5\ufc76\u0e29',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
});
try {
computePassEncoder85.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup27, new Uint32Array(726), 111, 0);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer1, 'uint16', 1_708, 2_651);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let arrayBuffer7 = buffer0.getMappedRange(232, 36);
try {
computePassEncoder74.pushDebugGroup('\u5d5f');
} catch {}
try {
computePassEncoder74.popDebugGroup();
} catch {}
try {
device0.queue.submit([commandBuffer8]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 365, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 6, y: 4 },
  flipY: true,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup43 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 263, resource: {buffer: buffer54, offset: 0, size: 72}}],
});
let buffer71 = device0.createBuffer({
  size: 9448,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let computePassEncoder87 = commandEncoder102.beginComputePass();
try {
computePassEncoder60.setBindGroup(3, bindGroup27);
} catch {}
try {
computePassEncoder81.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline14);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let buffer72 = device0.createBuffer({size: 4692, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder103 = device0.createCommandEncoder({});
let texture79 = device0.createTexture({
  size: {width: 365, height: 1, depthOrArrayLayers: 496},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder84.setBindGroup(0, bindGroup12);
} catch {}
try {
computePassEncoder87.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer30, 'uint16', 356, 6_452);
} catch {}
let promise17 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule3,
  constants: {},
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {module: shaderModule4, entryPoint: 'vertex5', buffers: []},
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw'},
});
let bindGroup44 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [
    {binding: 263, resource: {buffer: buffer4, offset: 256, size: 40}},
    {binding: 48, resource: {buffer: buffer26, offset: 1024}},
  ],
});
let texture80 = device0.createTexture({
  size: [30, 12, 50],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture81 = device0.createTexture({
  size: [730, 1, 1],
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView78 = texture12.createView({baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder88 = commandEncoder103.beginComputePass({});
try {
renderPassEncoder0.beginOcclusionQuery(128);
} catch {}
try {
buffer34.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 365, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 7, y: 153 },
  flipY: true,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 55, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup45 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 366, resource: {buffer: buffer45, offset: 0, size: 4236}},
    {binding: 229, resource: textureView55},
    {binding: 152, resource: textureView42},
  ],
});
let texture82 = device0.createTexture({
  size: [15, 10, 143],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture83 = device0.createTexture({
  size: [120, 48, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder44.setBindGroup(2, bindGroup8, new Uint32Array(387), 43, 0);
} catch {}
try {
computePassEncoder88.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer57, 'uint32', 4_844, 2_988);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(4, buffer66, 0);
} catch {}
let buffer73 = device0.createBuffer({
  size: 758,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let textureView79 = texture80.createView({baseArrayLayer: 0});
let externalTexture15 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'});
try {
computePassEncoder35.setBindGroup(0, bindGroup29);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup25, new Uint32Array(1562), 32, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer66, 'uint32', 1_444, 446);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline1);
} catch {}
try {
buffer71.unmap();
} catch {}
let textureView80 = texture6.createView({});
try {
renderPassEncoder23.setViewport(0.20685551627884724, 86.18545673112551, 6.744022841344322, 95.06327049335195, 0.16536134105834444, 0.3702233861838854);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap1,
  origin: { x: 4, y: 1 },
  flipY: true,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 2, depthOrArrayLayers: 0});
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte240m', transfer: 'bt709'} });
let sampler60 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', mipmapFilter: 'linear'});
try {
renderPassEncoder25.setBindGroup(3, bindGroup37);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer44, 168);
} catch {}
let recycledExplicitBindGroupLayout24 = pipeline4.getBindGroupLayout(0);
let commandEncoder104 = device0.createCommandEncoder({});
let computePassEncoder89 = commandEncoder104.beginComputePass({});
try {
computePassEncoder54.setBindGroup(1, bindGroup35);
} catch {}
try {
computePassEncoder89.setBindGroup(2, bindGroup38, new Uint32Array(3256), 321, 0);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer49, 'uint16', 124, 68);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(2, buffer7);
} catch {}
let commandEncoder105 = device0.createCommandEncoder({});
let sampler61 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
});
let externalTexture16 = device0.importExternalTexture({source: videoFrame3});
try {
renderPassEncoder12.setIndexBuffer(buffer28, 'uint32', 724, 394);
} catch {}
try {
buffer26.unmap();
} catch {}
try {
commandEncoder105.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 9},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
},
{width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder106 = device0.createCommandEncoder({});
let textureView81 = texture75.createView({dimension: '2d-array', aspect: 'depth-only', baseArrayLayer: 0});
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer23, 2_400); };
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline9);
} catch {}
let buffer74 = device0.createBuffer({size: 14751, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder107 = device0.createCommandEncoder();
try {
computePassEncoder46.setBindGroup(3, bindGroup1, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder71); computePassEncoder71.dispatchWorkgroupsIndirect(buffer3, 156); };
} catch {}
try {
computePassEncoder89.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup31);
} catch {}
try {
renderPassEncoder20.setBindGroup(1, bindGroup0, new Uint32Array(120), 22, 0);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline17);
} catch {}
try {
buffer52.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 49, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 4, y: 2 },
  flipY: true,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout4, recycledExplicitBindGroupLayout10]});
let commandEncoder108 = device0.createCommandEncoder({});
let texture84 = device0.createTexture({
  size: [30, 20, 1],
  mipLevelCount: 3,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder11.end();
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup45);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder25.setViewport(104.18192845577607, 0.4207607262881329, 78.75138185584571, 0.35474013099974655, 0.9206607177086858, 0.9770385409115337);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
texture53.destroy();
} catch {}
try {
commandEncoder12.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 27, y: 10, z: 0},
  aspect: 'all',
},
{
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
document.body.append(img0);
await gc();
try {
externalTexture6.label = '\u4a3a\ua653\u{1f605}\u0114\u7109\u06c5\u4fd8\u{1ff2b}\u6ec6\u7c6c';
} catch {}
let texture85 = device0.createTexture({size: [3], dimension: '1d', format: 'rg8unorm', usage: GPUTextureUsage.COPY_DST});
let renderPassEncoder29 = commandEncoder12.beginRenderPass({
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: -612.7, g: 72.07, b: -699.5, a: 3.696, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder39.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle1, renderBundle0]);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer57, 'uint32', 2_904, 9_116);
} catch {}
try {
commandEncoder106.copyTextureToTexture({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 287, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 32, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder108.resolveQuerySet(querySet12, 158, 136, buffer4, 512);
} catch {}
let pipeline18 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule3,
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex3',
    constants: {},
    buffers: [
      {
        arrayStride: 232,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 28, shaderLocation: 11},
          {format: 'uint16x2', offset: 28, shaderLocation: 1},
        ],
      },
    ],
  },
});
let textureView82 = texture62.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 5});
let computePassEncoder90 = commandEncoder107.beginComputePass({label: '\u0d89\u{1f901}'});
let sampler62 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'repeat', magFilter: 'nearest', mipmapFilter: 'nearest'});
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(2, 1, 1); };
} catch {}
try {
computePassEncoder90.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer57, 'uint16', 1_880, 1_739);
} catch {}
let arrayBuffer8 = buffer0.getMappedRange(120, 4);
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let promise18 = device0.createRenderPipelineAsync({
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 2},
          {format: 'sint32', offset: 0, shaderLocation: 15},
          {format: 'unorm8x4', offset: 0, shaderLocation: 3},
          {format: 'uint8x4', offset: 0, shaderLocation: 1},
          {format: 'sint8x4', offset: 0, shaderLocation: 8},
          {format: 'sint32', offset: 0, shaderLocation: 9},
          {format: 'float32', offset: 0, shaderLocation: 7},
          {format: 'uint8x4', offset: 0, shaderLocation: 0},
          {format: 'sint8x2', offset: 0, shaderLocation: 5},
          {format: 'uint16x2', offset: 0, shaderLocation: 11},
          {format: 'sint8x4', offset: 0, shaderLocation: 14},
          {format: 'uint8x2', offset: 0, shaderLocation: 4},
          {format: 'snorm8x4', offset: 0, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 180,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x2', offset: 8, shaderLocation: 13},
          {format: 'unorm8x2', offset: 80, shaderLocation: 10},
          {format: 'float32x2', offset: 40, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw'},
});
try {
adapter0.label = '\u974c\ue388\ua074\u185b';
} catch {}
let commandEncoder109 = device0.createCommandEncoder();
try {
renderPassEncoder11.setScissorRect(7, 0, 20, 0);
} catch {}
try {
renderPassEncoder13.setViewport(39.41722190774159, 7.552233367220262, 18.856523704937892, 9.677465339787087, 0.2378165210921478, 0.6605517781053836);
} catch {}
try {
commandEncoder109.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 960 */
  offset: 960,
  buffer: buffer38,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup46 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout14,
  entries: [
    {binding: 48, resource: {buffer: buffer58, offset: 256, size: 908}},
    {binding: 263, resource: {buffer: buffer29, offset: 0, size: 1212}},
  ],
});
let pipelineLayout9 = device0.createPipelineLayout({label: '\ue656\u5e1c', bindGroupLayouts: [recycledExplicitBindGroupLayout14]});
try {
computePassEncoder64.setBindGroup(0, bindGroup29, new Uint32Array(510), 34, 0);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(5, buffer4, 1_028);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap2,
  origin: { x: 48, y: 14 },
  flipY: true,
}, {
  texture: texture78,
  mipLevel: 0,
  origin: {x: 14, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 37, height: 19, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout25 = pipeline0.getBindGroupLayout(0);
let computePassEncoder91 = commandEncoder109.beginComputePass({});
try {
computePassEncoder74.setBindGroup(0, bindGroup21);
} catch {}
try {
commandEncoder108.copyTextureToTexture({
  texture: texture83,
  mipLevel: 0,
  origin: {x: 2, y: 18, z: 0},
  aspect: 'all',
},
{
  texture: texture19,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise15;
} catch {}
let texture86 = device0.createTexture({size: [1460, 1, 7], mipLevelCount: 5, format: 'depth16unorm', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder53.setBindGroup(0, bindGroup22, new Uint32Array(2120), 175, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup15, new Uint32Array(87), 4, 0);
} catch {}
try {
renderPassEncoder15.drawIndexed(19, 107, 43, 52_197_332, 733_004_918);
} catch {}
let textureView83 = texture79.createView({format: 'rgba32sint'});
let texture87 = device0.createTexture({
  size: [16],
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder92 = commandEncoder106.beginComputePass();
let sampler63 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.33,
  compare: 'greater-equal',
  maxAnisotropy: 17,
});
try {
computePassEncoder17.setBindGroup(0, bindGroup46);
} catch {}
try {
renderPassEncoder15.end();
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer34, 0, 13);
} catch {}
try {
commandEncoder108.clearBuffer(buffer4, 5716, 84);
} catch {}
try {
computePassEncoder84.insertDebugMarker('\u636b');
} catch {}
let commandBuffer9 = commandEncoder61.finish();
let textureView84 = texture39.createView({dimension: '2d-array', aspect: 'depth-only'});
let computePassEncoder93 = commandEncoder105.beginComputePass({});
try {
computePassEncoder59.setBindGroup(2, bindGroup28, new Uint32Array(296), 81, 0);
} catch {}
try {
computePassEncoder93.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup34, new Uint32Array(1004), 23, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline5);
} catch {}
try {
commandEncoder108.clearBuffer(buffer21, 680, 3288);
} catch {}
let imageData8 = new ImageData(4, 88);
let texture88 = device0.createTexture({
  size: [3, 99, 99],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler64 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 66.62,
  maxAnisotropy: 7,
});
try {
computePassEncoder55.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder28.setBindGroup(2, bindGroup0, new Uint32Array(2432), 760, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'depth-only',
}, new Uint8Array(504_620).fill(149), /* required buffer size: 504_620 */
{offset: 152, bytesPerRow: 212, rowsPerImage: 52}, {width: 60, height: 40, depthOrArrayLayers: 46});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 90, y: 12, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup47 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout12,
  entries: [
    {binding: 48, resource: {buffer: buffer51, offset: 512, size: 580}},
    {binding: 263, resource: {buffer: buffer12, offset: 0, size: 112}},
  ],
});
let textureView85 = texture2.createView({dimension: '2d-array', baseArrayLayer: 2, arrayLayerCount: 1});
let sampler65 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 85.90,
  compare: 'never',
  maxAnisotropy: 1,
});
try {
{ clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder28.setBindGroup(2, bindGroup34);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder108.copyBufferToBuffer(buffer56, 684, buffer1, 492, 852);
} catch {}
let bindGroup48 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout14,
  entries: [
    {binding: 48, resource: {buffer: buffer1, offset: 0, size: 4360}},
    {binding: 263, resource: {buffer: buffer38, offset: 1280, size: 4276}},
  ],
});
let commandEncoder110 = device0.createCommandEncoder({});
let textureView86 = texture78.createView({dimension: '2d-array'});
let computePassEncoder94 = commandEncoder110.beginComputePass({});
let sampler66 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', compare: 'not-equal'});
try {
computePassEncoder18.end();
} catch {}
try {
renderPassEncoder17.setStencilReference(731);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(4, buffer16, 2_328, 465);
} catch {}
try {
commandEncoder22.clearBuffer(buffer55, 304, 2352);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
});
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let computePassEncoder95 = commandEncoder108.beginComputePass({});
try {
computePassEncoder92.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle7, renderBundle1, renderBundle0, renderBundle11]);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(2, buffer49, 44, 162);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder22.copyBufferToBuffer(buffer63, 20, buffer1, 1732, 920);
} catch {}
try {
device0.queue.writeBuffer(buffer55, 576, new DataView(new ArrayBuffer(20024)), 5057, 3220);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture78,
  mipLevel: 0,
  origin: {x: 26, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(102).fill(94), /* required buffer size: 102 */
{offset: 102, bytesPerRow: 288}, {width: 43, height: 37, depthOrArrayLayers: 0});
} catch {}
try {
  await promise14;
} catch {}
let bindGroup49 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout8,
  entries: [
    {binding: 263, resource: {buffer: buffer44, offset: 0}},
    {binding: 48, resource: {buffer: buffer54, offset: 0, size: 224}},
  ],
});
let commandEncoder111 = device0.createCommandEncoder({});
let computePassEncoder96 = commandEncoder111.beginComputePass({});
let externalTexture17 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
computePassEncoder59.setBindGroup(0, bindGroup40, []);
} catch {}
try {
computePassEncoder68.setBindGroup(2, bindGroup36, new Uint32Array(1762), 60, 0);
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup28, new Uint32Array(1195), 74, 0);
} catch {}
try {
renderPassEncoder29.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(1, buffer28, 256, 51);
} catch {}
try {
device0.queue.submit([commandBuffer9]);
} catch {}
let pipeline19 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth16unorm',
    depthWriteEnabled: true,
    depthCompare: 'less-equal',
    stencilFront: {passOp: 'keep'},
    stencilWriteMask: 1449004399,
    depthBias: -2091533351,
    depthBiasSlopeScale: 0.0,
  },
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 364,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 108, shaderLocation: 11},
          {format: 'uint8x4', offset: 84, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'back'},
});
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); };
} catch {}
let commandEncoder112 = device0.createCommandEncoder({});
let texture89 = device0.createTexture({
  size: {width: 30, height: 12, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView87 = texture51.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 2});
try {
renderPassEncoder21.setIndexBuffer(buffer22, 'uint32', 108, 41);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(1, buffer13);
} catch {}
try {
device0.queue.writeBuffer(buffer40, 1148, new DataView(new ArrayBuffer(24120)), 1204, 200);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData9 = new ImageData(24, 64);
let autogeneratedBindGroupLayout10 = pipeline9.getBindGroupLayout(0);
let buffer75 = device0.createBuffer({
  size: 1322,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let texture90 = device0.createTexture({
  size: {width: 30, height: 20, depthOrArrayLayers: 18},
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder96.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle11, renderBundle0, renderBundle11]);
} catch {}
try {
renderPassEncoder29.setPipeline(pipeline14);
} catch {}
try {
buffer41.unmap();
} catch {}
try {
commandEncoder112.copyTextureToTexture({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 4},
  aspect: 'all',
},
{
  texture: texture67,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder112.resolveQuerySet(querySet14, 173, 14, buffer16, 2048);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(27).fill(47), /* required buffer size: 27 */
{offset: 27}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup50 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 48, resource: {buffer: buffer8, offset: 0, size: 896}},
    {binding: 263, resource: {buffer: buffer24, offset: 3328, size: 1824}},
  ],
});
let commandEncoder113 = device0.createCommandEncoder();
let textureView88 = texture90.createView({baseMipLevel: 0, baseArrayLayer: 3, arrayLayerCount: 8});
let texture91 = device0.createTexture({
  size: [6],
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler67 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 95.66, compare: 'greater'});
let externalTexture18 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'});
try {
computePassEncoder69.setBindGroup(1, bindGroup23);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(1, buffer17, 0, 1_160);
} catch {}
try {
device0.queue.writeBuffer(buffer8, 1420, new DataView(new ArrayBuffer(18270)), 2509, 1504);
} catch {}
try {
  await promise13;
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'logSqrt'} });
let commandEncoder114 = device0.createCommandEncoder();
let texture92 = device0.createTexture({
  size: [120, 48, 63],
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView89 = texture87.createView({label: '\uf9a0\u{1fd6c}'});
let externalTexture19 = device0.importExternalTexture({source: videoFrame8});
try {
computePassEncoder39.setBindGroup(0, bindGroup29, new Uint32Array(1049), 65, 0);
} catch {}
try {
commandEncoder113.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 624 */
  offset: 624,
  buffer: buffer24,
}, {
  texture: texture8,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder115 = device0.createCommandEncoder();
let texture93 = device0.createTexture({
  size: [15, 10, 1],
  mipLevelCount: 2,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder87.setBindGroup(0, bindGroup46);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer58, 664); };
} catch {}
try {
computePassEncoder94.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup9, []);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup37, new Uint32Array(3183), 0, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer54, 'uint32', 148, 944);
} catch {}
try {
commandEncoder22.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2008 */
  offset: 2008,
  buffer: buffer1,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture94 = device0.createTexture({
  size: {width: 365},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let renderPassEncoder30 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView37,
  clearValue: { r: 569.2, g: -188.5, b: -142.2, a: -394.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 39273418,
});
let sampler68 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMinClamp: 51.76,
  lodMaxClamp: 94.59,
  compare: 'less-equal',
});
try {
computePassEncoder67.setBindGroup(0, bindGroup37);
} catch {}
try {
computePassEncoder91.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder22.setBlendConstant({ r: -603.5, g: -946.8, b: -758.1, a: 147.4, });
} catch {}
let arrayBuffer9 = buffer0.getMappedRange(160, 0);
let textureView90 = texture8.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 0});
let texture95 = device0.createTexture({
  size: [365],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView91 = texture86.createView({aspect: 'depth-only', mipLevelCount: 2, baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder97 = commandEncoder113.beginComputePass({});
try {
computePassEncoder97.setBindGroup(0, bindGroup19);
} catch {}
try {
computePassEncoder49.setBindGroup(3, bindGroup46, new Uint32Array(771), 293, 0);
} catch {}
try {
computePassEncoder95.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer34, 0);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 60, height: 40, depthOrArrayLayers: 1}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 18, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let textureView92 = texture90.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
let computePassEncoder98 = commandEncoder112.beginComputePass({});
try {
renderPassEncoder14.setBindGroup(0, bindGroup23, new Uint32Array(5688), 921, 0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer44, 248);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer52, 1_624);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline5);
} catch {}
try {
commandEncoder115.copyTextureToTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder84.pushDebugGroup('\ubd32');
} catch {}
let commandEncoder116 = device0.createCommandEncoder({});
let computePassEncoder99 = commandEncoder114.beginComputePass();
try {
computePassEncoder87.setBindGroup(0, bindGroup10, new Uint32Array(1884), 82, 0);
} catch {}
try {
renderPassEncoder8.draw(0, 53, 0, 15_202_756);
} catch {}
try {
renderPassEncoder8.drawIndexed(661, 138, 623, 70_577_105, 193_396_866);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer17, 260);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(3, buffer61);
} catch {}
try {
buffer71.unmap();
} catch {}
try {
commandEncoder115.resolveQuerySet(querySet12, 186, 94, buffer47, 256);
} catch {}
canvas0.height = 1745;
let commandEncoder117 = device0.createCommandEncoder({});
let textureView93 = texture94.createView({});
let computePassEncoder100 = commandEncoder117.beginComputePass({});
try {
computePassEncoder82.setBindGroup(0, bindGroup23, new Uint32Array(346), 15, 0);
} catch {}
try {
computePassEncoder100.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer37, 1_196);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(1, buffer17, 92);
} catch {}
try {
commandEncoder115.resolveQuerySet(querySet13, 6, 96, buffer6, 256);
} catch {}
try {
computePassEncoder84.popDebugGroup();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let commandEncoder118 = device0.createCommandEncoder({});
let textureView94 = texture40.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 8, arrayLayerCount: 1});
let textureView95 = texture80.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder101 = commandEncoder115.beginComputePass({});
try {
renderPassEncoder13.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(114);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer7, 108, 22);
} catch {}
let pipeline20 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'dst'},
  },
  writeMask: 0,
}],
},
  depthStencil: {
    format: 'depth16unorm',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilReadMask: 131690326,
    stencilWriteMask: 412967674,
    depthBias: -1424662855,
    depthBiasSlopeScale: 326.43745563711553,
  },
  vertex: {
    module: shaderModule3,
    constants: {},
    buffers: [
      {
        arrayStride: 8,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 11},
          {format: 'uint16x2', offset: 0, shaderLocation: 1},
        ],
      },
    ],
  },
});
let computePassEncoder102 = commandEncoder118.beginComputePass({});
let sampler69 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.57,
  maxAnisotropy: 14,
});
try {
computePassEncoder40.setBindGroup(3, bindGroup25, new Uint32Array(369), 99, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer50, 'uint16', 708, 3_389);
} catch {}
let arrayBuffer10 = buffer47.getMappedRange();
try {
commandEncoder29.copyTextureToBuffer({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2416 */
  offset: 2416,
  bytesPerRow: 12800,
  buffer: buffer52,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture61,
  mipLevel: 1,
  origin: {x: 71, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(27_175).fill(217), /* required buffer size: 27_175 */
{offset: 148, bytesPerRow: 297, rowsPerImage: 7}, {width: 148, height: 0, depthOrArrayLayers: 14});
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
document.body.append(canvas1);
let autogeneratedBindGroupLayout11 = pipeline18.getBindGroupLayout(0);
let commandEncoder119 = device0.createCommandEncoder({});
let texture96 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 12},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let sampler70 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMaxClamp: 61.89,
});
try {
renderPassEncoder23.setBindGroup(0, bindGroup24);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup5, new Uint32Array(65), 1, 0);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setScissorRect(0, 25, 0, 7);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer33, 'uint16', 1_762, 849);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(3, buffer13, 0, 574);
} catch {}
let arrayBuffer11 = buffer21.getMappedRange(48, 28);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 60, height: 40, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap1,
  origin: { x: 0, y: 4 },
  flipY: false,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 32, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); };
} catch {}
try {
globalThis.someLabel = externalTexture5.label;
} catch {}
let textureView96 = texture19.createView({});
let computePassEncoder103 = commandEncoder29.beginComputePass({});
try {
computePassEncoder97.setBindGroup(0, bindGroup40);
} catch {}
try {
computePassEncoder74.setBindGroup(0, bindGroup8, new Uint32Array(4169), 577, 0);
} catch {}
try {
renderPassEncoder24.setBindGroup(1, bindGroup30);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer67, 'uint16', 2_426, 1_686);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(0, buffer57, 0, 8_187);
} catch {}
let promise19 = shaderModule2.getCompilationInfo();
try {
device0.queue.writeBuffer(buffer24, 464, new BigUint64Array(2343), 0, 484);
} catch {}
let pipeline21 = device0.createComputePipeline({layout: pipelineLayout6, compute: {module: shaderModule2, entryPoint: 'compute3'}});
let autogeneratedBindGroupLayout12 = pipeline7.getBindGroupLayout(0);
let bindGroup51 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout16,
  entries: [
    {binding: 48, resource: {buffer: buffer4, offset: 512, size: 3500}},
    {binding: 263, resource: {buffer: buffer43, offset: 1280, size: 1092}},
  ],
});
let buffer76 = device0.createBuffer({size: 30500, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture97 = device0.createTexture({
  size: [30, 20, 286],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder95.setBindGroup(0, bindGroup15, []);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup24, new Uint32Array(232), 57, 0);
} catch {}
try {
renderPassEncoder29.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(1, buffer57, 2_624, 4_012);
} catch {}
let buffer77 = device0.createBuffer({
  size: 21087,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandBuffer10 = commandEncoder116.finish();
let textureView97 = texture56.createView({});
let sampler71 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.11,
  maxAnisotropy: 13,
});
try {
computePassEncoder99.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer7, 'uint32', 156, 2);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeBuffer(buffer24, 972, new BigUint64Array(2753), 649, 40);
} catch {}
try {
  await promise19;
} catch {}
let autogeneratedBindGroupLayout13 = pipeline9.getBindGroupLayout(0);
let commandEncoder120 = device0.createCommandEncoder({});
let sampler72 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 35.84,
  lodMaxClamp: 41.80,
});
try {
computePassEncoder68.setBindGroup(3, bindGroup43);
} catch {}
try {
computePassEncoder81.setBindGroup(0, bindGroup5, new Uint32Array(462), 76, 0);
} catch {}
try {
computePassEncoder102.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer54, 'uint16', 34, 615);
} catch {}
try {
commandEncoder120.copyTextureToBuffer({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 1, y: 8, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 112 */
  offset: 112,
  bytesPerRow: 91648,
  buffer: buffer24,
}, {width: 4, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder120.insertDebugMarker('\u{1f9e6}');
} catch {}
try {
renderPassEncoder29.insertDebugMarker('\u96ee');
} catch {}
let computePassEncoder104 = commandEncoder120.beginComputePass();
try {
computePassEncoder103.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder26.executeBundles([renderBundle1, renderBundle7, renderBundle0, renderBundle13, renderBundle13]);
} catch {}
try {
device0.queue.writeBuffer(buffer8, 1188, new Float32Array(2716), 430, 124);
} catch {}
try {
adapter0.label = '\u404e\u{1f7d2}\ueb57\u{1f789}\u{1fd49}\u9dda\u1e7a\u{1fbee}\u0d73\u{1f86e}';
} catch {}
let buffer78 = device0.createBuffer({
  size: 10874,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder121 = device0.createCommandEncoder();
let sampler73 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  lodMaxClamp: 76.86,
  maxAnisotropy: 1,
});
try {
computePassEncoder64.setBindGroup(2, bindGroup27);
} catch {}
try {
computePassEncoder98.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline18);
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'film', transfer: 'iec61966-2-1'} });
let texture98 = device0.createTexture({
  label: '\u46b1\u{1fbd8}\u660f\u0be3\u{1f7ce}\u{1fe22}\u{1fc19}\u0aaf',
  size: [30, 12, 1],
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder105 = commandEncoder119.beginComputePass();
try {
computePassEncoder46.setBindGroup(0, bindGroup31);
} catch {}
try {
computePassEncoder97.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder24.setBindGroup(2, bindGroup28);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer16, 'uint32', 11_624, 926);
} catch {}
try {
commandEncoder121.copyBufferToBuffer(buffer69, 2576, buffer48, 2092, 308);
} catch {}
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 39,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {binding: 47, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 111,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 118, visibility: 0, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let texture99 = device0.createTexture({
  size: {width: 1460, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder106 = commandEncoder121.beginComputePass();
let sampler74 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 70.67});
try {
computePassEncoder97.setBindGroup(0, bindGroup29, new Uint32Array(65), 23, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup3);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer1, 2_984); };
} catch {}
try {
computePassEncoder105.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder26.setBindGroup(1, bindGroup28);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer31);
} catch {}
let arrayBuffer12 = buffer0.getMappedRange(128, 0);
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder122 = device0.createCommandEncoder({label: '\u74a0\u{1f76e}'});
let texture100 = device0.createTexture({
  size: {width: 120},
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder107 = commandEncoder122.beginComputePass({});
try {
computePassEncoder76.setBindGroup(0, bindGroup38, new Uint32Array(7443), 2_560, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer16, 'uint16', 3_588, 3_512);
} catch {}
let commandEncoder123 = device0.createCommandEncoder({});
let textureView98 = texture80.createView({});
let computePassEncoder108 = commandEncoder123.beginComputePass({});
let externalTexture20 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'srgb'});
try {
computePassEncoder79.setBindGroup(0, bindGroup38);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup20, new Uint32Array(3811), 161, 0);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle0, renderBundle11, renderBundle11]);
} catch {}
let pipeline22 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  fragment: {module: shaderModule0, entryPoint: 'fragment0', targets: [{format: 'rg8sint'}]},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex4',
    constants: {},
    buffers: [
      {
        arrayStride: 196,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 36, shaderLocation: 5},
          {format: 'unorm16x2', offset: 4, shaderLocation: 3},
          {format: 'snorm8x4', offset: 12, shaderLocation: 9},
          {format: 'float32x3', offset: 0, shaderLocation: 10},
          {format: 'snorm16x4', offset: 64, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
let sampler75 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', compare: 'greater'});
try {
computePassEncoder99.setBindGroup(0, bindGroup28);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder106.setPipeline(pipeline21);
} catch {}
let pipeline23 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  constants: {},
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {module: shaderModule5, constants: {}, buffers: []},
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', unclippedDepth: true},
});
let commandEncoder124 = device0.createCommandEncoder({});
let textureView99 = texture94.createView({});
try {
computePassEncoder101.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline1);
} catch {}
try {
commandEncoder124.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 148 */
  offset: 148,
  buffer: buffer38,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 41, y: 4, z: 0},
  aspect: 'all',
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 3, height: 99, depthOrArrayLayers: 51}
*/
{
  source: imageData4,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 10},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let texture101 = device0.createTexture({
  size: [60, 40, 573],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder31 = commandEncoder124.beginRenderPass({
  colorAttachments: [{
  view: textureView78,
  clearValue: { r: 246.3, g: 839.2, b: 985.2, a: 11.28, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet12,
});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({
  label: '\u3975\u9b2f\u{1ff9e}\u3507\u0fbb\u0f0f\u{1f8a6}\uba19\u0d89\u3d3a\u4fa4',
  colorFormats: ['rg8unorm'],
  depthStencilFormat: 'depth16unorm',
  stencilReadOnly: true,
});
try {
renderPassEncoder23.setIndexBuffer(buffer12, 'uint32', 10_720, 1_633);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(3, buffer66, 0, 1_969);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup25);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline11);
} catch {}
let autogeneratedBindGroupLayout14 = pipeline16.getBindGroupLayout(0);
let commandEncoder125 = device0.createCommandEncoder({});
try {
computePassEncoder107.setPipeline(pipeline3);
} catch {}
try {
commandEncoder125.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 1,
  origin: {x: 27, y: 0, z: 5},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 268 */
  offset: 268,
  bytesPerRow: 48128,
  buffer: buffer63,
}, {width: 6, height: 14, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let sampler76 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', magFilter: 'linear', lodMaxClamp: 99.55});
try {
computePassEncoder94.setBindGroup(2, bindGroup34, []);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup15, new Uint32Array(3824), 1_900, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer27, 'uint16', 5_138, 30);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer46, 0, 31);
} catch {}
try {
commandEncoder125.resolveQuerySet(querySet2, 10, 9, buffer24, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer75, 104, new DataView(new ArrayBuffer(9858)), 5164, 60);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let texture102 = device0.createTexture({
  size: {width: 15, height: 6, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder109 = commandEncoder125.beginComputePass({});
try {
computePassEncoder70.setBindGroup(0, bindGroup37);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder76); computePassEncoder76.dispatchWorkgroupsIndirect(buffer34, 976); };
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer17);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup23, []);
} catch {}
try {
if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55); };
} catch {}
let bindGroup52 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 167, resource: textureView6}, {binding: 235, resource: textureView97}],
});
let commandEncoder126 = device0.createCommandEncoder({});
let textureView100 = texture10.createView({dimension: 'cube-array', format: 'rg8sint', arrayLayerCount: 6});
let computePassEncoder110 = commandEncoder126.beginComputePass({});
try {
computePassEncoder86.setBindGroup(1, bindGroup50, []);
} catch {}
try {
computePassEncoder27.setBindGroup(0, bindGroup28, new Uint32Array(1084), 228, 0);
} catch {}
try {
computePassEncoder82.setPipeline(pipeline21);
} catch {}
try {
computePassEncoder108.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder31.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup2, new Uint32Array(79), 22, 0);
} catch {}
let canvas2 = document.createElement('canvas');
let shaderModule6 = device0.createShaderModule({
  code: `
enable f16;

enable f16;

requires packed_4x8_integer_dot_product;

diagnostic(info, xyz);

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

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

var<workgroup> vw16: mat2x4f;

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

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

@group(0) @binding(235) var tex7: texture_2d<f32>;

fn fn1() {
}

var<workgroup> vw15: array<array<atomic<u32>, 1>, 3>;

struct VertexOutput7 {
  @location(2) @interpolate(flat, centroid) f17: vec2u,
  @builtin(position) f18: vec4f,
  @location(14) @interpolate(flat, centroid) f19: vec2u,
  @location(7) @interpolate(flat, center) f20: vec4u,
}

alias vec3b = vec3<bool>;

struct T1 {
  @size(576) f0: mat3x4f,
  @align(4) @size(320) f1: f16,
  @align(4) @size(448) f2: f16,
  @align(8) @size(64) f3: array<array<mat2x2h, 3>, 1>,
  @align(32) @size(1024) f4: array<array<array<array<array<vec2h, 1>, 1>, 1>, 5>, 23>,
  @align(64) @size(320) f5: array<array<array<array<mat2x2h, 15>, 1>, 1>, 1>,
  @size(64) f6: array<vec4i, 2>,
  @size(704) f7: T0,
  @align(64) @size(64) f8: array<array<array<array<vec4i, 1>, 1>, 1>, 1>,
  @size(384) f9: array<array<array<array<vec2i, 1>, 1>, 3>, 1>,
  @align(64) @size(64) f10: mat2x4h,
  @align(64) @size(1088) f11: f32,
  @align(64) @size(64) f12: array<mat2x4f, 1>,
  @align(64) @size(128) f13: array<i32, 1>,
  @size(256) f14: mat2x2h,
  @align(16) @size(64) f15: f16,
  @align(64) @size(320) f16: mat3x3f,
}

fn fn0(a0: VertexOutput7) {
  var vf80: bool = any(bool(unconst_bool(false)));
  var vf81: vec2h = reflect(vec2h(unconst_f16(28107.9), unconst_f16(4694.1)), vec2h(unconst_f16(6359.9), unconst_f16(4620.1)));
  var vf82: vec4h = tanh(vec4h(unconst_f16(-15169.6), unconst_f16(4948.4), unconst_f16(2291.8), unconst_f16(1938.1)));
  vf82 = bitcast<vec4h>(a0.f17);
  vf80 = bool(cosh(vec4h(unconst_f16(5573.9), unconst_f16(4648.0), unconst_f16(-31704.1), unconst_f16(20898.5)))[0]);
  var vf83: f16 = acos(f16(unconst_f16(17784.1)));
  var vf84: vec4f = textureLoad(tex7, vec2i(unconst_i32(382), unconst_i32(650)), i32(unconst_i32(38)));
  vf81 *= vec2h(a0.f20.xw);
  let ptr75: ptr<function, vec4f> = &vf84;
  var vf85: u32 = countOneBits(u32(unconst_u32(40)));
  let vf86: u32 = a0.f20[u32(unconst_u32(334))];
  vf85 += a0.f17.r;
  vf83 = f16(pack4xU8(vec4u(unconst_u32(693), unconst_u32(2), unconst_u32(597), unconst_u32(61))));
  vf85 |= u32((*ptr75)[3]);
  vf82 -= vec4h(f16(countOneBits(u32(unconst_u32(48)))));
  let ptr76: ptr<function, f16> = &vf83;
  _ = tex7;
}

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

struct T0 {
  @align(8) f0: array<array<vec2h, 1>, 8>,
  @size(112) f1: array<array<array<mat3x2f, 1>, 1>, 2>,
  @size(376) f2: array<mat4x2f, 3>,
}

@vertex
fn vertex7(@location(7) a0: vec4i, @builtin(instance_index) a1: u32) -> VertexOutput7 {
  var out: VertexOutput7;
  let vf87: u32 = countOneBits(u32(unconst_u32(286)));
  fn1();
  fn1();
  out.f19 &= vec2u(vf87);
  out.f17 = vec2u(unpack2x16float(textureDimensions(tex7).x));
  out.f19 = vec2u(u32(a0[u32(unconst_u32(598))]));
  out.f19 -= vec2u(bitcast<u32>(degrees(f32(unconst_f32(0.07628)))));
  fn0(VertexOutput7());
  fn0(VertexOutput7());
  out.f17 |= bitcast<vec2u>(step(step(vec4h(unconst_f16(16749.5), unconst_f16(73.64), unconst_f16(10675.6), unconst_f16(53.22)), vec4h(unconst_f16(16939.9), unconst_f16(5132.9), unconst_f16(12347.9), unconst_f16(-11458.9))), vec4h(unconst_f16(6591.5), unconst_f16(171.7), unconst_f16(6311.6), unconst_f16(7107.0))));
  out.f20 = vec4u(u32(a0[u32(unconst_u32(174))]));
  out.f19 = vec2u(textureNumLevels(tex7));
  var vf88: vec2u = textureDimensions(tex7, i32(unconst_i32(76)));
  let vf89: u32 = textureNumLevels(tex7);
  var vf90: u32 = a1;
  vf90 = pack2x16snorm(exp2(vec2f(unconst_f32(0.2449), unconst_f32(0.1903))));
  let vf91: u32 = vf88[u32(unconst_u32(88))];
  return out;
  _ = tex7;
}

@compute @workgroup_size(2, 1, 1)
fn compute8(@builtin(local_invocation_index) a0: u32, @builtin(global_invocation_id) a1: vec3u) {
  vw16 = mat2x4f(bitcast<f32>(atomicExchange(&vw15[2][0], atomicLoad(&vw15[u32(unconst_u32(67))][u32(unconst_u32(14))]))), bitcast<f32>(atomicExchange(&vw15[2][0], atomicLoad(&vw15[u32(unconst_u32(67))][u32(unconst_u32(14))]))), f32(atomicExchange(&vw15[2][0], atomicLoad(&vw15[u32(unconst_u32(67))][u32(unconst_u32(14))]))), f32(atomicExchange(&vw15[2][0], atomicLoad(&vw15[u32(unconst_u32(67))][u32(unconst_u32(14))]))), f32(atomicExchange(&vw15[2][0], atomicLoad(&vw15[u32(unconst_u32(67))][u32(unconst_u32(14))]))), f32(atomicExchange(&vw15[2][0], atomicLoad(&vw15[u32(unconst_u32(67))][u32(unconst_u32(14))]))), bitcast<f32>(atomicExchange(&vw15[2][0], atomicLoad(&vw15[u32(unconst_u32(67))][u32(unconst_u32(14))]))), f32(atomicExchange(&vw15[2][0], atomicLoad(&vw15[u32(unconst_u32(67))][u32(unconst_u32(14))]))));
  fn1();
  fn0(VertexOutput7(vec2u(unconst_u32(96), unconst_u32(285)), vec4f(unconst_f32(-0.7613), unconst_f32(0.04611), unconst_f32(0.09421), unconst_f32(0.01165)), vec2u(unconst_u32(250), unconst_u32(116)), vec4u(unconst_u32(128), unconst_u32(210), unconst_u32(84), unconst_u32(253))));
  fn0(VertexOutput7(vec2u(u32((*&vw16)[u32(unconst_u32(96))][u32(unconst_u32(0))])), vec4f((*&vw16)[u32(unconst_u32(96))][u32(unconst_u32(0))]), vec2u(bitcast<u32>((*&vw16)[u32(unconst_u32(96))][u32(unconst_u32(0))])), unpack4xU8(bitcast<u32>((*&vw16)[u32(unconst_u32(96))][u32(unconst_u32(0))]))));
  let ptr77: ptr<workgroup, atomic<u32>> = &(*&vw15)[2][0];
  fn1();
  vw16 = mat2x4f(bitcast<f32>(atomicExchange(&vw15[2][u32(unconst_u32(72))], u32(unconst_u32(70)))), f32(atomicExchange(&vw15[2][u32(unconst_u32(72))], u32(unconst_u32(70)))), f32(atomicExchange(&vw15[2][u32(unconst_u32(72))], u32(unconst_u32(70)))), f32(atomicExchange(&vw15[2][u32(unconst_u32(72))], u32(unconst_u32(70)))), f32(atomicExchange(&vw15[2][u32(unconst_u32(72))], u32(unconst_u32(70)))), f32(atomicExchange(&vw15[2][u32(unconst_u32(72))], u32(unconst_u32(70)))), f32(atomicExchange(&vw15[2][u32(unconst_u32(72))], u32(unconst_u32(70)))), f32(atomicExchange(&vw15[2][u32(unconst_u32(72))], u32(unconst_u32(70)))));
  atomicCompareExchangeWeak(&vw15[2][u32(unconst_u32(70))], unconst_u32(82), unconst_u32(95));
  fn0(VertexOutput7(bitcast<vec2u>(cross(vec3f(unconst_f32(0.1217), unconst_f32(0.01567), unconst_f32(0.2458)), vec3f(unconst_f32(0.1187), unconst_f32(0.03085), unconst_f32(0.06318))).zz), cross(vec3f(unconst_f32(0.1217), unconst_f32(0.01567), unconst_f32(0.2458)), vec3f(unconst_f32(0.1187), unconst_f32(0.03085), unconst_f32(0.06318))).xyzx, bitcast<vec2u>(cross(vec3f(unconst_f32(0.1217), unconst_f32(0.01567), unconst_f32(0.2458)), vec3f(unconst_f32(0.1187), unconst_f32(0.03085), unconst_f32(0.06318))).yz), bitcast<vec4u>(cross(vec3f(unconst_f32(0.1217), unconst_f32(0.01567), unconst_f32(0.2458)), vec3f(unconst_f32(0.1187), unconst_f32(0.03085), unconst_f32(0.06318))).yzxy)));
  atomicMin(&vw15[u32(unconst_u32(350))][u32(unconst_u32(30))], u32(unconst_u32(216)));
  let ptr78: ptr<workgroup, atomic<u32>> = &(*&vw15)[2][u32(unconst_u32(124))];
  let vf92: u32 = atomicLoad(&(*ptr77));
  let ptr79: ptr<workgroup, atomic<u32>> = &vw15[u32(unconst_u32(0))][0];
  fn1();
  var vf93: u32 = atomicLoad(&(*ptr79));
  vw16 = mat2x4f(f32(atomicLoad(&(*&vw15)[u32(unconst_u32(23))][0])), f32(atomicLoad(&(*&vw15)[u32(unconst_u32(23))][0])), f32(atomicLoad(&(*&vw15)[u32(unconst_u32(23))][0])), bitcast<f32>(atomicLoad(&(*&vw15)[u32(unconst_u32(23))][0])), f32(atomicLoad(&(*&vw15)[u32(unconst_u32(23))][0])), bitcast<f32>(atomicLoad(&(*&vw15)[u32(unconst_u32(23))][0])), f32(atomicLoad(&(*&vw15)[u32(unconst_u32(23))][0])), bitcast<f32>(atomicLoad(&(*&vw15)[u32(unconst_u32(23))][0])));
  vw16 -= mat2x4f(f32(a0), bitcast<f32>(a0), f32(a0), bitcast<f32>(a0), f32(a0), bitcast<f32>(a0), bitcast<f32>(a0), bitcast<f32>(a0));
  let vf94: vec4f = vw16[u32(unconst_u32(127))];
  fn1();
  _ = tex7;
}

@compute @workgroup_size(1, 1, 1)
fn compute9() {
  vw16 = mat2x4f(f32(atomicLoad(&(*&vw15)[2][0])), f32(atomicLoad(&(*&vw15)[2][0])), bitcast<f32>(atomicLoad(&(*&vw15)[2][0])), bitcast<f32>(atomicLoad(&(*&vw15)[2][0])), f32(atomicLoad(&(*&vw15)[2][0])), bitcast<f32>(atomicLoad(&(*&vw15)[2][0])), bitcast<f32>(atomicLoad(&(*&vw15)[2][0])), bitcast<f32>(atomicLoad(&(*&vw15)[2][0])));
  vw16 = mat2x4f(bitcast<vec4f>(textureDimensions(tex7, i32(unconst_i32(81))).gggr), bitcast<vec4f>(textureDimensions(tex7, i32(unconst_i32(81))).rrgr));
  _ = tex7;
}

@compute @workgroup_size(2, 1, 4)
fn compute10(@builtin(local_invocation_index) a0: u32, @builtin(num_workgroups) a1: vec3u) {
  fn1();
  vw16 = workgroupUniformLoad(&vw16);
  let vf95: u32 = atomicLoad(&vw15[2][0]);
  var vf96: vec3f = acosh(vec3f(unconst_f32(0.00992), unconst_f32(-0.1068), unconst_f32(-0.2057)));
  fn1();
  fn0(VertexOutput7(textureDimensions(tex7, i32(unconst_i32(326))), vec4f(textureDimensions(tex7, i32(unconst_i32(326))).xxxy), textureDimensions(tex7, i32(unconst_i32(326))), textureDimensions(tex7, i32(unconst_i32(326))).yxyx));
  let ptr80: ptr<workgroup, atomic<u32>> = &(*&vw15)[2][u32(unconst_u32(3))];
  _ = tex7;
}`,
});
let buffer79 = device0.createBuffer({
  size: 667,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder127 = device0.createCommandEncoder({});
let computePassEncoder111 = commandEncoder127.beginComputePass({});
let renderBundle14 = renderBundleEncoder14.finish();
try {
computePassEncoder95.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup0, new Uint32Array(622), 16, 0);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline17);
} catch {}
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 285,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '2d-array' },
    },
  ],
});
let recycledExplicitBindGroupLayout26 = pipeline17.getBindGroupLayout(0);
let commandEncoder128 = device0.createCommandEncoder({});
let textureView101 = texture71.createView({dimension: '2d-array'});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true});
try {
computePassEncoder24.setBindGroup(3, bindGroup49);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup30, new Uint32Array(1121), 59, 0);
} catch {}
let arrayBuffer13 = buffer21.getMappedRange(104, 16);
try {
device0.queue.writeTexture({
  texture: texture99,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(162).fill(243), /* required buffer size: 162 */
{offset: 162, rowsPerImage: 11}, {width: 269, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder129 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  label: '\u4dce\u{1fc31}\u{1fbbb}\u0c91\ud014\ua430\u0335\ub1d4',
  size: [16, 16, 12],
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture104 = device0.createTexture({
  size: [6],
  dimension: '1d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder16.setViewport(11.203813467479552, 112.63965353351516, 0.315959270086216, 200.0918384132011, 0.343165345683467, 0.3700050479867384);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup0, new Uint32Array(1040), 243, 0);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(3, buffer12, 0, 1_987);
} catch {}
try {
commandEncoder128.copyBufferToBuffer(buffer61, 804, buffer55, 2028, 2780);
} catch {}
try {
commandEncoder128.copyTextureToBuffer({
  texture: texture87,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 838 */
  offset: 838,
  buffer: buffer2,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder130 = device0.createCommandEncoder({});
let texture105 = device0.createTexture({
  size: {width: 120, height: 48, depthOrArrayLayers: 77},
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle15 = renderBundleEncoder15.finish();
try {
computePassEncoder111.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer9, 120, 271);
} catch {}
let gpuCanvasContext3 = canvas2.getContext('webgpu');
await gc();
let buffer80 = device0.createBuffer({size: 2506, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture106 = device0.createTexture({
  size: [730],
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder57.setBindGroup(3, bindGroup28);
} catch {}
try {
device0.queue.submit([commandBuffer10]);
} catch {}
let commandEncoder131 = device0.createCommandEncoder({});
let texture107 = device0.createTexture({size: [60, 24, 1], format: 'rgba32sint', usage: GPUTextureUsage.STORAGE_BINDING, viewFormats: []});
try {
renderPassEncoder11.setBindGroup(0, bindGroup52, new Uint32Array(945), 24, 0);
} catch {}
try {
buffer31.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer48, 888, new BigUint64Array(13536), 512, 24);
} catch {}
document.body.append(canvas2);
let commandEncoder132 = device0.createCommandEncoder({});
let texture108 = device0.createTexture({
  size: {width: 60, height: 24, depthOrArrayLayers: 1},
  format: 'rgba8snorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture109 = device0.createTexture({
  size: {width: 15, height: 10, depthOrArrayLayers: 143},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView102 = texture77.createView({aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder64.setBindGroup(0, bindGroup3, new Uint32Array(3003), 1_083, 0);
} catch {}
try {
computePassEncoder109.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup4);
} catch {}
let textureView103 = texture108.createView({});
let computePassEncoder112 = commandEncoder131.beginComputePass();
let renderPassEncoder32 = commandEncoder128.beginRenderPass({
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: 952.1, g: -741.3, b: 472.5, a: -47.24, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 52440599,
});
let sampler77 = device0.createSampler({addressModeU: 'repeat'});
try {
computePassEncoder75.setBindGroup(3, bindGroup28, new Uint32Array(2531), 55, 0);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle1, renderBundle11]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer27, 'uint32', 1_316, 4_050);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(3, buffer16, 420, 2_243);
} catch {}
try {
commandEncoder130.copyTextureToBuffer({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1144 */
  offset: 1144,
  bytesPerRow: 26624,
  buffer: buffer76,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder132.clearBuffer(buffer21, 1056, 1592);
} catch {}
let textureView104 = texture107.createView({});
try {
computePassEncoder49.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline18);
} catch {}
let commandEncoder133 = device0.createCommandEncoder({});
let textureView105 = texture106.createView({});
let texture110 = device0.createTexture({
  size: {width: 365, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder113 = commandEncoder133.beginComputePass({});
let sampler78 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 93.91});
let commandEncoder134 = device0.createCommandEncoder({});
let sampler79 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.62,
  compare: 'not-equal',
});
try {
computePassEncoder109.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder3.setBindGroup(0, bindGroup48, new Uint32Array(974), 56, 0);
} catch {}
try {
computePassEncoder104.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle11, renderBundle11, renderBundle7, renderBundle3, renderBundle7, renderBundle3, renderBundle11]);
} catch {}
try {
buffer60.unmap();
} catch {}
let commandEncoder135 = device0.createCommandEncoder({});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true});
let sampler80 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 70.24});
try {
computePassEncoder20.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline18);
} catch {}
let arrayBuffer14 = buffer0.getMappedRange(136, 0);
try {
buffer27.unmap();
} catch {}
try {
commandEncoder130.copyBufferToBuffer(buffer70, 924, buffer63, 1020, 132);
} catch {}
let recycledExplicitBindGroupLayout27 = pipeline12.getBindGroupLayout(0);
let buffer81 = device0.createBuffer({size: 14575, usage: GPUBufferUsage.MAP_READ});
let commandEncoder136 = device0.createCommandEncoder();
try {
{ clearResourceUsages(device0, computePassEncoder68); computePassEncoder68.dispatchWorkgroupsIndirect(buffer36, 672); };
} catch {}
try {
computePassEncoder110.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup23);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline1);
} catch {}
try {
commandEncoder129.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3360 */
  offset: 3360,
  buffer: buffer1,
}, {
  texture: texture63,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 1},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise20 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule1,
  targets: [{
  format: 'rg8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 168,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x2', offset: 4, shaderLocation: 11}],
      },
      {
        arrayStride: 488,
        stepMode: 'vertex',
        attributes: [{format: 'uint8x4', offset: 12, shaderLocation: 1}],
      },
    ],
  },
  primitive: {topology: 'point-list', unclippedDepth: true},
});
let textureView106 = texture72.createView({dimension: '2d-array'});
let computePassEncoder114 = commandEncoder129.beginComputePass({});
try {
renderPassEncoder28.setBindGroup(2, bindGroup49);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer46, 'uint16', 2_058, 81);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer61);
} catch {}
let buffer82 = device0.createBuffer({size: 17039, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let textureView107 = texture36.createView({dimension: '2d-array', arrayLayerCount: 1});
let computePassEncoder115 = commandEncoder134.beginComputePass({});
let renderBundle16 = renderBundleEncoder16.finish({});
try {
renderPassEncoder20.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup23, new Uint32Array(2237), 428, 0);
} catch {}
try {
commandEncoder132.copyTextureToBuffer({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2102 */
  offset: 2102,
  bytesPerRow: 20736,
  buffer: buffer31,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeBuffer(buffer6, 116, new DataView(new ArrayBuffer(5795)), 1200, 424);
} catch {}
let recycledExplicitBindGroupLayout28 = pipeline13.getBindGroupLayout(0);
let buffer83 = device0.createBuffer({size: 4122, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder137 = device0.createCommandEncoder({});
let renderPassEncoder33 = commandEncoder136.beginRenderPass({colorAttachments: [{view: textureView13, loadOp: 'clear', storeOp: 'store'}]});
try {
computePassEncoder113.setPipeline(pipeline15);
} catch {}
let imageData10 = new ImageData(32, 40);
let querySet16 = device0.createQuerySet({type: 'occlusion', count: 4096});
let textureView108 = texture61.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder116 = commandEncoder135.beginComputePass({});
let sampler81 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 73.29});
try {
computePassEncoder91.setBindGroup(0, bindGroup21, new Uint32Array(1635), 283, 0);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer66, 'uint32', 2_716, 453);
} catch {}
let arrayBuffer15 = buffer0.getMappedRange(144, 0);
try {
buffer34.unmap();
} catch {}
try {
commandEncoder132.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 272 */
  offset: 272,
  bytesPerRow: 19456,
  buffer: buffer27,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 16, height: 16, depthOrArrayLayers: 0});
} catch {}
await gc();
try {
sampler51.label = '\u8666\u{1fc6e}\udbad\u09a7\u0286';
} catch {}
let commandEncoder138 = device0.createCommandEncoder();
let texture111 = device0.createTexture({
  size: {width: 30, height: 20, depthOrArrayLayers: 286},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder117 = commandEncoder132.beginComputePass({});
let externalTexture21 = device0.importExternalTexture({source: videoFrame10});
try {
renderPassEncoder29.setBindGroup(2, bindGroup4, []);
} catch {}
try {
commandEncoder130.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3394 */
  offset: 3394,
  buffer: buffer53,
}, {
  texture: texture102,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture112 = device0.createTexture({
  size: [120, 48, 35],
  sampleCount: 1,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder118 = commandEncoder137.beginComputePass({});
try {
computePassEncoder108.setBindGroup(0, bindGroup20);
} catch {}
try {
computePassEncoder110.setBindGroup(0, bindGroup49, new Uint32Array(344), 52, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder53); computePassEncoder53.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup12, new Uint32Array(1176), 86, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder33.setPipeline(pipeline8);
} catch {}
try {
buffer30.unmap();
} catch {}
try {
commandEncoder130.insertDebugMarker('\u810e');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture112,
  mipLevel: 0,
  origin: {x: 13, y: 6, z: 4},
  aspect: 'all',
}, new Uint8Array(48_547).fill(115), /* required buffer size: 48_547 */
{offset: 435, bytesPerRow: 97, rowsPerImage: 62}, {width: 15, height: 0, depthOrArrayLayers: 9});
} catch {}
document.body.prepend(canvas2);
try {
adapter0.label = '\ufe70\u014b\u5a46\u0f30\u599b\ue5b4';
} catch {}
let buffer84 = device0.createBuffer({size: 47262, usage: GPUBufferUsage.MAP_WRITE});
let computePassEncoder119 = commandEncoder130.beginComputePass({});
try {
computePassEncoder61.setBindGroup(2, bindGroup40, new Uint32Array(101), 4, 0);
} catch {}
try {
computePassEncoder119.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup45, new Uint32Array(612), 24, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let arrayBuffer16 = buffer0.getMappedRange(376, 416);
let imageData11 = new ImageData(40, 72);
let bindGroup53 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 263, resource: {buffer: buffer42, offset: 1536}}],
});
let commandEncoder139 = device0.createCommandEncoder({});
let textureView109 = texture98.createView({dimension: '2d-array', aspect: 'depth-only', format: 'depth16unorm'});
let sampler82 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 64.83});
try {
computePassEncoder72.setBindGroup(1, bindGroup27);
} catch {}
try {
renderPassEncoder21.setViewport(10.911315587959162, 219.225073040463, 0.9767536726823787, 102.70168516380828, 0.3241149128479275, 0.8425488877742031);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline22);
} catch {}
try {
commandEncoder138.copyBufferToBuffer(buffer60, 632, buffer75, 772, 148);
} catch {}
try {
commandEncoder139.copyBufferToTexture({
  /* bytesInLastRow: 240 widthInBlocks: 120 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 6556 */
  offset: 6556,
  buffer: buffer36,
}, {
  texture: texture50,
  mipLevel: 0,
  origin: {x: 0, y: 12, z: 0},
  aspect: 'depth-only',
}, {width: 120, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer75, 160, new Int16Array(14550), 204, 60);
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

enable f16;

var<workgroup> vw21: FragmentOutput5;

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

struct FragmentOutput6 {
  @location(0) f0: vec4f,
  @location(1) @interpolate(flat) f1: vec2i,
}

var<workgroup> vw20: atomic<i32>;

struct FragmentOutput5 {
  @location(0) @interpolate(linear, centroid) f0: vec4f,
}

var<workgroup> vw23: i32;

var<workgroup> vw25: array<FragmentOutput6, 1>;

override override0: u32 = 55;

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

var<workgroup> vw19: FragmentOutput6;

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

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

var<workgroup> vw24: atomic<i32>;

var<workgroup> vw26: mat4x4f;

override override2: u32;

var<workgroup> vw18: FragmentOutput5;

var<workgroup> vw17: mat3x2h;

@id(17112) override override1: i32;

var<workgroup> vw22: FragmentOutput5;

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

var<workgroup> vw27: FragmentOutput6;

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

@fragment
fn fragment5() -> FragmentOutput5 {
  var out: FragmentOutput5;
  var vf97: vec4f = unpack4x8unorm(u32(unconst_u32(1)));
  vf97 = unpack2x16snorm(u32(unconst_u32(357))).grgg;
  var vf98: vec3h = faceForward(vec3h(unconst_f16(744.8), unconst_f16(9291.5), unconst_f16(2777.7)), vec3h(unconst_f16(2067.4), unconst_f16(9661.4), unconst_f16(34192.9)), vec3h(unconst_f16(-8263.4), unconst_f16(1034.2), unconst_f16(5476.3)));
  vf98 = vf98;
  out.f0 -= vec4f(vf98.rrbr);
  var vf99: vec3f = cosh(cosh(vec3f(bitcast<f32>(dot4U8Packed(u32(unconst_u32(163)), u32(unconst_u32(146)))))));
  out = FragmentOutput5(unpack4x8unorm(u32(unconst_u32(352))));
  return out;
}

@fragment
fn fragment6() -> FragmentOutput6 {
  var out: FragmentOutput6;
  out = FragmentOutput6(vec4f(f32(override2)), vec2i(i32(override2)));
  let vf100: f32 = floor(f32(unconst_f32(0.07919)));
  out.f1 *= vec2i(bitcast<i32>(override2));
  out = FragmentOutput6(quantizeToF16(vec2f(unconst_f32(0.3122), unconst_f32(0.3830))).grgg, vec2i(quantizeToF16(vec2f(unconst_f32(0.3122), unconst_f32(0.3830)))));
  out = FragmentOutput6(vec4f(bitcast<f32>(abs(abs(override1)))), vec2i(abs(abs(override1))));
  let vf101: bool = all(bool(unconst_bool(true)));
  var vf102: vec4h = sin(vec4h(unconst_f16(7265.6), unconst_f16(35447.5), unconst_f16(3551.5), unconst_f16(28554.2)));
  let vf103: u32 = pack2x16float(vec2f(unconst_f32(0.01088), unconst_f32(0.04485)));
  out.f1 -= vec2i(i32(pack2x16float(vec2f(unconst_f32(0.1036), unconst_f32(0.1782)))));
  var vf104: bool = all(bool(unconst_bool(false)));
  var vf105: f32 = vf100;
  vf102 -= step(vec3h(unconst_f16(20335.5), unconst_f16(9703.0), unconst_f16(97.30)), vec3h(unconst_f16(14935.1), unconst_f16(2132.9), unconst_f16(15468.0))).xyyz;
  var vf106: vec4h = sin(vec4h(unconst_f16(4735.7), unconst_f16(7368.4), unconst_f16(27197.2), unconst_f16(951.9)));
  var vf107: i32 = override1;
  var vf108: vec2h = fma(vec2h(unconst_f16(9150.0), unconst_f16(1676.7)), vec2h(unconst_f16(1135.0), unconst_f16(12568.4)), vec2h(unconst_f16(1233.2), unconst_f16(1313.5)));
  vf105 -= bitcast<f32>(pack2x16float(vec2f(unconst_f32(-0.00683), unconst_f32(0.09334))));
  let vf109: f32 = determinant(mat3x3f());
  out.f1 |= vec2i(i32(vf101));
  out = FragmentOutput6(vec4f(bitcast<f32>(vf107)), vec2i(vf107));
  vf108 = bitcast<vec2h>(override1);
  let vf110: bool = vf101;
  return out;
  _ = override2;
  _ = override1;
}`,
});
let computePassEncoder120 = commandEncoder139.beginComputePass();
try {
renderPassEncoder11.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(2, buffer57);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(118).fill(126), /* required buffer size: 118 */
{offset: 118, bytesPerRow: 13}, {width: 0, height: 20, depthOrArrayLayers: 0});
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 3, height: 99, depthOrArrayLayers: 1}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 13, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let canvas3 = document.createElement('canvas');
let imageBitmap3 = await createImageBitmap(canvas0);
try {
globalThis.someLabel = externalTexture1.label;
} catch {}
let buffer85 = device0.createBuffer({size: 29106, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView110 = texture98.createView({aspect: 'depth-only'});
let computePassEncoder121 = commandEncoder138.beginComputePass({});
try {
computePassEncoder75.setBindGroup(2, bindGroup28);
} catch {}
try {
computePassEncoder95.setBindGroup(0, bindGroup29, new Uint32Array(4226), 162, 0);
} catch {}
try {
renderPassEncoder31.executeBundles([renderBundle7, renderBundle5, renderBundle7, renderBundle5, renderBundle5, renderBundle16]);
} catch {}
try {
device0.queue.writeBuffer(buffer72, 1104, new Float32Array(11751), 632, 144);
} catch {}
document.body.prepend(canvas0);
let bindGroup54 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout19,
  entries: [
    {binding: 48, resource: {buffer: buffer24, offset: 3072, size: 644}},
    {binding: 263, resource: {buffer: buffer26, offset: 7168}},
  ],
});
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout14]});
let buffer86 = device0.createBuffer({size: 7839, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let querySet17 = device0.createQuerySet({type: 'occlusion', count: 447});
let textureView111 = texture37.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
let sampler83 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 89.41});
try {
computePassEncoder112.setBindGroup(3, bindGroup43, new Uint32Array(4443), 210, 0);
} catch {}
try {
computePassEncoder31.end();
} catch {}
try {
computePassEncoder121.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer30, 'uint16', 632, 1_496);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(4, buffer9, 0, 2_143);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let gpuCanvasContext4 = canvas3.getContext('webgpu');
let autogeneratedBindGroupLayout15 = pipeline23.getBindGroupLayout(0);
let texture113 = device0.createTexture({size: [15], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let renderPassEncoder34 = commandEncoder39.beginRenderPass({
  colorAttachments: [{
  view: textureView70,
  clearValue: { r: 73.16, g: 969.7, b: 236.5, a: 804.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  depthStencilAttachment: {view: textureView81, depthClearValue: 2.1067091097042194, depthReadOnly: true, stencilReadOnly: false},
  occlusionQuerySet: querySet0,
});
let sampler84 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', maxAnisotropy: 1});
try {
computePassEncoder32.setBindGroup(0, bindGroup12);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder31.setPipeline(pipeline14);
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt709', transfer: 'gamma28curve'} });
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 78,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let bindGroup55 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout25,
  entries: [
    {binding: 263, resource: {buffer: buffer1, offset: 512, size: 296}},
    {binding: 48, resource: {buffer: buffer42, offset: 256, size: 1104}},
  ],
});
let commandEncoder140 = device0.createCommandEncoder({});
let renderPassEncoder35 = commandEncoder140.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: 0.8671, g: 685.3, b: -936.8, a: -524.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let externalTexture22 = device0.importExternalTexture({source: videoFrame12});
try {
computePassEncoder97.setBindGroup(2, bindGroup38);
} catch {}
try {
renderPassEncoder32.setViewport(9.087881748309721, 67.39893124169647, 2.8051048061042914, 4.733451553551447, 0.26981275799613214, 0.46326962158470353);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer22, 'uint32', 120, 135);
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline6);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 12},
  aspect: 'all',
}, new Uint8Array(1_352).fill(9), /* required buffer size: 1_352 */
{offset: 112, bytesPerRow: 40, rowsPerImage: 31}, {width: 0, height: 0, depthOrArrayLayers: 2});
} catch {}
let commandEncoder141 = device0.createCommandEncoder();
let texture114 = device0.createTexture({
  size: [15, 6, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder122 = commandEncoder141.beginComputePass({});
let sampler85 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMaxClamp: 77.85,
  maxAnisotropy: 1,
});
let externalTexture23 = device0.importExternalTexture({source: videoFrame12});
try {
{ clearResourceUsages(device0, computePassEncoder76); computePassEncoder76.dispatchWorkgroupsIndirect(buffer79, 96); };
} catch {}
try {
computePassEncoder117.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer33, 'uint16', 1_036, 741);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
device0.queue.writeBuffer(buffer12, 640, new Int16Array(2087), 1192, 88);
} catch {}
document.body.append(canvas1);
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'bt1361ExtendedColourGamut'} });
let bindGroup56 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout9,
  entries: [
    {binding: 48, resource: {buffer: buffer41, offset: 0, size: 736}},
    {binding: 263, resource: {buffer: buffer40, offset: 256, size: 1004}},
  ],
});
let buffer87 = device0.createBuffer({size: 8573, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView112 = texture105.createView({dimension: '2d'});
let sampler86 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', addressModeW: 'repeat', lodMinClamp: 16.34});
try {
computePassEncoder42.setBindGroup(0, bindGroup41);
} catch {}
try {
computePassEncoder116.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup35);
} catch {}
try {
renderPassEncoder31.executeBundles([renderBundle15]);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer71, 'uint32', 756, 47);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline16);
} catch {}
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte170m', transfer: 'gamma22curve'} });
let buffer88 = device0.createBuffer({
  size: 1003,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture115 = device0.createTexture({
  size: {width: 15, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder108.setBindGroup(0, bindGroup29);
} catch {}
try {
computePassEncoder112.setPipeline(pipeline15);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
buffer60.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer24, 3512, new BigUint64Array(6450), 229, 552);
} catch {}
let buffer89 = device0.createBuffer({
  size: 2664,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
computePassEncoder96.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup35, new Uint32Array(2782), 883, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer82, 'uint32', 3_892, 1_589);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer4, 1264, new Float32Array(18611), 1344, 252);
} catch {}
let buffer90 = device0.createBuffer({
  size: 13074,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder142 = device0.createCommandEncoder({});
let textureView113 = texture114.createView({dimension: '2d-array', baseArrayLayer: 0});
try {
computePassEncoder80.setBindGroup(0, bindGroup5, new Uint32Array(490), 14, 0);
} catch {}
try {
computePassEncoder28.end();
} catch {}
try {
renderPassEncoder20.setScissorRect(5, 0, 83, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer13, 'uint32', 984, 570);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(0, buffer28, 428, 257);
} catch {}
let texture116 = device0.createTexture({
  size: {width: 15},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder123 = commandEncoder36.beginComputePass({});
try {
computePassEncoder120.setPipeline(pipeline12);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let recycledExplicitBindGroupLayout29 = pipeline10.getBindGroupLayout(0);
let textureView114 = texture116.createView({});
try {
computePassEncoder122.setPipeline(pipeline15);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer24, 3772, new Float32Array(8457), 2573, 100);
} catch {}
let commandEncoder143 = device0.createCommandEncoder({});
let texture117 = device0.createTexture({
  size: {width: 30, height: 20, depthOrArrayLayers: 286},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder124 = commandEncoder142.beginComputePass({label: '\uf02d\u0f0d\u0286\u{1f897}\u023d\u{1f7e3}\u8dfb\u5a16\u0b67\u{1feb9}'});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({
  colorFormats: ['rg8unorm'],
  depthStencilFormat: 'depth16unorm',
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle17 = renderBundleEncoder17.finish({});
try {
computePassEncoder101.setBindGroup(0, bindGroup33, new Uint32Array(1399), 75, 0);
} catch {}
try {
computePassEncoder124.setPipeline(pipeline3);
} catch {}
await gc();
let buffer91 = device0.createBuffer({
  size: 2280,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder144 = device0.createCommandEncoder({});
let texture118 = device0.createTexture({
  size: {width: 3, height: 99, depthOrArrayLayers: 14},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView115 = texture13.createView({dimension: '2d', format: 'rg8sint', baseMipLevel: 0, baseArrayLayer: 13});
try {
{ clearResourceUsages(device0, computePassEncoder70); computePassEncoder70.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder118.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup46);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer30, 'uint32', 3_488, 190);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline17);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer55, 4584, new Int16Array(2951), 197, 300);
} catch {}
let querySet18 = device0.createQuerySet({type: 'occlusion', count: 803});
let textureView116 = texture117.createView({});
let computePassEncoder125 = commandEncoder143.beginComputePass({});
try {
computePassEncoder123.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder14.drawIndexedIndirect(buffer89, 196);
} catch {}
try {
commandEncoder144.clearBuffer(buffer3);
} catch {}
let imageData12 = new ImageData(28, 32);
let buffer92 = device0.createBuffer({size: 106, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder145 = device0.createCommandEncoder({});
let texture119 = device0.createTexture({
  size: [60, 24, 49],
  dimension: '2d',
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['depth16unorm'],
});
let textureView117 = texture33.createView({dimension: '2d-array', baseArrayLayer: 0, arrayLayerCount: 1});
let computePassEncoder126 = commandEncoder144.beginComputePass({});
try {
computePassEncoder115.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder29.setBindGroup(3, bindGroup36, new Uint32Array(4021), 1_163, 0);
} catch {}
try {
renderPassEncoder14.drawIndexed(170, 87, 19, 310_394_208, 102_661_827);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(5, buffer12, 0, 14_032);
} catch {}
try {
device0.queue.writeBuffer(buffer68, 708, new DataView(new ArrayBuffer(9419)), 293, 800);
} catch {}
let texture120 = device0.createTexture({
  size: [3],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let sampler87 = device0.createSampler({
  label: '\u40c8\u00c9\uf107\u0f11\udc96',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.10,
  maxAnisotropy: 11,
});
try {
computePassEncoder126.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup5, new Uint32Array(1129), 112, 0);
} catch {}
try {
renderPassEncoder14.drawIndexed(56, 265, 429, 493_527_239, 841_544_228);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer34, 'uint32', 2_540, 468);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline17);
} catch {}
try {
  await buffer72.mapAsync(GPUMapMode.READ, 16, 1348);
} catch {}
try {
commandEncoder145.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 8988 */
  offset: 1820,
  bytesPerRow: 1024,
  buffer: buffer20,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 51, y: 21, z: 0},
  aspect: 'all',
}, {width: 0, height: 8, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 49, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let sampler88 = device0.createSampler({addressModeW: 'repeat', magFilter: 'nearest', lodMaxClamp: 88.41});
try {
computePassEncoder50.setBindGroup(0, bindGroup5, new Uint32Array(1738), 21, 0);
} catch {}
try {
computePassEncoder53.end();
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup56);
} catch {}
try {
renderPassEncoder14.draw(4, 134, 3, 1_350_907_761);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer71, 300);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer20, 'uint16', 4_026, 5_098);
} catch {}
let bindGroup57 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [
    {binding: 235, resource: textureView97},
    {binding: 263, resource: {buffer: buffer12, offset: 5120, size: 10196}},
    {binding: 48, resource: {buffer: buffer73, offset: 0, size: 204}},
  ],
});
let commandEncoder146 = device0.createCommandEncoder();
let sampler89 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 89.75,
});
try {
renderPassEncoder14.setBindGroup(3, bindGroup27);
} catch {}
try {
renderPassEncoder14.drawIndexed(40, 413, 156, 84_537_789, 2_065_323_274);
} catch {}
try {
renderPassEncoder14.drawIndirect(buffer75, 80);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer5, 'uint32', 236, 16);
} catch {}
try {
commandEncoder146.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3902 */
  offset: 3902,
  bytesPerRow: 1536,
  rowsPerImage: 70,
  buffer: buffer83,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 4},
  aspect: 'all',
}, {width: 2, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer29, 10840, new Float32Array(3003), 121, 120);
} catch {}
let bindGroup58 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout28,
  entries: [
    {binding: 263, resource: {buffer: buffer77, offset: 4608, size: 2344}},
    {binding: 48, resource: {buffer: buffer12, offset: 2560, size: 2588}},
  ],
});
let buffer93 = device0.createBuffer({
  size: 10849,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder147 = device0.createCommandEncoder();
let commandBuffer11 = commandEncoder67.finish();
let textureView118 = texture117.createView({baseMipLevel: 0});
let computePassEncoder127 = commandEncoder146.beginComputePass({});
let renderPassEncoder36 = commandEncoder145.beginRenderPass({
  colorAttachments: [{
  view: textureView67,
  depthSlice: 0,
  clearValue: { r: 69.34, g: 496.5, b: 608.0, a: 917.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 150143038,
});
let sampler90 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 63.25,
});
try {
computePassEncoder46.setBindGroup(1, bindGroup11, new Uint32Array(118), 10, 0);
} catch {}
try {
computePassEncoder125.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder14.end();
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline14);
} catch {}
try {
commandEncoder147.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1560 */
  offset: 1560,
  buffer: buffer27,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'depth-only',
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let recycledExplicitBindGroupLayout30 = pipeline13.getBindGroupLayout(0);
let bindGroup59 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout0,
  entries: [
    {binding: 263, resource: {buffer: buffer37, offset: 0, size: 1888}},
    {binding: 48, resource: {buffer: buffer80, offset: 512, size: 792}},
  ],
});
let commandBuffer12 = commandEncoder59.finish();
let computePassEncoder128 = commandEncoder147.beginComputePass({});
try {
computePassEncoder44.setBindGroup(3, bindGroup20, new Uint32Array(107), 11, 0);
} catch {}
try {
renderPassEncoder32.setBindGroup(0, bindGroup59);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer31, 'uint32', 4, 701);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(4, buffer28);
} catch {}
let recycledExplicitBindGroupLayout31 = pipeline14.getBindGroupLayout(0);
let commandEncoder148 = device0.createCommandEncoder({});
let computePassEncoder129 = commandEncoder148.beginComputePass();
let pipeline24 = device0.createComputePipeline({layout: pipelineLayout5, compute: {module: shaderModule2, entryPoint: 'compute2', constants: {}}});
try {
  await promise21;
} catch {}
let texture121 = device0.createTexture({
  size: [12, 396, 1],
  format: 'rg8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView119 = texture11.createView({dimension: '3d', mipLevelCount: 1, baseArrayLayer: 0});
let sampler91 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 86.28,
});
try {
renderPassEncoder32.setBindGroup(0, bindGroup1, new Uint32Array(45), 2, 0);
} catch {}
document.body.append(canvas2);
let buffer94 = device0.createBuffer({size: 27001, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder149 = device0.createCommandEncoder({});
try {
computePassEncoder45.setBindGroup(0, bindGroup21);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder80); computePassEncoder80.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
computePassEncoder128.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer71, 'uint32', 3_904, 1_928);
} catch {}
try {
renderPassEncoder35.insertDebugMarker('\ud777');
} catch {}
let pipeline25 = device0.createRenderPipeline({
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment5',
  targets: [{
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-constant', dstFactor: 'dst-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}],
},
  depthStencil: {
    format: 'depth16unorm',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilReadMask: 81261076,
    stencilWriteMask: 144378553,
    depthBias: -1914024130,
    depthBiasSlopeScale: 628.1482900048061,
    depthBiasClamp: 717.762048497552,
  },
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 1008,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x2', offset: 60, shaderLocation: 11},
          {format: 'uint32x2', offset: 0, shaderLocation: 6},
          {format: 'unorm8x2', offset: 286, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true},
});
let computePassEncoder130 = commandEncoder149.beginComputePass({});
try {
computePassEncoder81.setBindGroup(0, bindGroup33);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer34, 1_904); };
} catch {}
try {
computePassEncoder127.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture88,
  mipLevel: 0,
  origin: {x: 0, y: 6, z: 19},
  aspect: 'all',
}, new Uint8Array(175_114).fill(187), /* required buffer size: 175_114 */
{offset: 287, bytesPerRow: 79, rowsPerImage: 158}, {width: 0, height: 2, depthOrArrayLayers: 15});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let shaderModule8 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires unrestricted_pointer_parameters;

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

var<workgroup> vw30: atomic<i32>;

var<workgroup> vw28: mat2x2h;

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

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

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

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

struct T1 {
  @size(192) f0: array<array<array<mat2x3f, 1>, 2>, 1>,
}

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

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

@compute @workgroup_size(1, 1, 2)
fn compute11() {
  let vf111: vec2h = (*&vw28)[u32(unconst_u32(150))];
  let ptr81: ptr<workgroup, atomic<i32>> = &(*&vw29)[u32(unconst_u32(319))][0];
  var vf112: i32 = atomicExchange(&(*&vw30), i32(unconst_i32(19)));
  atomicMin(&vw30, i32(unconst_i32(116)));
}

@compute @workgroup_size(1, 1, 1)
fn compute12() {
  let ptr82: ptr<workgroup, mat2x2h> = &vw28;
  let ptr83: ptr<workgroup, array<atomic<i32>, 1>> = &vw29[0];
  let vf113: i32 = atomicLoad(&(*&vw29)[u32(unconst_u32(1))][u32(unconst_u32(56))]);
}`,
});
let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout7]});
let buffer95 = device0.createBuffer({
  size: 2060,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler92 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', lodMinClamp: 10.27});
try {
computePassEncoder114.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder35.setBindGroup(2, bindGroup12);
} catch {}
try {
renderPassEncoder35.setBindGroup(0, bindGroup56, new Uint32Array(590), 136, 0);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer32, 'uint16', 2_964, 507);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(3, buffer77, 0);
} catch {}
document.body.prepend(canvas2);
let autogeneratedBindGroupLayout16 = pipeline3.getBindGroupLayout(0);
let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout3]});
let commandEncoder150 = device0.createCommandEncoder({});
let texture122 = device0.createTexture({
  size: {width: 365},
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView120 = texture102.createView({dimension: '2d-array'});
try {
computePassEncoder86.setBindGroup(1, bindGroup23);
} catch {}
try {
computePassEncoder129.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer90, 'uint16', 2_810, 3_316);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline9);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let buffer96 = device0.createBuffer({
  size: 23739,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture123 = gpuCanvasContext4.getCurrentTexture();
try {
renderPassEncoder34.beginOcclusionQuery(66);
} catch {}
try {
renderPassEncoder34.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer45, 'uint32', 396, 111);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let commandEncoder151 = device0.createCommandEncoder({});
let textureView121 = texture116.createView({baseMipLevel: 0, mipLevelCount: 1});
let texture124 = device0.createTexture({
  size: {width: 2920, height: 1, depthOrArrayLayers: 16},
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let sampler93 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 66.21,
  maxAnisotropy: 9,
});
try {
computePassEncoder46.setBindGroup(2, bindGroup56, new Uint32Array(776), 99, 0);
} catch {}
try {
computePassEncoder130.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline6);
} catch {}
try {
device0.queue.submit([commandBuffer11]);
} catch {}
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 42,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 65,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 70,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 132,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '2d' },
    },
    {binding: 249, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 324,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let recycledExplicitBindGroupLayout32 = pipeline8.getBindGroupLayout(0);
let bindGroup60 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 47, resource: {buffer: buffer6, offset: 1024}},
    {binding: 1, resource: sampler55},
    {binding: 111, resource: textureView53},
    {binding: 39, resource: textureView20},
    {binding: 118, resource: {buffer: buffer41, offset: 0, size: 708}},
  ],
});
let texture125 = device0.createTexture({
  size: [30],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture126 = device0.createTexture({
  size: [30, 20, 286],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView122 = texture117.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup47);
} catch {}
try {
renderPassEncoder7.setScissorRect(0, 9, 0, 40);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer93, 'uint32', 4_356, 1_694);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline1);
} catch {}
try {
commandEncoder150.copyBufferToBuffer(buffer71, 332, buffer44, 464, 72);
} catch {}
try {
commandEncoder150.resolveQuerySet(querySet18, 2, 159, buffer61, 1792);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(18).fill(134), /* required buffer size: 18 */
{offset: 18, bytesPerRow: 345}, {width: 120, height: 48, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
let texture127 = device0.createTexture({
  size: [730],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder12.setBindGroup(2, bindGroup35, new Uint32Array(787), 133, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer25.unmap();
} catch {}
try {
commandEncoder150.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 62 */
  offset: 62,
  bytesPerRow: 26880,
  buffer: buffer62,
}, {
  texture: texture11,
  mipLevel: 1,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
}, {width: 0, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer64, 864, new DataView(new ArrayBuffer(18576)), 10553, 152);
} catch {}
let bindGroup61 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout15,
  entries: [
    {binding: 263, resource: {buffer: buffer1, offset: 768, size: 1924}},
    {binding: 48, resource: {buffer: buffer42, offset: 0}},
  ],
});
let commandEncoder152 = device0.createCommandEncoder({});
let texture128 = device0.createTexture({size: [6], sampleCount: 1, dimension: '1d', format: 'rg8unorm', usage: GPUTextureUsage.COPY_SRC});
let textureView123 = texture102.createView({
  label: '\u8fd5\u05ec\u36c7\u0a64\u0000\u{1fde8}\u02c8\u018c\u5699\uc75b\u{1f7fc}',
  dimension: '2d-array',
});
let computePassEncoder131 = commandEncoder151.beginComputePass({});
try {
computePassEncoder101.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(85);
} catch {}
try {
  await buffer35.mapAsync(GPUMapMode.WRITE, 512, 572);
} catch {}
try {
commandEncoder152.copyBufferToTexture({
  /* bytesInLastRow: 46 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 10216 */
  offset: 186,
  bytesPerRow: 3328,
  buffer: buffer36,
}, {
  texture: texture112,
  mipLevel: 0,
  origin: {x: 0, y: 25, z: 21},
  aspect: 'all',
}, {width: 23, height: 4, depthOrArrayLayers: 1});
} catch {}
try {
computePassEncoder115.pushDebugGroup('\u6121');
} catch {}
try {
computePassEncoder115.popDebugGroup();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture78,
  mipLevel: 0,
  origin: {x: 22, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer97 = device0.createBuffer({size: 6748, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let querySet19 = device0.createQuerySet({type: 'occlusion', count: 990});
let textureView124 = texture95.createView({});
try {
computePassEncoder79.setBindGroup(3, bindGroup40);
} catch {}
try {
computePassEncoder131.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle15]);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline8);
} catch {}
try {
computePassEncoder3.setBindGroup(3, bindGroup45);
} catch {}
try {
renderPassEncoder32.setBindGroup(1, bindGroup3, new Uint32Array(3528), 438, 0);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle13, renderBundle1]);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer5, 'uint16', 1_530, 82);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(5, buffer61);
} catch {}
let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout4]});
let commandEncoder153 = device0.createCommandEncoder({});
let textureView125 = texture90.createView({baseArrayLayer: 1, arrayLayerCount: 1});
let texture129 = device0.createTexture({
  size: [15, 10, 55],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder127.setBindGroup(0, bindGroup30, new Uint32Array(257), 14, 0);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup45);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup43, new Uint32Array(2573), 214, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder154 = device0.createCommandEncoder({});
let texture130 = device0.createTexture({
  size: [60, 40, 573],
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder132 = commandEncoder150.beginComputePass({});
try {
renderPassEncoder27.beginOcclusionQuery(24);
} catch {}
try {
renderPassEncoder31.setViewport(334.6715863016631, 0.6472841735963673, 26.06422020320533, 0.30015449349826084, 0.7482566937052763, 0.9730474261408845);
} catch {}
try {
buffer57.unmap();
} catch {}
try {
commandEncoder154.clearBuffer(buffer86, 4196, 440);
} catch {}
let commandEncoder155 = device0.createCommandEncoder({});
let texture131 = gpuCanvasContext3.getCurrentTexture();
let computePassEncoder133 = commandEncoder153.beginComputePass();
try {
computePassEncoder81.setBindGroup(3, bindGroup36, new Uint32Array(546), 16, 0);
} catch {}
try {
computePassEncoder132.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
commandEncoder155.copyTextureToBuffer({
  texture: texture76,
  mipLevel: 0,
  origin: {x: 40, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5518 */
  offset: 5518,
  bytesPerRow: 9728,
  buffer: buffer67,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView126 = texture125.createView({aspect: 'all'});
let computePassEncoder134 = commandEncoder154.beginComputePass({});
try {
computePassEncoder24.setBindGroup(3, bindGroup23, new Uint32Array(345), 57, 0);
} catch {}
try {
computePassEncoder16.end();
} catch {}
try {
renderPassEncoder26.end();
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer33, 'uint16', 644, 673);
} catch {}
try {
commandEncoder18.copyTextureToTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 63, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture12,
  mipLevel: 0,
  origin: {x: 59, y: 0, z: 0},
  aspect: 'all',
},
{width: 45, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas2);
let bindGroup62 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout13,
  entries: [
    {binding: 263, resource: {buffer: buffer30, offset: 4864, size: 5564}},
    {binding: 48, resource: {buffer: buffer42, offset: 3072, size: 4332}},
  ],
});
let textureView127 = texture18.createView({});
try {
computePassEncoder108.setBindGroup(0, bindGroup23, new Uint32Array(12), 0, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder51); computePassEncoder51.dispatchWorkgroups(1, 1); };
} catch {}
let recycledExplicitBindGroupLayout33 = pipeline15.getBindGroupLayout(0);
let sampler94 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  lodMaxClamp: 63.55,
});
try {
computePassEncoder37.setBindGroup(0, bindGroup37, new Uint32Array(337), 70, 0);
} catch {}
try {
computePassEncoder134.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(6, buffer90, 0);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup63 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout25,
  entries: [
    {binding: 48, resource: {buffer: buffer40, offset: 512, size: 316}},
    {binding: 263, resource: {buffer: buffer24, offset: 1024, size: 528}},
  ],
});
let texture132 = gpuCanvasContext1.getCurrentTexture();
let computePassEncoder135 = commandEncoder152.beginComputePass({});
try {
computePassEncoder87.setPipeline(pipeline12);
} catch {}
try {
computePassEncoder135.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline14);
} catch {}
let imageData13 = new ImageData(12, 28);
let recycledExplicitBindGroupLayout34 = pipeline15.getBindGroupLayout(0);
let bindGroup64 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout10,
  entries: [
    {binding: 263, resource: {buffer: buffer77, offset: 2816, size: 7988}},
    {binding: 48, resource: {buffer: buffer82, offset: 2304, size: 3000}},
  ],
});
let buffer98 = device0.createBuffer({
  size: 11215,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let commandEncoder156 = device0.createCommandEncoder({});
let commandBuffer13 = commandEncoder15.finish();
let renderPassEncoder37 = commandEncoder18.beginRenderPass({colorAttachments: [{view: textureView119, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}]});
try {
computePassEncoder21.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer88);
} catch {}
try {
device0.queue.writeBuffer(buffer85, 536, new BigUint64Array(3651), 406, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture111,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 6},
  aspect: 'all',
}, new Uint8Array(100_724).fill(217), /* required buffer size: 100_724 */
{offset: 57, bytesPerRow: 63, rowsPerImage: 38}, {width: 7, height: 2, depthOrArrayLayers: 43});
} catch {}
let promise22 = device0.queue.onSubmittedWorkDone();
let commandEncoder157 = device0.createCommandEncoder({});
let textureView128 = texture62.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 10});
let computePassEncoder136 = commandEncoder156.beginComputePass({});
let sampler95 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 67.66,
});
try {
{ clearResourceUsages(device0, computePassEncoder79); computePassEncoder79.dispatchWorkgroupsIndirect(buffer52, 3_380); };
} catch {}
try {
computePassEncoder37.end();
} catch {}
try {
buffer7.unmap();
} catch {}
try {
commandEncoder47.clearBuffer(buffer8, 524, 396);
} catch {}
try {
  await promise22;
} catch {}
let autogeneratedBindGroupLayout17 = pipeline3.getBindGroupLayout(0);
let textureView129 = texture103.createView({dimension: '2d', baseArrayLayer: 1});
let renderPassEncoder38 = commandEncoder47.beginRenderPass({
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: 894.4, g: 651.6, b: 618.0, a: 490.7, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder38.setBindGroup(1, bindGroup61, new Uint32Array(1549), 40, 0);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer5, 'uint16', 430, 25);
} catch {}
try {
device0.queue.writeBuffer(buffer78, 5848, new Int16Array(11430), 767, 252);
} catch {}
let pipeline26 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 648,
        attributes: [
          {format: 'uint32x4', offset: 76, shaderLocation: 1},
          {format: 'snorm16x2', offset: 100, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder158 = device0.createCommandEncoder({label: '\u4627\u2e33\u{1f83a}\u87a8\u{1fc75}\u0944\u3c69'});
let texture133 = device0.createTexture({
  size: [30, 12, 97],
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView130 = texture104.createView({});
let computePassEncoder137 = commandEncoder155.beginComputePass();
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle18 = renderBundleEncoder18.finish({});
try {
computePassEncoder27.setBindGroup(0, bindGroup51, new Uint32Array(909), 271, 0);
} catch {}
try {
computePassEncoder64.end();
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer32, 'uint16', 2_082, 39);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
await gc();
let commandEncoder159 = device0.createCommandEncoder({});
let texture134 = device0.createTexture({
  size: [30, 12, 50],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView131 = texture15.createView({arrayLayerCount: 1});
let sampler96 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', minFilter: 'linear'});
try {
computePassEncoder136.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer49, 'uint32', 52, 111);
} catch {}
try {
commandEncoder5.copyBufferToTexture({
  /* bytesInLastRow: 730 widthInBlocks: 365 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 796 */
  offset: 796,
  bytesPerRow: 74496,
  buffer: buffer63,
}, {
  texture: texture26,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 365, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.submit([commandBuffer13]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 365, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData11,
  origin: { x: 6, y: 3 },
  flipY: true,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 152,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 229,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 366,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let textureView132 = texture124.createView({dimension: '2d', aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 3});
try {
renderPassEncoder23.setBindGroup(0, bindGroup21, new Uint32Array(1157), 99, 0);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(5, undefined, 145_423_931, 1_074_653_077);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let arrayBuffer17 = buffer35.getMappedRange(512, 36);
try {
commandEncoder159.copyTextureToTexture({
  texture: texture126,
  mipLevel: 1,
  origin: {x: 2, y: 1, z: 32},
  aspect: 'all',
},
{
  texture: texture63,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup65 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout33,
  entries: [
    {binding: 263, resource: {buffer: buffer13, offset: 512}},
    {binding: 48, resource: {buffer: buffer7, offset: 0}},
  ],
});
try {
computePassEncoder115.setBindGroup(0, bindGroup7, new Uint32Array(2343), 433, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(4, 2); };
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup27, new Uint32Array(1206), 33, 0);
} catch {}
try {
renderPassEncoder4.end();
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder38.setIndexBuffer(buffer20, 'uint32', 9_704, 13_752);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(0, buffer31, 256, 97);
} catch {}
let texture135 = device0.createTexture({
  size: [2920, 1, 44],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView133 = texture12.createView({baseArrayLayer: 1, arrayLayerCount: 1});
let sampler97 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 74.28, maxAnisotropy: 7});
try {
computePassEncoder106.setBindGroup(0, bindGroup15, new Uint32Array(717), 81, 0);
} catch {}
try {
computePassEncoder131.setPipeline(pipeline12);
} catch {}
try {
computePassEncoder133.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle15]);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer6, 'uint16', 54, 106);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline26);
} catch {}
try {
commandEncoder5.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2324 */
  offset: 2324,
  buffer: buffer56,
}, {
  texture: texture87,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder158.copyTextureToBuffer({
  texture: texture98,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 60 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1600 */
  offset: 1600,
  buffer: buffer25,
}, {width: 30, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas2);
let computePassEncoder138 = commandEncoder158.beginComputePass();
try {
renderPassEncoder27.setBindGroup(0, bindGroup31, new Uint32Array(1798), 109, 0);
} catch {}
try {
globalThis.someLabel = sampler40.label;
} catch {}
let bindGroup66 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout13,
  entries: [
    {binding: 48, resource: {buffer: buffer6, offset: 0, size: 348}},
    {binding: 263, resource: {buffer: buffer26, offset: 25600}},
  ],
});
let buffer99 = device0.createBuffer({
  size: 10463,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
});
let computePassEncoder139 = commandEncoder157.beginComputePass({});
let externalTexture24 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'display-p3'});
try {
computePassEncoder138.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup2, new Uint32Array(3300), 515, 0);
} catch {}
try {
renderPassEncoder28.setViewport(259.2921162921098, 0.46314443736903343, 96.23990647575161, 0.0110319460458351, 0.23553120665452054, 0.8464812260186857);
} catch {}
try {
commandEncoder20.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 276 */
  offset: 276,
  bytesPerRow: 76544,
  rowsPerImage: 574,
  buffer: buffer60,
}, {
  texture: texture91,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder83.pushDebugGroup('\uc58a');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let autogeneratedBindGroupLayout18 = pipeline3.getBindGroupLayout(0);
let textureView134 = texture50.createView({aspect: 'depth-only'});
let computePassEncoder140 = commandEncoder159.beginComputePass({});
try {
renderPassEncoder23.setVertexBuffer(1, buffer51, 0, 109);
} catch {}
try {
renderPassEncoder11.insertDebugMarker('\u826f');
} catch {}
let pipeline27 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule3, targets: [{format: 'rg8sint'}]},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex3',
    buffers: [
      {
        arrayStride: 48,
        attributes: [{format: 'snorm8x4', offset: 4, shaderLocation: 11}, {format: 'uint32', offset: 4, shaderLocation: 1}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: false},
});
let recycledExplicitBindGroupLayout35 = pipeline13.getBindGroupLayout(0);
let bindGroup67 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout17,
  entries: [{binding: 263, resource: {buffer: buffer88, offset: 0, size: 164}}],
});
let commandEncoder160 = device0.createCommandEncoder({});
let textureView135 = texture72.createView({});
let sampler98 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.56,
  maxAnisotropy: 2,
});
try {
computePassEncoder56.setBindGroup(0, bindGroup49);
} catch {}
try {
computePassEncoder36.setBindGroup(0, bindGroup8, new Uint32Array(3099), 699, 0);
} catch {}
try {
computePassEncoder139.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle1]);
} catch {}
let promise23 = device0.queue.onSubmittedWorkDone();
let canvas4 = document.createElement('canvas');
let bindGroup68 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 1, resource: sampler18},
    {binding: 47, resource: {buffer: buffer98, offset: 768, size: 2500}},
    {binding: 118, resource: {buffer: buffer12, offset: 17920, size: 1108}},
    {binding: 111, resource: textureView0},
    {binding: 39, resource: textureView34},
  ],
});
let buffer100 = device0.createBuffer({size: 7401, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let renderPassEncoder39 = commandEncoder160.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: -298.9, g: 976.5, b: -609.2, a: 86.97, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet5,
});
try {
computePassEncoder107.setBindGroup(2, bindGroup45);
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle2, renderBundle5, renderBundle2]);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(5, buffer7, 0, 13);
} catch {}
try {
commandEncoder20.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 292 */
  offset: 292,
  buffer: buffer23,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {width: 15, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder20.resolveQuerySet(querySet16, 675, 146, buffer47, 0);
} catch {}
let texture136 = device0.createTexture({
  size: {width: 365, height: 1, depthOrArrayLayers: 129},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder40 = commandEncoder20.beginRenderPass({label: '\u0012\u0591', colorAttachments: [{view: textureView13, loadOp: 'load', storeOp: 'store'}]});
try {
computePassEncoder99.setBindGroup(0, bindGroup46);
} catch {}
try {
computePassEncoder137.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder38.setBindGroup(1, bindGroup29);
} catch {}
try {
renderPassEncoder39.setBindGroup(3, bindGroup37, new Uint32Array(932), 72, 0);
} catch {}
try {
computePassEncoder107.pushDebugGroup('\u{1f819}');
} catch {}
try {
computePassEncoder107.popDebugGroup();
} catch {}
let gpuCanvasContext5 = canvas4.getContext('webgpu');
let commandEncoder161 = device0.createCommandEncoder({});
let computePassEncoder141 = commandEncoder161.beginComputePass({});
let renderPassEncoder41 = commandEncoder5.beginRenderPass({
  colorAttachments: [{
  view: textureView106,
  clearValue: { r: 626.5, g: -154.5, b: -442.7, a: -138.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder132.setBindGroup(0, bindGroup50);
} catch {}
try {
computePassEncoder140.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup37, new Uint32Array(245), 8, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 76, new BigUint64Array(16198), 925, 28);
} catch {}
document.body.append(canvas0);
let bindGroup69 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [{binding: 263, resource: {buffer: buffer40, offset: 0, size: 1180}}],
});
let commandEncoder162 = device0.createCommandEncoder();
let texture137 = device0.createTexture({
  size: [15, 6, 1],
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView136 = texture94.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder51); computePassEncoder51.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder141.setPipeline(pipeline7);
} catch {}
let pipeline28 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment6',
  constants: {override2: 0, 17_112: 0},
  targets: [{format: 'rgba16float', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule6,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'sint8x2', offset: 310, shaderLocation: 7}],
      },
    ],
  },
  primitive: {cullMode: 'front'},
});
let buffer101 = device0.createBuffer({
  size: 4046,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let texture138 = device0.createTexture({
  size: [1, 49, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler99 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'mirror-repeat', lodMaxClamp: 94.29});
try {
computePassEncoder112.setBindGroup(0, bindGroup49, new Uint32Array(942), 135, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder81); computePassEncoder81.dispatchWorkgroupsIndirect(buffer73, 180); };
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup43, new Uint32Array(644), 17, 0);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle16]);
} catch {}
try {
renderPassEncoder38.setViewport(3.6109987663762175, 360.42192231019794, 2.5694920833754513, 8.309354905911116, 0.8725272385021481, 0.9663627249299368);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer12, 'uint32', 10_900, 2_308);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(4, buffer46);
} catch {}
try {
commandEncoder162.copyTextureToTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture126,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpte432', transfer: 'bt709'} });
let textureView137 = texture107.createView({});
let computePassEncoder142 = commandEncoder162.beginComputePass({});
let externalTexture25 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder109.setBindGroup(1, bindGroup27, new Uint32Array(1356), 320, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroupsIndirect(buffer37, 4_936); };
} catch {}
try {
computePassEncoder57.end();
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline17);
} catch {}
try {
commandEncoder73.copyBufferToBuffer(buffer59, 528, buffer8, 892, 1628);
} catch {}
document.body.prepend(img0);
let texture139 = device0.createTexture({
  size: {width: 12},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView138 = texture35.createView({dimension: '2d-array'});
let computePassEncoder143 = commandEncoder73.beginComputePass({});
try {
computePassEncoder103.setBindGroup(0, bindGroup47);
} catch {}
try {
computePassEncoder142.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer66, 'uint16', 5_150, 505);
} catch {}
try {
buffer45.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer12]);
} catch {}
let autogeneratedBindGroupLayout19 = pipeline7.getBindGroupLayout(0);
let texture140 = device0.createTexture({
  size: [16, 16, 12],
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder60.setBindGroup(0, bindGroup21, new Uint32Array(3996), 634, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup57);
} catch {}
try {
computePassEncoder83.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer24, 924, new BigUint64Array(5666), 1753, 68);
} catch {}
let img2 = await imageWithData(19, 63, '#10101010', '#20202020');
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'film', transfer: 'log'} });
let buffer102 = device0.createBuffer({size: 7915, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView139 = texture38.createView({});
try {
computePassEncoder131.setBindGroup(0, bindGroup2);
} catch {}
try {
computePassEncoder131.setBindGroup(0, bindGroup10, new Uint32Array(3661), 1_072, 0);
} catch {}
try {
computePassEncoder143.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder37.setBindGroup(0, bindGroup63);
} catch {}
try {
renderPassEncoder27.setViewport(1.4288120739286847, 164.83995186192737, 9.32394541664282, 209.83680688783818, 0.44952265841820815, 0.8451314242147046);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(2, buffer9);
} catch {}
document.body.prepend(canvas4);
let buffer103 = device0.createBuffer({size: 6845, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView140 = texture91.createView({});
try {
renderPassEncoder25.executeBundles([renderBundle5]);
} catch {}
let pipeline29 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute5', constants: {}}});
try {
  await promise23;
} catch {}
let commandEncoder163 = device0.createCommandEncoder({});
let texture141 = device0.createTexture({
  size: {width: 3},
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler100 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 91.81,
});
try {
commandEncoder163.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2572 */
  offset: 2572,
  bytesPerRow: 16640,
  buffer: buffer90,
}, {
  texture: texture93,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder163.copyTextureToTexture({
  texture: texture111,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 14},
  aspect: 'all',
},
{
  texture: texture133,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder106.pushDebugGroup('\uaca1');
} catch {}
try {
computePassEncoder106.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 10, z: 0},
  aspect: 'all',
}, new Uint8Array(290).fill(69), /* required buffer size: 290 */
{offset: 290, bytesPerRow: 97, rowsPerImage: 121}, {width: 0, height: 5, depthOrArrayLayers: 0});
} catch {}
let bindGroup70 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 235, resource: textureView3}, {binding: 167, resource: textureView129}],
});
let buffer104 = device0.createBuffer({
  size: 13603,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
});
let texture142 = device0.createTexture({
  size: {width: 6, height: 198, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let sampler101 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder50.setBindGroup(0, bindGroup27);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer5, 'uint16', 1_356, 43);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline1);
} catch {}
let arrayBuffer18 = buffer21.getMappedRange(88, 0);
document.body.prepend(canvas4);
let computePassEncoder144 = commandEncoder163.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder110); computePassEncoder110.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle0]);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer91, 124, 476);
} catch {}
let promise24 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule7, entryPoint: 'fragment5', targets: [{format: 'rg8unorm', writeMask: 0}]},
  depthStencil: {
    format: 'depth16unorm',
    depthWriteEnabled: false,
    depthBias: -1641866808,
    depthBiasSlopeScale: 290.6024594087328,
    depthBiasClamp: -10.92868916887096,
  },
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex4',
    constants: {},
    buffers: [
      {
        arrayStride: 200,
        attributes: [
          {format: 'unorm8x4', offset: 80, shaderLocation: 9},
          {format: 'float32x2', offset: 28, shaderLocation: 1},
          {format: 'float32x2', offset: 4, shaderLocation: 10},
          {format: 'uint32', offset: 0, shaderLocation: 5},
          {format: 'float32x3', offset: 48, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front'},
});
let bindGroup71 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout27,
  entries: [
    {binding: 48, resource: {buffer: buffer7, offset: 0}},
    {binding: 263, resource: {buffer: buffer7, offset: 0}},
  ],
});
let texture143 = device0.createTexture({size: [15, 6, 77], format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthStencilFormat: 'depth16unorm', stencilReadOnly: true});
try {
computePassEncoder27.setBindGroup(0, bindGroup37, new Uint32Array(798), 228, 0);
} catch {}
try {
computePassEncoder46.end();
} catch {}
try {
computePassEncoder51.end();
} catch {}
try {
computePassEncoder144.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder39.beginOcclusionQuery(27);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer30, 'uint32', 6_580, 3_000);
} catch {}
try {
renderPassEncoder32.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder19.setBindGroup(2, bindGroup30, new Uint32Array(513), 95, 0);
} catch {}
try {
commandEncoder57.clearBuffer(buffer100, 92, 72);
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet19, 212, 27, buffer3, 0);
} catch {}
let bindGroup72 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout19,
  entries: [
    {binding: 48, resource: {buffer: buffer88, offset: 0, size: 184}},
    {binding: 263, resource: {buffer: buffer12, offset: 1792, size: 3260}},
  ],
});
let texture144 = device0.createTexture({
  size: {width: 30, height: 12, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder145 = commandEncoder57.beginComputePass({label: '\u0b8f\uc017\ucacc\ue2b0\u{1fb9e}\u0ddc\u0808\u6e5b\u0fb9\u{1fbd8}'});
let sampler102 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 54.77,
});
try {
renderPassEncoder39.endOcclusionQuery();
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer88, 'uint16', 134, 394);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline26);
} catch {}
try {
buffer79.unmap();
} catch {}
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 730 widthInBlocks: 365 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 868 */
  offset: 868,
  rowsPerImage: 114,
  buffer: buffer78,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {width: 365, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup73 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout22,
  entries: [
    {binding: 263, resource: {buffer: buffer88, offset: 256, size: 40}},
    {binding: 48, resource: {buffer: buffer43, offset: 256, size: 720}},
  ],
});
let commandEncoder164 = device0.createCommandEncoder();
let texture145 = device0.createTexture({size: [1, 49, 1], mipLevelCount: 2, format: 'depth16unorm', usage: GPUTextureUsage.COPY_DST});
let textureView141 = texture11.createView({dimension: '3d', format: 'rg8sint', mipLevelCount: 1});
let sampler103 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 71.27,
  compare: 'greater-equal',
  maxAnisotropy: 6,
});
try {
computePassEncoder34.setBindGroup(0, bindGroup37, new Uint32Array(379), 119, 0);
} catch {}
try {
renderPassEncoder21.setViewport(1.146261224890547, 326.92767761457003, 2.9734355673246613, 15.64642091374173, 0.16746421423502633, 0.22641251462900774);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(4, buffer44, 0, 54);
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout30,
  entries: [
    {binding: 263, resource: {buffer: buffer54, offset: 0, size: 36}},
    {binding: 48, resource: {buffer: buffer80, offset: 512, size: 408}},
  ],
});
let computePassEncoder146 = commandEncoder164.beginComputePass({});
try {
computePassEncoder120.setBindGroup(1, bindGroup69, new Uint32Array(944), 18, 0);
} catch {}
try {
computePassEncoder145.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup61, new Uint32Array(5108), 737, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer80, 'uint16', 92, 475);
} catch {}
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1018 */
  offset: 1018,
  buffer: buffer45,
}, {
  texture: texture20,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder42.pushDebugGroup('\ud014');
} catch {}
let computePassEncoder147 = commandEncoder64.beginComputePass();
let sampler104 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  maxAnisotropy: 1,
});
try {
computePassEncoder44.setBindGroup(0, bindGroup35);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer5, 'uint32', 24, 105);
} catch {}
try {
computePassEncoder42.popDebugGroup();
} catch {}
let img3 = await imageWithData(40, 117, '#10101010', '#20202020');
let commandEncoder165 = device0.createCommandEncoder();
let sampler105 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 48.81,
  lodMaxClamp: 55.50,
  compare: 'greater',
  maxAnisotropy: 3,
});
try {
computePassEncoder94.setBindGroup(0, bindGroup72);
} catch {}
try {
computePassEncoder147.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder39.setBindGroup(0, bindGroup9, new Uint32Array(1487), 218, 0);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(4, buffer3, 0, 998);
} catch {}
let recycledExplicitBindGroupLayout36 = pipeline14.getBindGroupLayout(0);
let bindGroup75 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout18,
  entries: [{binding: 263, resource: {buffer: buffer50, offset: 1536}}],
});
let buffer105 = device0.createBuffer({
  size: 326,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder123.setBindGroup(0, bindGroup40, []);
} catch {}
try {
renderPassEncoder32.setViewport(2.6326113582047292, 114.58066531642953, 6.765148137976419, 115.21358991717892, 0.7065702421294416, 0.7774858857103966);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer13, 'uint16', 2_196, 860);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(5, buffer96, 0, 4_533);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'bt1361ExtendedColourGamut'} });
let recycledExplicitBindGroupLayout37 = pipeline24.getBindGroupLayout(0);
let texture146 = device0.createTexture({
  size: {width: 7, height: 5, depthOrArrayLayers: 22},
  format: 'depth16unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder148 = commandEncoder165.beginComputePass({});
try {
computePassEncoder146.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer12, 'uint16', 19_570, 1_726);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(1, undefined, 0);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(2, buffer67, 2_396, 1_220);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 5},
  aspect: 'depth-only',
}, new Uint8Array(40_724).fill(205), /* required buffer size: 40_724 */
{offset: 224, bytesPerRow: 45, rowsPerImage: 300}, {width: 16, height: 0, depthOrArrayLayers: 4});
} catch {}
let commandEncoder166 = device0.createCommandEncoder({});
let textureView142 = texture52.createView({format: 'rgba16float'});
try {
computePassEncoder127.setBindGroup(0, bindGroup47);
} catch {}
try {
computePassEncoder23.setBindGroup(3, bindGroup43, new Uint32Array(762), 362, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder132); computePassEncoder132.dispatchWorkgroupsIndirect(buffer9, 428); };
} catch {}
try {
computePassEncoder68.end();
} catch {}
try {
computePassEncoder148.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup30, new Uint32Array(622), 2, 0);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(3, undefined, 1_620_909_068);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup15);
} catch {}
try {
renderBundleEncoder19.setBindGroup(2, bindGroup51, new Uint32Array(1567), 284, 0);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline19);
} catch {}
document.body.prepend(canvas3);
let textureView143 = texture54.createView({});
let computePassEncoder149 = commandEncoder1.beginComputePass({});
let sampler106 = device0.createSampler({addressModeV: 'repeat'});
try {
computePassEncoder118.setBindGroup(0, bindGroup5, new Uint32Array(2399), 134, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer93, 2_108); };
} catch {}
try {
computePassEncoder149.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup62, []);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 672, new Float32Array(5797), 336, 392);
} catch {}
try {
buffer57.label = '\u3de1\u4ba8\u0322\u{1fa55}\u{1fc61}\u8212\u00d5';
} catch {}
let bindGroup76 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout11,
  entries: [
    {binding: 48, resource: {buffer: buffer54, offset: 0, size: 328}},
    {binding: 263, resource: {buffer: buffer6, offset: 0}},
  ],
});
let commandEncoder167 = device0.createCommandEncoder({});
let textureView144 = texture52.createView({dimension: '1d'});
let texture147 = device0.createTexture({
  size: {width: 1460},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let renderBundle19 = renderBundleEncoder19.finish({});
try {
computePassEncoder136.setBindGroup(0, bindGroup41);
} catch {}
try {
computePassEncoder66.setBindGroup(0, bindGroup33, new Uint32Array(1041), 11, 0);
} catch {}
try {
computePassEncoder39.end();
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup58, []);
} catch {}
let pipeline30 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x53e6abe7},
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment6',
  constants: {override2: 0, 17_112: 0},
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'src-alpha', dstFactor: 'dst'},
    alpha: {operation: 'subtract', srcFactor: 'constant', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.BLUE,
}],
},
  vertex: {module: shaderModule5, constants: {}, buffers: []},
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
try {
if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55); };
} catch {}
let texture148 = device0.createTexture({
  size: [12, 396, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView145 = texture59.createView({
  aspect: 'depth-only',
  format: 'depth16unorm',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 13,
  arrayLayerCount: 4,
});
let computePassEncoder150 = commandEncoder167.beginComputePass();
let sampler107 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', magFilter: 'linear'});
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer89, 1_088); };
} catch {}
try {
computePassEncoder150.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer50, 'uint32', 17_768, 269);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer58, 0, 725);
} catch {}
try {
device0.queue.writeBuffer(buffer33, 288, new Float32Array(9140), 663, 120);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture99,
  mipLevel: 0,
  origin: {x: 551, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(49).fill(26), /* required buffer size: 49 */
{offset: 49, bytesPerRow: 272, rowsPerImage: 7}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img1);
let autogeneratedBindGroupLayout20 = pipeline7.getBindGroupLayout(0);
let texture149 = device0.createTexture({
  size: {width: 15, height: 10, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler108 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 50.56,
  lodMaxClamp: 78.90,
  compare: 'always',
  maxAnisotropy: 10,
});
try {
computePassEncoder48.setBindGroup(1, bindGroup70);
} catch {}
try {
renderPassEncoder36.executeBundles([renderBundle16]);
} catch {}
try {
renderPassEncoder31.setScissorRect(58, 0, 35, 0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline22);
} catch {}
try {
commandEncoder166.copyBufferToBuffer(buffer53, 1588, buffer12, 804, 3712);
} catch {}
canvas2.height = 1326;
let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 39,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
    {binding: 47, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 111,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 118, visibility: 0, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let buffer106 = device0.createBuffer({
  size: 7068,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView146 = texture148.createView({baseArrayLayer: 0});
let computePassEncoder151 = commandEncoder49.beginComputePass({});
let renderPassEncoder42 = commandEncoder166.beginRenderPass({colorAttachments: [{view: textureView106, loadOp: 'load', storeOp: 'discard'}]});
try {
computePassEncoder151.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup62, new Uint32Array(851), 163, 0);
} catch {}
try {
renderPassEncoder31.setScissorRect(45, 0, 0, 0);
} catch {}
let bindGroup77 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout36,
  entries: [
    {binding: 263, resource: {buffer: buffer13, offset: 1024, size: 152}},
    {binding: 48, resource: {buffer: buffer77, offset: 0, size: 8748}},
  ],
});
try {
{ clearResourceUsages(device0, computePassEncoder87); computePassEncoder87.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder32.setBindGroup(0, bindGroup73);
} catch {}
try {
renderPassEncoder35.setBindGroup(3, bindGroup77, new Uint32Array(2036), 526, 0);
} catch {}
try {
renderPassEncoder41.setStencilReference(1325);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer75, 'uint16', 456, 476);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture150 = device0.createTexture({
  size: [30, 12, 50],
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler109 = device0.createSampler({addressModeV: 'clamp-to-edge', mipmapFilter: 'nearest', compare: 'equal', maxAnisotropy: 1});
try {
renderPassEncoder29.setVertexBuffer(3, buffer34, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 2,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(6_557).fill(219), /* required buffer size: 6_557 */
{offset: 21, bytesPerRow: 38, rowsPerImage: 43}, {width: 0, height: 1, depthOrArrayLayers: 5});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2920, height: 1, depthOrArrayLayers: 44}
*/
{
  source: imageBitmap1,
  origin: { x: 9, y: 0 },
  flipY: true,
}, {
  texture: texture135,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 7},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout21 = pipeline19.getBindGroupLayout(0);
let commandEncoder168 = device0.createCommandEncoder({});
try {
computePassEncoder109.setBindGroup(0, bindGroup11);
} catch {}
try {
buffer83.unmap();
} catch {}
try {
computePassEncoder0.setBindGroup(0, bindGroup29);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer66, 'uint32', 1_400, 249);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 3, height: 99, depthOrArrayLayers: 51}
*/
{
  source: imageData12,
  origin: { x: 23, y: 20 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 4, depthOrArrayLayers: 0});
} catch {}
let buffer107 = device0.createBuffer({size: 772, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder169 = device0.createCommandEncoder({});
let textureView147 = texture64.createView({format: 'rg8sint', baseMipLevel: 0});
let computePassEncoder152 = commandEncoder168.beginComputePass({});
try {
computePassEncoder125.setBindGroup(0, bindGroup4, new Uint32Array(5921), 626, 0);
} catch {}
try {
computePassEncoder152.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer79, 'uint16', 4, 42);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer44, 560, 85);
} catch {}
try {
commandEncoder169.copyBufferToBuffer(buffer87, 3372, buffer36, 1480, 124);
} catch {}
try {
commandEncoder169.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1610 */
  offset: 1610,
  buffer: buffer1,
}, {
  texture: texture137,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout22 = pipeline3.getBindGroupLayout(0);
let texture151 = device0.createTexture({size: [60, 40, 1], mipLevelCount: 3, format: 'astc-5x4-unorm', usage: GPUTextureUsage.COPY_DST});
let renderPassEncoder43 = commandEncoder169.beginRenderPass({
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: 600.4, g: 792.3, b: -492.4, a: -205.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
{ clearResourceUsages(device0, computePassEncoder136); computePassEncoder136.dispatchWorkgroupsIndirect(buffer50, 6_904); };
} catch {}
let arrayBuffer19 = buffer72.getMappedRange(16, 244);
try {
computePassEncoder140.setBindGroup(2, bindGroup36, new Uint32Array(310), 64, 0);
} catch {}
let arrayBuffer20 = buffer72.getMappedRange(264, 56);
let texture152 = device0.createTexture({
  size: [730, 1, 1],
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView148 = texture147.createView({format: 'rg8sint'});
try {
renderPassEncoder29.setBindGroup(3, bindGroup77);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer88, 'uint32', 168, 309);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline14);
} catch {}
canvas3.height = 949;
let canvas5 = document.createElement('canvas');
let buffer108 = device0.createBuffer({
  size: 11471,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
try {
{ clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroupsIndirect(buffer90, 2_488); };
} catch {}
try {
renderPassEncoder38.setPipeline(pipeline22);
} catch {}
let arrayBuffer21 = buffer21.getMappedRange(16, 0);
try {
device0.queue.writeBuffer(buffer25, 4, new DataView(new ArrayBuffer(2359)), 340, 60);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 68, y: 18, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline31 = await promise16;
try {
computePassEncoder119.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup48);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline16);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); };
} catch {}
let bindGroup78 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [
    {binding: 263, resource: {buffer: buffer6, offset: 512}},
    {binding: 48, resource: {buffer: buffer106, offset: 512}},
  ],
});
let buffer109 = device0.createBuffer({
  size: 1738,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let textureView149 = texture95.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder83.setBindGroup(0, bindGroup32);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup70, new Uint32Array(2195), 301, 0);
} catch {}
try {
renderPassEncoder41.executeBundles([renderBundle5, renderBundle0]);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer67, 'uint32', 1_588, 2_633);
} catch {}
try {
  await shaderModule6.getCompilationInfo();
} catch {}
let texture153 = device0.createTexture({
  size: {width: 3},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let sampler110 = device0.createSampler({
  label: '\u3279\u0656\u9819\u9738',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 97.67,
});
try {
renderPassEncoder30.setPipeline(pipeline9);
} catch {}
try {
  await buffer60.mapAsync(GPUMapMode.WRITE, 0, 7328);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder170 = device0.createCommandEncoder({});
let textureView150 = texture61.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let computePassEncoder153 = commandEncoder170.beginComputePass({});
let sampler111 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  compare: 'equal',
});
let externalTexture26 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'});
try {
computePassEncoder32.setBindGroup(0, bindGroup9, new Uint32Array(2047), 390, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder71); computePassEncoder71.dispatchWorkgroupsIndirect(buffer108, 2_900); };
} catch {}
try {
renderPassEncoder39.setBindGroup(0, bindGroup52, new Uint32Array(223), 36, 0);
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline4);
} catch {}
let gpuCanvasContext6 = canvas5.getContext('webgpu');
let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 39,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let autogeneratedBindGroupLayout23 = pipeline30.getBindGroupLayout(0);
let texture154 = device0.createTexture({
  size: {width: 365, height: 1, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder109.setBindGroup(0, bindGroup11, new Uint32Array(2042), 1_133, 0);
} catch {}
try {
renderPassEncoder40.setBindGroup(2, bindGroup36, new Uint32Array(2586), 323, 0);
} catch {}
try {
renderPassEncoder30.setStencilReference(393);
} catch {}
try {
renderPassEncoder37.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(4, buffer51, 208, 26);
} catch {}
document.body.prepend(img0);
let buffer110 = device0.createBuffer({size: 1432, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder171 = device0.createCommandEncoder({});
let textureView151 = texture99.createView({mipLevelCount: 1});
let texture155 = device0.createTexture({size: [12, 396, 139], dimension: '3d', format: 'rg8unorm', usage: GPUTextureUsage.COPY_DST});
try {
{ clearResourceUsages(device0, computePassEncoder91); computePassEncoder91.dispatchWorkgroupsIndirect(buffer2, 224); };
} catch {}
try {
renderPassEncoder40.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder42.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer46, 396, 1_961);
} catch {}
try {
commandEncoder171.copyBufferToTexture({
  /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 848 */
  offset: 848,
  buffer: buffer83,
}, {
  texture: texture122,
  mipLevel: 0,
  origin: {x: 154, y: 0, z: 0},
  aspect: 'all',
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 48, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap2,
  origin: { x: 71, y: 22 },
  flipY: true,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 37, y: 12, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 8, height: 10, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout24 = pipeline18.getBindGroupLayout(0);
let commandEncoder172 = device0.createCommandEncoder({});
let texture156 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 12},
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder154 = commandEncoder171.beginComputePass();
try {
computePassEncoder120.setBindGroup(0, bindGroup76);
} catch {}
try {
renderPassEncoder27.setBindGroup(0, bindGroup0, new Uint32Array(10000), 375, 0);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder41.setBlendConstant({ r: 110.3, g: -331.9, b: -767.6, a: -803.4, });
} catch {}
try {
renderPassEncoder13.setScissorRect(2, 5, 9, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.append(canvas5);
let commandEncoder173 = device0.createCommandEncoder({});
let textureView152 = texture156.createView({baseArrayLayer: 1, arrayLayerCount: 2});
let computePassEncoder155 = commandEncoder172.beginComputePass({});
try {
computePassEncoder155.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline27);
} catch {}
try {
commandEncoder173.copyBufferToBuffer(buffer23, 528, buffer40, 692, 296);
} catch {}
try {
commandEncoder173.insertDebugMarker('\u707c');
} catch {}
document.body.prepend(img0);
let buffer111 = device0.createBuffer({size: 14605, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder174 = device0.createCommandEncoder({});
let texture157 = device0.createTexture({
  size: [60, 40, 42],
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '2d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder156 = commandEncoder173.beginComputePass({});
try {
computePassEncoder77.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder32.setBindGroup(0, bindGroup23, new Uint32Array(562), 104, 0);
} catch {}
document.body.append(img3);
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'smpte240m'} });
let texture158 = device0.createTexture({
  size: {width: 30, height: 12, depthOrArrayLayers: 50},
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture159 = device0.createTexture({
  size: {width: 1, height: 49, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder157 = commandEncoder174.beginComputePass({});
try {
computePassEncoder88.setBindGroup(0, bindGroup24, new Uint32Array(3610), 2_331, 0);
} catch {}
try {
renderPassEncoder41.setVertexBuffer(3, buffer31, 308);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
let bindGroup79 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [{binding: 235, resource: textureView129}, {binding: 167, resource: textureView70}],
});
let buffer112 = device0.createBuffer({
  size: 2381,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let querySet20 = device0.createQuerySet({type: 'occlusion', count: 1215});
let textureView153 = texture157.createView({dimension: '2d', baseArrayLayer: 8});
let texture160 = device0.createTexture({
  size: {width: 15, height: 6, depthOrArrayLayers: 1},
  sampleCount: 4,
  dimension: '2d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder74.setBindGroup(0, bindGroup76, []);
} catch {}
try {
renderPassEncoder38.setBindGroup(0, bindGroup74);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer104, 'uint16', 1_722, 3_081);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline6);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture159,
  mipLevel: 1,
  origin: {x: 0, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(43).fill(66), /* required buffer size: 43 */
{offset: 43, bytesPerRow: 38}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout38 = pipeline1.getBindGroupLayout(0);
let buffer113 = device0.createBuffer({size: 9385, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let commandEncoder175 = device0.createCommandEncoder({});
let texture161 = device0.createTexture({
  size: {width: 6, height: 198, depthOrArrayLayers: 36},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView154 = texture26.createView({aspect: 'depth-only', mipLevelCount: 1});
let computePassEncoder158 = commandEncoder175.beginComputePass({});
try {
computePassEncoder156.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup33);
} catch {}
try {
renderPassEncoder34.beginOcclusionQuery(237);
} catch {}
try {
renderPassEncoder34.endOcclusionQuery();
} catch {}
try {
renderPassEncoder32.setScissorRect(1, 29, 0, 8);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(6, buffer101, 64);
} catch {}
let bindGroup80 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout36,
  entries: [
    {binding: 48, resource: {buffer: buffer65, offset: 0, size: 208}},
    {binding: 263, resource: {buffer: buffer37, offset: 1536, size: 320}},
  ],
});
let textureView155 = texture118.createView({});
let textureView156 = texture43.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 24});
try {
renderPassEncoder12.setBindGroup(2, bindGroup45, new Uint32Array(2393), 810, 0);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer46, 'uint16', 670, 63);
} catch {}
try {
buffer89.unmap();
} catch {}
let buffer114 = device0.createBuffer({size: 4473, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let texture162 = device0.createTexture({
  size: {width: 6, height: 198, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder153.setPipeline(pipeline29);
} catch {}
try {
renderPassEncoder43.setScissorRect(2, 2, 24, 5);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer49, 0, 54);
} catch {}
await gc();
let texture163 = device0.createTexture({
  size: {width: 30, height: 20, depthOrArrayLayers: 86},
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView157 = texture31.createView({arrayLayerCount: 1});
try {
computePassEncoder131.setPipeline(pipeline12);
} catch {}
try {
computePassEncoder158.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline17);
} catch {}
try {
buffer1.unmap();
} catch {}
let promise25 = device0.createRenderPipelineAsync({
  label: '\ua02d\u3ec4\u9bfd\u0ce6\uc93f\u6ded\u{1fa76}\u20cd\u0e12\u850c',
  layout: pipelineLayout9,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL,
}],
},
  depthStencil: {
    format: 'depth16unorm',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilBack: {},
    stencilReadMask: 292240841,
    stencilWriteMask: 277116451,
    depthBias: -1132559458,
    depthBiasSlopeScale: 348.9173162108916,
  },
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 668,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 160, shaderLocation: 6},
          {format: 'snorm8x4', offset: 108, shaderLocation: 9},
          {format: 'sint32', offset: 96, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', cullMode: 'none', unclippedDepth: true},
});
let bindGroup81 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout3,
  entries: [
    {binding: 263, resource: {buffer: buffer105, offset: 0, size: 92}},
    {binding: 48, resource: {buffer: buffer77, offset: 768, size: 2796}},
  ],
});
let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout22]});
let commandEncoder176 = device0.createCommandEncoder({});
let sampler112 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 61.28});
try {
renderPassEncoder7.drawIndexedIndirect(buffer3, 188);
} catch {}
try {
commandEncoder176.copyBufferToBuffer(buffer105, 52, buffer30, 1724, 100);
} catch {}
let commandEncoder177 = device0.createCommandEncoder({});
let commandBuffer14 = commandEncoder176.finish();
let computePassEncoder159 = commandEncoder177.beginComputePass({});
try {
computePassEncoder123.setBindGroup(0, bindGroup37);
} catch {}
try {
computePassEncoder115.setBindGroup(0, bindGroup73, new Uint32Array(5231), 1_225, 0);
} catch {}
try {
computePassEncoder154.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder11.setBlendConstant({ r: 604.8, g: -38.38, b: 37.55, a: 476.6, });
} catch {}
try {
renderPassEncoder7.draw(14, 0, 285_195_373, 0);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer49, 92);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer65, 68);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer32, 'uint32', 980, 607);
} catch {}
let pipeline32 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4'}});
document.body.append(img1);
let img4 = await imageWithData(61, 24, '#10101010', '#20202020');
let bindGroup82 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout23,
  entries: [
    {binding: 263, resource: {buffer: buffer104, offset: 256, size: 108}},
    {binding: 48, resource: {buffer: buffer88, offset: 256, size: 212}},
  ],
});
let buffer115 = device0.createBuffer({size: 1929, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder178 = device0.createCommandEncoder();
let computePassEncoder160 = commandEncoder178.beginComputePass({});
try {
computePassEncoder157.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder7.drawIndexed(55, 0, 13, 260_432_089);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer34, 312);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer51, 392);
} catch {}
try {
computePassEncoder89.insertDebugMarker('\u031a');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let recycledExplicitBindGroupLayout39 = pipeline17.getBindGroupLayout(0);
try {
computePassEncoder160.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder7.end();
} catch {}
try {
renderPassEncoder23.setVertexBuffer(2, buffer5, 0, 1_325);
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1040 */
  offset: 1040,
  bytesPerRow: 21504,
  rowsPerImage: 320,
  buffer: buffer51,
}, {
  texture: texture145,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder27.copyTextureToBuffer({
  texture: texture138,
  mipLevel: 0,
  origin: {x: 0, y: 8, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 336 */
  offset: 336,
  bytesPerRow: 11520,
  buffer: buffer55,
}, {width: 0, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 212},
  aspect: 'all',
}, new Uint8Array(33_866).fill(207), /* required buffer size: 33_866 */
{offset: 650, bytesPerRow: 692, rowsPerImage: 12}, {width: 42, height: 0, depthOrArrayLayers: 5});
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
let computePassEncoder161 = commandEncoder27.beginComputePass({});
try {
computePassEncoder26.setBindGroup(0, bindGroup28, new Uint32Array(1075), 93, 0);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup28, new Uint32Array(2217), 242, 0);
} catch {}
let texture164 = device0.createTexture({
  size: [30, 20, 1],
  dimension: '2d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView158 = texture71.createView({baseMipLevel: 0});
try {
computePassEncoder33.setBindGroup(2, bindGroup45, new Uint32Array(776), 287, 0);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer45, 'uint16', 18, 1_728);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let textureView159 = texture87.createView({arrayLayerCount: 1});
try {
computePassEncoder55.setBindGroup(1, bindGroup15, new Uint32Array(176), 19, 0);
} catch {}
try {
computePassEncoder45.setPipeline(pipeline21);
} catch {}
try {
computePassEncoder159.setPipeline(pipeline12);
} catch {}
let arrayBuffer22 = buffer0.getMappedRange(272, 8);
let texture165 = device0.createTexture({
  size: {width: 15},
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView160 = texture111.createView({});
let sampler113 = device0.createSampler({addressModeU: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 99.21, compare: 'greater'});
try {
computePassEncoder161.setPipeline(pipeline21);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 10, depthOrArrayLayers: 143}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture126,
  mipLevel: 1,
  origin: {x: 2, y: 2, z: 27},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'jedecP22Phosphors', transfer: 'log'} });
try {
computePassEncoder81.end();
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline25);
} catch {}
try {
buffer102.unmap();
} catch {}
try {
commandEncoder93.copyBufferToBuffer(buffer35, 1420, buffer114, 244, 956);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 3, height: 99, depthOrArrayLayers: 51}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 0, y: 34, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
await gc();
let bindGroup83 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: [{binding: 235, resource: textureView103}]});
let commandEncoder179 = device0.createCommandEncoder({});
let computePassEncoder162 = commandEncoder179.beginComputePass({});
try {
renderPassEncoder20.setVertexBuffer(2, buffer112, 0);
} catch {}
let imageData14 = new ImageData(52, 40);
try {
textureView93.label = '\ua056\uc8bd\u8cfc\ue922\ub401\u0f92\ud2e2\u2e42\ud319';
} catch {}
let autogeneratedBindGroupLayout25 = pipeline32.getBindGroupLayout(0);
let buffer116 = device0.createBuffer({size: 30907, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder180 = device0.createCommandEncoder({});
let computePassEncoder163 = commandEncoder93.beginComputePass();
try {
computePassEncoder135.setBindGroup(2, bindGroup79);
} catch {}
try {
computePassEncoder163.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup51);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(2, buffer16, 0, 3_090);
} catch {}
try {
device0.queue.writeBuffer(buffer105, 88, new DataView(new ArrayBuffer(19452)), 419, 0);
} catch {}
let texture166 = device0.createTexture({
  size: {width: 3, height: 99, depthOrArrayLayers: 1},
  format: 'depth16unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder164 = commandEncoder180.beginComputePass();
let sampler114 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 89.19});
try {
computePassEncoder162.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder41.setBindGroup(3, bindGroup32, new Uint32Array(2510), 543, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer46, 'uint32', 476, 473);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder117.setBindGroup(3, bindGroup34, new Uint32Array(1596), 366, 0);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup63);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup41, new Uint32Array(1285), 120, 0);
} catch {}
try {
buffer100.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture97,
  mipLevel: 0,
  origin: {x: 5, y: 1, z: 92},
  aspect: 'all',
}, new Uint8Array(5_055).fill(160), /* required buffer size: 5_055 */
{offset: 345, bytesPerRow: 26, rowsPerImage: 12}, {width: 2, height: 2, depthOrArrayLayers: 16});
} catch {}
try {
  await promise26;
} catch {}
let commandEncoder181 = device0.createCommandEncoder();
let texture167 = device0.createTexture({
  size: [60, 40, 4],
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView161 = texture45.createView({
  label: '\u{1fcbd}\ue290\u{1f763}\u024d\u88e2\u{1ff7b}\u201a\uf6f0\u02e7',
  dimension: '2d-array',
  format: 'r32float',
});
let renderPassEncoder44 = commandEncoder181.beginRenderPass({
  colorAttachments: [{
  view: textureView27,
  clearValue: { r: 324.7, g: -513.1, b: 462.3, a: -697.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let sampler115 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.10,
});
try {
computePassEncoder108.setBindGroup(0, bindGroup76);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup28, new Uint32Array(2153), 940, 0);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer20, 'uint32', 5_808, 1_033);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(6, buffer112, 900, 203);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 60, height: 40, depthOrArrayLayers: 1}
*/
{
  source: imageData13,
  origin: { x: 2, y: 7 },
  flipY: false,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 4, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 3, depthOrArrayLayers: 0});
} catch {}
await gc();
let shaderModule9 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

enable f16;

var<private> vp7: mat4x2h = mat4x2h(1899.5, 8304.9, 1351.8, 23714.3, 13062.1, -7664.4, 5533.2, 19657.2);

@group(1) @binding(39) var<storage, read> buffer117: array<array<array<f16, 1>, 83>, 2>;

alias vec3b = vec3<bool>;

var<private> vp9 = modf(vec3h(-3738.8, -12432.2, 8847.1));

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

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

fn fn1(a0: mat3x4f) -> array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 1> {
  var out: array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 1>;
  vp9 = modf(vec3h(unpack2x16snorm(u32(unconst_u32(17))).xyx));
  let ptr94: ptr<private, f32> = &vp8[0][u32(unconst_u32(47))].fract;
  let ptr95: ptr<private, vec3h> = &vp9.whole;
  let vf118: f16 = (*ptr95)[u32(unconst_u32(298))];
  let ptr96: ptr<private, f32> = &(*ptr94);
  out[0][u32(unconst_u32(37))][u32(vp8[0][0].fract)][u32(unconst_u32(178))][u32(unconst_u32(399))] = f16(unpack2x16unorm(u32(unconst_u32(252))).r);
  let ptr97: ptr<private, vec2f> = &vp10.f23;
  vp9.fract = vec3h(step(vec3f(vp8[u32(unconst_u32(28))][0].whole), vec3f(unconst_f32(0.03142), unconst_f32(0.1000), unconst_f32(0.07868))));
  var vf119: mat3x4f = a0;
  vf119 -= mat3x4f(vp10.f21, vp10.f21, vp10.f21);
  let vf120: vec3f = step(vec3f(unconst_f32(0.1123), unconst_f32(0.1279), unconst_f32(0.06253)), vec3f(unconst_f32(0.05867), unconst_f32(0.1305), unconst_f32(0.01808)));
  return out;
}

fn fn2(a0: ptr<function, array<array<f32, 20>, 1>>, a1: ptr<function, mat3x2f>, a2: mat2x3h, a3: ptr<function, mat4x2h>) -> array<array<array<array<array<mat2x2f, 1>, 1>, 1>, 1>, 1> {
  var out: array<array<array<array<array<mat2x2f, 1>, 1>, 1>, 1>, 1>;
  let vf121: vec4f = sinh(vec4f(unconst_f32(0.00048), unconst_f32(0.3101), unconst_f32(0.00817), unconst_f32(0.09760)));
  let ptr98 = &vp8[u32(unconst_u32(42))][u32(unconst_u32(238))];
  (*a3) = vp7;
  let ptr99: ptr<function, mat3x2f> = &(*a1);
  fn0();
  (*a0)[u32(unconst_u32(60))][u32(unconst_u32(115))] = bitcast<f32>((*a3)[unconst_i32(3)]);
  vp8[u32(unconst_u32(75))][u32(unconst_u32(262))] = vp8[0][0];
  return out;
}

@group(2) @binding(235) var tex15: texture_2d<f32>;

var<workgroup> vw33: array<array<f16, 1>, 30>;

struct T1 {
  f0: array<u32, 4>,
  @size(316) f1: array<atomic<i32>>,
}

var<private> vp8 = array(array(modf(f32(0.01463))));

var<workgroup> vw35: atomic<i32>;

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

var<private> vp10: VertexOutput8 = VertexOutput8();

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

struct VertexOutput8 {
  @builtin(position) f21: vec4f,
  @location(10) @interpolate(perspective, centroid) f22: f16,
  @location(9) f23: vec2f,
  @location(5) @interpolate(flat, sample) f24: vec4u,
}

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

var<workgroup> vw32: vec2<bool>;

fn fn0() {
  vp10 = VertexOutput8(vp10.f23.rggg, vec2h(vp10.f23)[1], vp10.f23, bitcast<vec4u>(vp10.f23.xxxx));
  let ptr84 = &vp8[u32(unconst_u32(241))][0];
  vp10.f24 += vec4u(bitcast<u32>(vp8[0][0].whole));
  let ptr85: ptr<private, f32> = &(*ptr84).whole;
  let ptr86: ptr<private, mat4x2h> = &vp7;
  let ptr87: ptr<private, vec2f> = &vp10.f23;
  let ptr88: ptr<private, vec4f> = &vp10.f21;
  vp9 = modf(vec3h(f16(pack2x16float(vec2f(unconst_f32(0.1130), unconst_f32(0.5339))))));
  var vf114: vec2h = (*ptr86)[u32(unconst_u32(58))];
  let ptr89: ptr<private, vec4f> = &vp10.f21;
  let ptr90: ptr<private, vec4f> = &vp10.f21;
  let ptr91: ptr<private, f32> = &(*ptr84).fract;
  vp9.fract -= vec3h(f16((*ptr91)));
  vf114 -= bitcast<vec2h>((*ptr91));
  var vf115: f16 = vf114[u32(unconst_u32(180))];
  vp7 -= mat4x2h(vec2h(exp(vec4f(unconst_f32(0.1144), unconst_f32(0.1101), unconst_f32(0.03167), unconst_f32(0.03187))).xx), vec2h(exp(vec4f(unconst_f32(0.1144), unconst_f32(0.1101), unconst_f32(0.03167), unconst_f32(0.03187))).xx), vec2h(exp(vec4f(unconst_f32(0.1144), unconst_f32(0.1101), unconst_f32(0.03167), unconst_f32(0.03187))).zw), vec2h(exp(vec4f(unconst_f32(0.1144), unconst_f32(0.1101), unconst_f32(0.03167), unconst_f32(0.03187))).ab));
  vf115 -= f16(vp8[u32(unconst_u32(111))][0].fract);
  let ptr92 = &vp8[0];
  let ptr93: ptr<private, f32> = &vp8[bitcast<vec3u>(max(vec3i(unconst_i32(56), unconst_i32(5), unconst_i32(-35)), vec3i(unconst_i32(551), unconst_i32(-1000), unconst_i32(192))))[0]][u32(unconst_u32(32))].fract;
  vp7 = mat4x2h(vec2h(vp10.f23), vec2h(vp10.f23), vec2h(vp10.f23), vec2h(vp10.f23));
  vp7 = mat4x2h(f16(vp8[u32(unconst_u32(88))][u32(unconst_u32(458))].fract), f16(vp8[u32(unconst_u32(88))][u32(unconst_u32(458))].fract), f16(vp8[u32(unconst_u32(88))][u32(unconst_u32(458))].fract), f16(vp8[u32(unconst_u32(88))][u32(unconst_u32(458))].fract), f16(vp8[u32(unconst_u32(88))][u32(unconst_u32(458))].fract), f16(vp8[u32(unconst_u32(88))][u32(unconst_u32(458))].fract), f16(vp8[u32(unconst_u32(88))][u32(unconst_u32(458))].fract), f16(vp8[u32(unconst_u32(88))][u32(unconst_u32(458))].fract));
  var vf116: vec2f = unpack2x16unorm(u32(unconst_u32(85)));
  let vf117: f32 = (*ptr87)[u32(unconst_u32(10))];
}

struct T0 {
  @size(296) f0: array<array<array<vec4h, 5>, 4>, 1>,
}

var<workgroup> vw31: vec4h;

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

@vertex
fn vertex8(@builtin(vertex_index) a0: u32, @location(13) a1: f32) -> VertexOutput8 {
  var out: VertexOutput8;
  vp8[u32(unconst_u32(91))][u32(unconst_u32(1000))].fract = vp8[u32(unconst_u32(63))][0].fract;
  let ptr100: ptr<storage, f16, read> = &buffer117[1][u32(unconst_u32(24))][u32(unconst_u32(344))];
  let ptr101: ptr<storage, array<f16, 1>, read> = &buffer117[1][u32(unconst_u32(413))];
  out.f24 *= vec4u(u32((*&buffer117)[1][82][0]));
  let ptr102: ptr<storage, array<f16, 1>, read> = &buffer117[u32(unconst_u32(126))][textureNumLevels(tex15)];
  out.f21 = vec4f(f32((*&buffer117)[u32(unconst_u32(62))][82][0]));
  let vf122: f32 = a1;
  var vf123 = fn1(mat3x4f(unconst_f32(0.07053), unconst_f32(0.3256), unconst_f32(0.3051), unconst_f32(0.00771), unconst_f32(0.3008), unconst_f32(0.2314), unconst_f32(0.02544), unconst_f32(-0.2200), unconst_f32(0.1068), unconst_f32(0.08497), unconst_f32(-0.04591), unconst_f32(0.00518)));
  return out;
  _ = tex15;
  _ = buffer117;
}

@compute @workgroup_size(1, 1, 2)
fn compute13() {
  fn0();
  atomicCompareExchangeWeak(&vw35, unconst_i32(124), unconst_i32(207));
  vp8[u32(unconst_u32(248))][u32(unconst_u32(287))] = modf(f32(vp10.f22));
  fn0();
  let ptr103: ptr<private, vec4u> = &vp10.f24;
  let vf124: vec2<bool> = workgroupUniformLoad(&vw32);
  fn0();
  atomicOr(&vw34[u32(unconst_u32(140))], i32(unconst_i32(374)));
}`,
});
let bindGroup84 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout8,
  entries: [
    {binding: 263, resource: {buffer: buffer30, offset: 512, size: 288}},
    {binding: 48, resource: {buffer: buffer62, offset: 256}},
  ],
});
let querySet21 = device0.createQuerySet({type: 'occlusion', count: 127});
let textureView162 = texture27.createView({
  label: '\uc61c\u0643\uefe3\ube73\u{1fd94}\u4df7',
  dimension: '2d-array',
  mipLevelCount: 1,
  baseArrayLayer: 0,
});
try {
computePassEncoder87.end();
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup63, new Uint32Array(1500), 23, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer66, 'uint16', 1_220, 317);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline27);
} catch {}
try {
commandEncoder102.copyTextureToBuffer({
  texture: texture115,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 22 */
  offset: 22,
  bytesPerRow: 15616,
  buffer: buffer94,
}, {width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer75, 8, new DataView(new ArrayBuffer(2386)), 126, 224);
} catch {}
let buffer118 = device0.createBuffer({
  size: 3853,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let textureView163 = texture134.createView({});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true});
let renderBundle20 = renderBundleEncoder20.finish({});
try {
computePassEncoder152.setBindGroup(0, bindGroup55, new Uint32Array(4609), 982, 0);
} catch {}
try {
computePassEncoder164.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup64);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer28, 'uint16', 114, 848);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(3, buffer49, 0);
} catch {}
try {
commandEncoder102.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1722 */
  offset: 1722,
  buffer: buffer59,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline33 = device0.createRenderPipeline({
  layout: pipelineLayout8,
  multisample: {mask: 0x2e719d74},
  fragment: {
  module: shaderModule3,
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 140,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 0, shaderLocation: 11}, {format: 'uint8x2', offset: 2, shaderLocation: 6}],
      },
      {
        arrayStride: 580,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 12, shaderLocation: 9}],
      },
    ],
  },
});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup85 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout9,
  entries: [
    {binding: 263, resource: {buffer: buffer106, offset: 256}},
    {binding: 48, resource: {buffer: buffer58, offset: 0, size: 408}},
  ],
});
let commandEncoder182 = device0.createCommandEncoder();
let renderPassEncoder45 = commandEncoder182.beginRenderPass({
  colorAttachments: [{
  view: textureView163,
  depthSlice: 28,
  clearValue: { r: 761.2, g: 440.4, b: -268.1, a: 510.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder27.setIndexBuffer(buffer115, 'uint32', 48, 330);
} catch {}
try {
commandEncoder102.copyBufferToBuffer(buffer46, 560, buffer111, 1736, 356);
} catch {}
try {
commandEncoder102.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 842 */
  offset: 842,
  bytesPerRow: 512,
  buffer: buffer45,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder102.resolveQuerySet(querySet7, 16, 2, buffer5, 512);
} catch {}
try {
computePassEncoder61.insertDebugMarker('\ua0e2');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture147,
  mipLevel: 0,
  origin: {x: 121, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(22).fill(236), /* required buffer size: 22 */
{offset: 22}, {width: 48, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer119 = device0.createBuffer({
  size: 2864,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let sampler116 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.37,
  compare: 'not-equal',
  maxAnisotropy: 20,
});
try {
renderPassEncoder16.setBindGroup(2, bindGroup72, new Uint32Array(2741), 439, 0);
} catch {}
try {
renderPassEncoder34.beginOcclusionQuery(13);
} catch {}
try {
renderPassEncoder34.endOcclusionQuery();
} catch {}
try {
renderPassEncoder20.setViewport(329.69910370452914, 0.02262200507839396, 22.460991091236128, 0.2766149215724708, 0.8722191613392274, 0.9955431554614615);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer89, 'uint16', 34, 44);
} catch {}
try {
renderPassEncoder32.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(0, buffer90, 0, 3_138);
} catch {}
let promise27 = device0.queue.onSubmittedWorkDone();
try {
  await promise27;
} catch {}
let bindGroup86 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [
    {binding: 263, resource: {buffer: buffer73, offset: 0, size: 236}},
    {binding: 48, resource: {buffer: buffer26, offset: 8448}},
  ],
});
let textureView164 = texture127.createView({dimension: '1d'});
let renderPassEncoder46 = commandEncoder102.beginRenderPass({
  colorAttachments: [{
  view: textureView131,
  depthSlice: 0,
  clearValue: { r: 736.1, g: 401.2, b: -177.6, a: -463.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 1234567890,
});
try {
renderPassEncoder38.setBindGroup(0, bindGroup72);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer118, 'uint16', 2_452, 185);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(4, buffer28, 200, 502);
} catch {}
try {
buffer57.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 365, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 124, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'bt470m', transfer: 'iec61966-2-1'} });
let recycledExplicitBindGroupLayout40 = pipeline1.getBindGroupLayout(0);
let bindGroup87 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout23,
  entries: [
    {binding: 263, resource: {buffer: buffer54, offset: 0, size: 8}},
    {binding: 48, resource: {buffer: buffer82, offset: 256, size: 3180}},
  ],
});
let buffer120 = device0.createBuffer({size: 3152, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder183 = device0.createCommandEncoder({});
let texture168 = device0.createTexture({
  size: {width: 12, height: 396, depthOrArrayLayers: 118},
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder165 = commandEncoder183.beginComputePass();
try {
computePassEncoder150.setBindGroup(0, bindGroup80);
} catch {}
try {
computePassEncoder165.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer71, 'uint32', 472, 2_239);
} catch {}
let arrayBuffer23 = buffer35.getMappedRange(552, 0);
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([commandBuffer14]);
} catch {}
let autogeneratedBindGroupLayout26 = pipeline26.getBindGroupLayout(0);
let commandEncoder184 = device0.createCommandEncoder({});
let texture169 = device0.createTexture({
  size: [30, 12, 11],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder63.setBindGroup(0, bindGroup58, new Uint32Array(414), 23, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer3, 1_524); };
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup47);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup64, new Uint32Array(41), 7, 0);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer98, 'uint32', 3_692, 552);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline22);
} catch {}
try {
commandEncoder184.copyTextureToBuffer({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1084 */
  offset: 1084,
  bytesPerRow: 13056,
  buffer: buffer8,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup88 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout39,
  entries: [
    {binding: 263, resource: {buffer: buffer1, offset: 256, size: 284}},
    {binding: 48, resource: {buffer: buffer82, offset: 1536, size: 2200}},
  ],
});
let pipelineLayout15 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout23, recycledExplicitBindGroupLayout28]});
let commandEncoder185 = device0.createCommandEncoder({});
let computePassEncoder166 = commandEncoder185.beginComputePass({});
let sampler117 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 87.83,
  compare: 'greater-equal',
});
try {
computePassEncoder151.setBindGroup(3, bindGroup36, new Uint32Array(2650), 231, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder79); computePassEncoder79.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder166.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder10.end();
} catch {}
try {
renderPassEncoder40.insertDebugMarker('\u340b');
} catch {}
let commandBuffer15 = commandEncoder40.finish();
let sampler118 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', mipmapFilter: 'linear', lodMaxClamp: 90.60});
try {
computePassEncoder149.setBindGroup(0, bindGroup19);
} catch {}
try {
renderPassEncoder34.setBindGroup(0, bindGroup49, []);
} catch {}
try {
renderPassEncoder37.setBindGroup(0, bindGroup59, new Uint32Array(815), 233, 0);
} catch {}
try {
commandEncoder184.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 6022 */
  offset: 6022,
  bytesPerRow: 4864,
  buffer: buffer1,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout41 = pipeline1.getBindGroupLayout(0);
let bindGroup89 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout36,
  entries: [
    {binding: 263, resource: {buffer: buffer29, offset: 0}},
    {binding: 48, resource: {buffer: buffer1, offset: 256, size: 1296}},
  ],
});
let commandEncoder186 = device0.createCommandEncoder({});
let querySet22 = device0.createQuerySet({type: 'occlusion', count: 1181});
let texture170 = device0.createTexture({
  size: {width: 15, height: 6, depthOrArrayLayers: 20},
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder47 = commandEncoder186.beginRenderPass({
  colorAttachments: [{
  view: textureView70,
  clearValue: { r: 855.8, g: -408.7, b: -482.3, a: 985.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  depthStencilAttachment: {view: textureView81, depthClearValue: 8.478786109219197, depthReadOnly: true, stencilClearValue: 55941},
  maxDrawCount: 9359687,
});
try {
renderPassEncoder32.setIndexBuffer(buffer75, 'uint32', 100, 202);
} catch {}
try {
commandEncoder184.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2152 */
  offset: 2152,
  buffer: buffer36,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.submit([commandBuffer15]);
} catch {}
let commandEncoder187 = device0.createCommandEncoder({});
let texture171 = device0.createTexture({size: [15, 6, 10], format: 'depth16unorm', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder141.setBindGroup(3, bindGroup11);
} catch {}
try {
computePassEncoder143.setBindGroup(0, bindGroup82, new Uint32Array(633), 104, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline26);
} catch {}
try {
commandEncoder187.copyBufferToTexture({
  /* bytesInLastRow: 60 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 316 */
  offset: 316,
  bytesPerRow: 36864,
  rowsPerImage: 1031,
  buffer: buffer23,
}, {
  texture: texture98,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise28 = device0.queue.onSubmittedWorkDone();
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
if (!arrayBuffer23.detached) { new Uint8Array(arrayBuffer23).fill(0x55); };
} catch {}
let buffer121 = device0.createBuffer({
  size: 7451,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder188 = device0.createCommandEncoder({});
let textureView165 = texture161.createView({mipLevelCount: 1});
let computePassEncoder167 = commandEncoder187.beginComputePass({});
let renderPassEncoder48 = commandEncoder188.beginRenderPass({
  colorAttachments: [{
  view: textureView147,
  clearValue: { r: 199.2, g: -682.9, b: 461.9, a: -51.34, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder78.setBindGroup(0, bindGroup31, new Uint32Array(41), 10, 0);
} catch {}
try {
computePassEncoder167.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder33.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder29.setStencilReference(880);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer34, 'uint16', 36, 3_080);
} catch {}
try {
device0.queue.writeBuffer(buffer105, 36, new Float32Array(3536), 502, 0);
} catch {}
let bindGroup90 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout30,
  entries: [
    {binding: 48, resource: {buffer: buffer80, offset: 256, size: 696}},
    {binding: 263, resource: {buffer: buffer6, offset: 0}},
  ],
});
let textureView166 = texture127.createView({aspect: 'all', arrayLayerCount: 1});
let renderPassEncoder49 = commandEncoder184.beginRenderPass({
  colorAttachments: [{
  view: textureView78,
  clearValue: { r: -627.2, g: -228.1, b: 544.2, a: -604.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 162093630,
});
try {
computePassEncoder150.setBindGroup(0, bindGroup59, new Uint32Array(1078), 22, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroups(1, 3); };
} catch {}
try {
renderPassEncoder32.setBindGroup(2, bindGroup0, new Uint32Array(1721), 53, 0);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(0, buffer47);
} catch {}
try {
device0.queue.writeBuffer(buffer36, 4412, new BigUint64Array(13795), 260, 260);
} catch {}
let bindGroup91 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [
    {binding: 235, resource: textureView150},
    {binding: 263, resource: {buffer: buffer12, offset: 1536, size: 4556}},
    {binding: 48, resource: {buffer: buffer43, offset: 256, size: 688}},
  ],
});
let buffer122 = device0.createBuffer({
  size: 6931,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let sampler119 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 76.03});
try {
computePassEncoder162.setBindGroup(0, bindGroup82, new Uint32Array(1658), 270, 0);
} catch {}
try {
renderPassEncoder45.setStencilReference(324);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer33, 'uint16', 3_930, 201);
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder49.setVertexBuffer(3, buffer95, 292, 162);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 56,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 227,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let recycledExplicitBindGroupLayout42 = pipeline5.getBindGroupLayout(0);
try {
computePassEncoder32.setBindGroup(0, bindGroup48, new Uint32Array(4742), 154, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder76); computePassEncoder76.dispatchWorkgroupsIndirect(buffer28, 68); };
} catch {}
let arrayBuffer24 = buffer72.getMappedRange(320, 316);
let buffer123 = device0.createBuffer({
  label: '\u9220\u0a14\u9570\u84ea\u0ed2\u7ead\u{1f9e9}',
  size: 9461,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder189 = device0.createCommandEncoder({});
let computePassEncoder168 = commandEncoder189.beginComputePass({});
try {
computePassEncoder56.end();
} catch {}
try {
computePassEncoder168.setPipeline(pipeline29);
} catch {}
try {
buffer120.unmap();
} catch {}
let shaderModule10 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires pointer_composite_access;

enable f16;

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

var<workgroup> vw37: VertexOutput9;

struct T1 {
  @size(332) f0: atomic<u32>,
}

@group(2) @binding(235) var tex19: texture_2d<f32>;

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

var<workgroup> vw38: VertexOutput9;

alias vec3b = vec3<bool>;

var<workgroup> vw40: array<vec2f, 1>;

var<workgroup> vw36: mat2x2f;

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

@group(1) @binding(39) var<storage, read> buffer124: array<f16, 166>;

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

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

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

var<workgroup> vw39: array<array<atomic<u32>, 1>, 4>;

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

var<workgroup> vw41: atomic<i32>;

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

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

@vertex
fn vertex9(@location(0) a0: i32) -> VertexOutput9 {
  var out: VertexOutput9;
  out.f25 = vec4f(f32((*&buffer124)[u32(unconst_u32(334))]));
  var vf125: vec2u = textureDimensions(tex19, i32(unconst_i32(70)));
  let vf126: vec2u = textureDimensions(tex19);
  return out;
  _ = tex19;
  _ = buffer124;
}

@compute @workgroup_size(1, 1, 1)
fn compute14() {
  vw42[u32(unconst_u32(10))] = vec2<bool>(bool(buffer124[165]));
  let vf127: u32 = atomicLoad(&vw39[3][0]);
  let ptr104: ptr<workgroup, vec2<bool>> = &vw42[u32(unconst_u32(401))];
  var vf128: u32 = atomicExchange(&vw39[3][0], u32(unconst_u32(676)));
  let ptr105: ptr<storage, f16, read> = &(*&buffer124)[u32(unconst_u32(100))];
  let ptr106: ptr<workgroup, atomic<u32>> = &(*&vw39)[3][0];
  _ = buffer124;
}`,
});
let texture172 = device0.createTexture({
  size: [15, 6, 1],
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder169 = commandEncoder72.beginComputePass({});
try {
computePassEncoder113.setBindGroup(0, bindGroup32, new Uint32Array(82), 25, 0);
} catch {}
try {
renderPassEncoder48.setBindGroup(3, bindGroup0, new Uint32Array(403), 138, 0);
} catch {}
try {
renderPassEncoder42.setPipeline(pipeline22);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(4_454).fill(192), /* required buffer size: 4_454 */
{offset: 93, bytesPerRow: 39, rowsPerImage: 16}, {width: 16, height: 16, depthOrArrayLayers: 7});
} catch {}
let bindGroup92 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout41,
  entries: [
    {binding: 263, resource: {buffer: buffer61, offset: 4096}},
    {binding: 48, resource: {buffer: buffer114, offset: 256, size: 368}},
  ],
});
let buffer125 = device0.createBuffer({size: 5420, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder190 = device0.createCommandEncoder({});
let texture173 = device0.createTexture({
  size: [30, 20, 179],
  mipLevelCount: 2,
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder170 = commandEncoder190.beginComputePass({});
let sampler120 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 18,
});
try {
computePassEncoder50.setBindGroup(1, bindGroup48, new Uint32Array(1847), 510, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder118); computePassEncoder118.dispatchWorkgroupsIndirect(buffer17, 984); };
} catch {}
try {
computePassEncoder169.setPipeline(pipeline15);
} catch {}
try {
  await shaderModule9.getCompilationInfo();
} catch {}
try {
buffer36.unmap();
} catch {}
try {
computePassEncoder89.setBindGroup(0, bindGroup76);
} catch {}
try {
computePassEncoder110.end();
} catch {}
try {
computePassEncoder170.setPipeline(pipeline24);
} catch {}
try {
buffer40.unmap();
} catch {}
document.body.prepend(canvas1);
let autogeneratedBindGroupLayout27 = pipeline3.getBindGroupLayout(0);
let renderPassEncoder50 = commandEncoder126.beginRenderPass({
  label: '\u0e09\u0afa\u09fe\u91ed',
  colorAttachments: [{
  view: textureView64,
  clearValue: { r: 785.3, g: -563.1, b: 232.6, a: -173.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet9,
  maxDrawCount: 136020066,
});
try {
renderPassEncoder23.beginOcclusionQuery(108);
} catch {}
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte432', transfer: 'logSqrt'} });
let textureView167 = texture161.createView({format: 'r8uint', mipLevelCount: 1});
let sampler121 = device0.createSampler({addressModeV: 'repeat', magFilter: 'linear', lodMaxClamp: 69.76});
try {
computePassEncoder29.setBindGroup(0, bindGroup29);
} catch {}
try {
renderPassEncoder29.setBindGroup(3, bindGroup67);
} catch {}
try {
renderPassEncoder45.setBindGroup(1, bindGroup32, new Uint32Array(975), 324, 0);
} catch {}
let arrayBuffer25 = buffer21.getMappedRange(24, 8);
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let bindGroup93 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout31,
  entries: [
    {binding: 48, resource: {buffer: buffer38, offset: 2816, size: 196}},
    {binding: 263, resource: {buffer: buffer44, offset: 256}},
  ],
});
let texture174 = device0.createTexture({
  size: [16, 16, 12],
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder170.setBindGroup(0, bindGroup64, new Uint32Array(2928), 63, 0);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(3, buffer2, 0, 137);
} catch {}
let texture175 = device0.createTexture({
  size: {width: 1, height: 49, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView168 = texture75.createView({dimension: '2d-array', aspect: 'depth-only'});
try {
computePassEncoder128.setBindGroup(1, bindGroup69, new Uint32Array(4596), 337, 0);
} catch {}
try {
renderPassEncoder23.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline33);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 20, depthOrArrayLayers: 286}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 10, y: 2, z: 41},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 56,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 227,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer126 = device0.createBuffer({size: 3837, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
try {
renderPassEncoder17.beginOcclusionQuery(163);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer99, 'uint16', 4_464, 431);
} catch {}
try {
buffer68.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 396, depthOrArrayLayers: 118}
*/
{
  source: videoFrame19,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture168,
  mipLevel: 0,
  origin: {x: 0, y: 35, z: 42},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline18);
} catch {}
let buffer127 = device0.createBuffer({
  size: 3119,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let commandEncoder191 = device0.createCommandEncoder({});
let textureView169 = texture172.createView({dimension: '2d-array', aspect: 'depth-only'});
try {
renderPassEncoder34.setScissorRect(0, 1, 0, 2);
} catch {}
try {
renderPassEncoder42.setIndexBuffer(buffer75, 'uint32', 20, 84);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(4, buffer67, 1_056, 1_179);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture148,
  mipLevel: 0,
  origin: {x: 0, y: 23, z: 0},
  aspect: 'all',
}, new Uint8Array(103).fill(225), /* required buffer size: 103 */
{offset: 103, bytesPerRow: 123}, {width: 0, height: 142, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup94 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout35,
  entries: [
    {binding: 263, resource: {buffer: buffer118, offset: 0, size: 328}},
    {binding: 48, resource: {buffer: buffer66, offset: 2560, size: 532}},
  ],
});
let renderPassEncoder51 = commandEncoder191.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: 447.3, g: -472.6, b: -547.3, a: 93.26, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet16,
});
try {
renderPassEncoder27.setBindGroup(0, bindGroup46);
} catch {}
try {
renderPassEncoder49.setScissorRect(50, 0, 15, 0);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline8);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder192 = device0.createCommandEncoder({});
let texture176 = device0.createTexture({
  size: [60, 24, 1],
  mipLevelCount: 2,
  format: 'eac-r11snorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let computePassEncoder171 = commandEncoder192.beginComputePass({});
try {
renderPassEncoder48.setPipeline(pipeline31);
} catch {}
await gc();
let shaderModule11 = device0.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

requires readonly_and_readwrite_storage_textures;

var<private> vp11 = array(modf(vec2h(2440.6, 1692.9)));

struct T0 {
  @size(176) f0: array<vec4i, 1>,
  @align(16) @size(320) f1: array<array<vec2f, 29>, 1>,
}

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

@id(11343) override override8: f16;

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

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

override override9 = false;

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

fn fn1() -> bool {
  var out: bool;
  vp11[u32(unconst_u32(124))].whole = vec2h(buffer128[123][0][1][0]);
  let ptr114: ptr<storage, f16, read> = &buffer128[u32(unconst_u32(40))][0][u32(unconst_u32(406))][0];
  let ptr115: ptr<storage, array<array<f16, 1>, 2>, read> = &buffer128[123][u32(unconst_u32(184))];
  let ptr116: ptr<storage, f16, read> = &(*&buffer128)[123][u32(unconst_u32(82))][u32(unconst_u32(75))][u32(unconst_u32(345))];
  let ptr117: ptr<storage, f16, read> = &(*&buffer128)[u32(unconst_u32(255))][0][u32(unconst_u32(229))][0];
  var vf129 = fn0();
  out = bool((*&buffer128)[u32(unconst_u32(1))][u32(unconst_u32(16))][1][0]);
  vf129[u32(unconst_u32(158))] = u32(buffer128[123][u32(unconst_u32(145))][1][0]);
  let ptr118: ptr<storage, array<f16, 1>, read> = &(*&buffer128)[123][0][u32(unconst_u32(121))];
  var vf130 = fn0();
  return out;
  _ = buffer128;
}

fn fn0() -> array<u32, 1> {
  var out: array<u32, 1>;
  let ptr107: ptr<storage, array<array<f16, 1>, 2>, read> = &(*&buffer128)[123][0];
  let ptr108: ptr<storage, f16, read> = &(*ptr107)[u32(unconst_u32(138))][u32(unconst_u32(11))];
  let ptr109: ptr<storage, array<array<array<f16, 1>, 2>, 1>, read> = &buffer128[123];
  out[u32(unconst_u32(50))] -= u32(buffer128[u32(unconst_u32(354))][0][1][0]);
  let ptr110: ptr<storage, array<f16, 1>, read> = &(*ptr109)[0][u32(unconst_u32(573))];
  let ptr111 = &vp11[pack4xU8Clamp(vec4u(unconst_u32(830), unconst_u32(23), unconst_u32(33), unconst_u32(161)))];
  out[0] = u32((*&buffer128)[u32((*&buffer128)[123][0][1][0])][u32(unconst_u32(220))][1][0]);
  let ptr112: ptr<storage, f16, read> = &(*&buffer128)[123][0][u32(unconst_u32(52))][0];
  let ptr113: ptr<storage, f16, read> = &(*&buffer128)[123][0][1][u32((*&buffer128)[123][0][1][u32(unconst_u32(14))])];
  vp11[u32(unconst_u32(107))] = modf(vec2h((*ptr113)));
  return out;
  _ = buffer128;
}

override override5: f32;

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

@group(0) @binding(761) var<storage, read> buffer128: array<array<array<array<f16, 1>, 2>, 1>, 124>;

override override3: bool;

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

override override4 = -0.1437;

@id(24281) override override7: u32 = 210;

@id(45745) override override6: u32;

alias vec3b = vec3<bool>;

@vertex
fn vertex10(@location(13) @interpolate(perspective, sample) a0: f16) -> VertexOutput10 {
  var out: VertexOutput10;
  fn0();
  var vf131 = fn1();
  fn0();
  out.f26 *= vec4f(f32((*&buffer128)[u32(unconst_u32(69))][u32(vf131)][u32((*&buffer128)[123][u32(unconst_u32(64))][u32(unconst_u32(258))][0])][0]));
  vf131 = bool(buffer128[123][0][1][0]);
  vp11[u32(unconst_u32(642))] = modf(vec2h(buffer128[u32(unconst_u32(303))][u32(unconst_u32(143))][u32(unconst_u32(95))][u32(unconst_u32(203))]));
  out.f26 += vec4f(f32((*&buffer128)[123][0][1][0]));
  fn0();
  let ptr119: ptr<storage, f16, read> = &buffer128[u32(unconst_u32(210))][u32(unconst_u32(300))][u32(unconst_u32(23))][u32(unconst_u32(304))];
  vp11[u32(unconst_u32(297))].fract = vec2h(buffer128[123][u32(unconst_u32(114))][u32(unconst_u32(305))][0]);
  out.f26 += vec4f(f32((*&buffer128)[u32(unconst_u32(506))][0][u32((*&buffer128)[123][u32(unconst_u32(225))][1][0])][0]));
  vf131 = bool(buffer128[u32(unconst_u32(252))][u32(unconst_u32(37))][1][0]);
  let ptr120: ptr<storage, array<f16, 1>, read> = &buffer128[123][u32(reflect(vec3h(unconst_f16(11439.5), unconst_f16(31953.4), unconst_f16(30199.3)), vec3h(unconst_f16(6278.5), unconst_f16(15600.7), unconst_f16(201.7))).x)][u32(unconst_u32(185))];
  var vf132 = fn1();
  fn1();
  let ptr121: ptr<storage, array<f16, 1>, read> = &buffer128[u32(unconst_u32(178))][0][u32(unconst_u32(60))];
  fn0();
  var vf133 = fn0();
  vf132 = bool((*&buffer128)[123][0][u32(unconst_u32(114))][0]);
  var vf134 = fn1();
  vf133[u32((*&buffer128)[123][0][u32(unconst_u32(114))][0])] >>= u32((*&buffer128)[u32(unconst_u32(56))][u32(unconst_u32(87))][u32(unconst_u32(59))][0]);
  vf131 = bool(buffer128[u32((*&buffer128)[u32(unconst_u32(228))][u32(unconst_u32(155))][1][0])][0][1][0]);
  vf134 = bool(vp11[u32(unconst_u32(16))].fract[1]);
  let ptr122: ptr<storage, f16, read> = &(*&buffer128)[u32(unconst_u32(39))][0][1][u32(unconst_u32(14))];
  let ptr123: ptr<storage, f16, read> = &buffer128[123][0][u32(unconst_u32(387))][0];
  return out;
  _ = buffer128;
}

@compute @workgroup_size(4, 1, 1)
fn compute15() {
  vp11[u32(unconst_u32(178))].whole += bitcast<vec2h>(override6);
  _ = override6;
}`,
});
let autogeneratedBindGroupLayout28 = pipeline20.getBindGroupLayout(0);
let buffer129 = device0.createBuffer({size: 914, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let textureView170 = texture59.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 3});
try {
computePassEncoder67.setPipeline(pipeline32);
} catch {}
try {
renderPassEncoder50.setBindGroup(3, bindGroup48, new Uint32Array(1643), 262, 0);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline6);
} catch {}
try {
buffer44.label = '\u0fac\u0fe9\u0c3c\u9c2e\u{1fbea}\u0922\ube6a\u{1f8e4}';
} catch {}
let texture177 = device0.createTexture({
  label: '\u{1f986}\ua814\u08f6',
  size: [1460, 1, 5],
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView171 = texture108.createView({dimension: '2d-array'});
let sampler122 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 92.39,
  lodMaxClamp: 93.73,
  compare: 'always',
});
let externalTexture27 = device0.importExternalTexture({source: videoFrame7});
try {
computePassEncoder27.setBindGroup(0, bindGroup94);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(2, undefined, 664_958_585);
} catch {}
try {
buffer8.unmap();
} catch {}
let pipeline34 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule10}});
let commandEncoder193 = device0.createCommandEncoder({});
let commandBuffer16 = commandEncoder193.finish();
try {
computePassEncoder171.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder36.setPipeline(pipeline33);
} catch {}
try {
renderPassEncoder33.setVertexBuffer(1, buffer54, 696, 6);
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(68, 90);
let buffer130 = device0.createBuffer({size: 27140, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let sampler123 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  lodMinClamp: 12.39,
});
let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'bt470bg', transfer: 'pq'} });
let buffer131 = device0.createBuffer({size: 1653, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let sampler124 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'clamp-to-edge', lodMaxClamp: 81.56});
try {
computePassEncoder128.setBindGroup(0, bindGroup12, new Uint32Array(158), 55, 0);
} catch {}
let bindGroup95 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout12,
  entries: [
    {binding: 263, resource: {buffer: buffer73, offset: 0, size: 44}},
    {binding: 48, resource: {buffer: buffer106, offset: 1536}},
  ],
});
let commandEncoder194 = device0.createCommandEncoder({});
let texture178 = device0.createTexture({
  size: {width: 60, height: 24, depthOrArrayLayers: 101},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture179 = device0.createTexture({
  size: {width: 6, height: 198, depthOrArrayLayers: 1},
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView172 = texture2.createView({dimension: '2d', baseArrayLayer: 1});
let renderPassEncoder52 = commandEncoder194.beginRenderPass({
  colorAttachments: [{view: textureView163, depthSlice: 5, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet16,
});
let sampler125 = device0.createSampler({label: '\u3fda\u3dc1', addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 93.26});
try {
computePassEncoder102.setBindGroup(0, bindGroup21, new Uint32Array(347), 58, 0);
} catch {}
try {
renderPassEncoder31.setBindGroup(3, bindGroup79, new Uint32Array(5446), 2_238, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, buffer112, 528, 31);
} catch {}
document.body.prepend(img1);
let textureView173 = texture178.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthStencilFormat: 'depth16unorm', sampleCount: 1, stencilReadOnly: true});
try {
renderPassEncoder39.setBindGroup(3, bindGroup51);
} catch {}
try {
renderPassEncoder12.draw(0, 306, 0, 7_900_821);
} catch {}
try {
renderPassEncoder12.drawIndexed(105, 110, 60, -1_609_534_557, 1_071_391_770);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer2, 1_076);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer68, 232);
} catch {}
try {
renderPassEncoder41.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(5, buffer7);
} catch {}
let querySet23 = device0.createQuerySet({type: 'occlusion', count: 382});
try {
renderPassEncoder12.draw(0, 82, 0, 495_479_872);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer16, 1_076);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(6, buffer2, 12, 471);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let texture180 = device0.createTexture({
  size: [3, 99, 1],
  sampleCount: 4,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint']});
let sampler126 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 13,
});
try {
computePassEncoder33.setBindGroup(0, bindGroup22, new Uint32Array(1416), 291, 0);
} catch {}
try {
renderPassEncoder48.setBindGroup(0, bindGroup77);
} catch {}
try {
renderPassEncoder49.setBlendConstant({ r: -756.8, g: -413.5, b: -89.15, a: 39.51, });
} catch {}
try {
renderPassEncoder12.draw(0, 1, 0, 361_389_529);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer26, 'uint32', 2_320, 2_336);
} catch {}
try {
device0.queue.submit([commandBuffer16]);
} catch {}
try {
globalThis.someLabel = externalTexture20.label;
} catch {}
let commandEncoder195 = device0.createCommandEncoder({});
let texture181 = device0.createTexture({
  size: {width: 120, height: 48, depthOrArrayLayers: 1},
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
{ clearResourceUsages(device0, computePassEncoder89); computePassEncoder89.dispatchWorkgroupsIndirect(buffer121, 552); };
} catch {}
try {
renderPassEncoder47.setBindGroup(3, bindGroup70);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(5, buffer77, 264, 1_957);
} catch {}
try {
renderBundleEncoder22.setBindGroup(3, bindGroup8, new Uint32Array(3037), 16, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer132 = device0.createBuffer({size: 2929, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let computePassEncoder172 = commandEncoder195.beginComputePass({});
let sampler127 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 47.78});
try {
{ clearResourceUsages(device0, computePassEncoder45); computePassEncoder45.dispatchWorkgroupsIndirect(buffer121, 232); };
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup69);
} catch {}
try {
renderPassEncoder27.setBindGroup(0, bindGroup56, new Uint32Array(159), 32, 0);
} catch {}
try {
renderPassEncoder12.drawIndexedIndirect(buffer57, 6_840);
} catch {}
try {
renderPassEncoder12.drawIndirect(buffer17, 332);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer101, 'uint16', 346, 439);
} catch {}
try {
renderPassEncoder48.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(1, buffer79, 72, 42);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 48, depthOrArrayLayers: 1}
*/
{
  source: img3,
  origin: { x: 4, y: 1 },
  flipY: false,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 7, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext7 = offscreenCanvas1.getContext('webgpu');
let autogeneratedBindGroupLayout29 = pipeline32.getBindGroupLayout(0);
let buffer133 = device0.createBuffer({
  size: 22297,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder196 = device0.createCommandEncoder({});
let querySet24 = device0.createQuerySet({type: 'occlusion', count: 710});
let computePassEncoder173 = commandEncoder196.beginComputePass({});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true});
try {
renderPassEncoder49.setBindGroup(2, bindGroup88);
} catch {}
try {
renderPassEncoder33.setBindGroup(1, bindGroup35, new Uint32Array(351), 59, 0);
} catch {}
try {
renderPassEncoder12.end();
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline9);
} catch {}
try {
commandEncoder48.copyBufferToBuffer(buffer46, 336, buffer1, 672, 616);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer82, 580, new Int16Array(899), 26, 4);
} catch {}
let imageBitmap4 = await createImageBitmap(videoFrame7);
let autogeneratedBindGroupLayout30 = pipeline9.getBindGroupLayout(0);
let commandEncoder197 = device0.createCommandEncoder({});
let computePassEncoder174 = commandEncoder48.beginComputePass();
let renderPassEncoder53 = commandEncoder197.beginRenderPass({
  colorAttachments: [{
  view: textureView131,
  depthSlice: 13,
  clearValue: { r: 27.32, g: 850.6, b: 831.7, a: -358.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet8,
  maxDrawCount: 154073768,
});
try {
computePassEncoder172.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer5, 'uint32', 116, 13);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline31);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 49, depthOrArrayLayers: 1}
*/
{
  source: imageData14,
  origin: { x: 4, y: 6 },
  flipY: false,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 16, depthOrArrayLayers: 0});
} catch {}
let imageData15 = new ImageData(68, 4);
let videoFrame24 = new VideoFrame(offscreenCanvas0, {timestamp: 0});
let recycledExplicitBindGroupLayout43 = pipeline14.getBindGroupLayout(0);
let buffer134 = device0.createBuffer({
  size: 2718,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let renderBundle21 = renderBundleEncoder22.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder106); computePassEncoder106.dispatchWorkgroupsIndirect(buffer12, 768); };
} catch {}
try {
computePassEncoder173.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder31.setBindGroup(2, bindGroup52);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder50.setVertexBuffer(7, buffer49);
} catch {}
let promise29 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4'}});
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt2020', transfer: 'pq'} });
let bindGroup96 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout19,
  entries: [
    {binding: 263, resource: {buffer: buffer88, offset: 0, size: 84}},
    {binding: 48, resource: {buffer: buffer98, offset: 1024, size: 2256}},
  ],
});
let texture182 = device0.createTexture({size: [15, 10, 26], format: 'rgba16uint', usage: GPUTextureUsage.STORAGE_BINDING, viewFormats: []});
let textureView174 = texture173.createView({mipLevelCount: 1, baseArrayLayer: 17, arrayLayerCount: 3});
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer5, 268); };
} catch {}
try {
computePassEncoder174.setPipeline(pipeline32);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer16, 'uint32', 2_644, 3_295);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(1, buffer122, 1_276, 459);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 432, new DataView(new ArrayBuffer(3015)), 352, 1208);
} catch {}
let autogeneratedBindGroupLayout31 = pipeline27.getBindGroupLayout(0);
let commandEncoder198 = device0.createCommandEncoder({});
let querySet25 = device0.createQuerySet({type: 'occlusion', count: 6});
let texture183 = gpuCanvasContext7.getCurrentTexture();
let computePassEncoder175 = commandEncoder198.beginComputePass({});
let externalTexture28 = device0.importExternalTexture({source: videoFrame10});
try {
computePassEncoder29.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder167.setBindGroup(0, bindGroup73, new Uint32Array(874), 12, 0);
} catch {}
try {
computePassEncoder175.setPipeline(pipeline29);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup24, new Uint32Array(1996), 753, 0);
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer109, 'uint32', 180, 251);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(4, buffer79, 0);
} catch {}
try {
renderBundleEncoder23.setBindGroup(0, bindGroup20);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(3, buffer88, 0, 26);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
let pipeline35 = device0.createRenderPipeline({
  label: '\u{1f7af}\u0c31\ue3ae\u0232\u8394',
  layout: 'auto',
  multisample: {mask: 0x7404f508},
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment6',
  constants: {17_112: 0, override2: 0},
  targets: [{format: 'rgba16float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule9,
    buffers: [
      {
        arrayStride: 148,
        stepMode: 'instance',
        attributes: [{format: 'float32x3', offset: 36, shaderLocation: 13}],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', cullMode: 'front'},
});
document.body.append(img3);
let commandEncoder199 = device0.createCommandEncoder();
let texture184 = gpuCanvasContext5.getCurrentTexture();
let computePassEncoder176 = commandEncoder199.beginComputePass({});
try {
computePassEncoder130.setBindGroup(0, bindGroup94);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup68, new Uint32Array(211), 3, 0);
} catch {}
try {
renderPassEncoder40.setScissorRect(63, 0, 104, 0);
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup28, new Uint32Array(648), 50, 0);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(7, buffer17);
} catch {}
try {
buffer46.unmap();
} catch {}
let autogeneratedBindGroupLayout32 = pipeline11.getBindGroupLayout(0);
let textureView175 = texture63.createView({baseArrayLayer: 0});
try {
computePassEncoder99.setBindGroup(0, bindGroup82, new Uint32Array(920), 44, 0);
} catch {}
try {
renderPassEncoder42.executeBundles([renderBundle7, renderBundle13, renderBundle7]);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer13, 'uint32', 1_592, 162);
} catch {}
let buffer135 = device0.createBuffer({size: 8480, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let texture185 = device0.createTexture({
  size: {width: 7, height: 5, depthOrArrayLayers: 71},
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC,
});
let renderBundle22 = renderBundleEncoder21.finish();
try {
computePassEncoder176.setPipeline(pipeline32);
} catch {}
try {
renderPassEncoder24.setBindGroup(1, bindGroup81);
} catch {}
try {
renderPassEncoder50.setBindGroup(2, bindGroup21, new Uint32Array(753), 14, 0);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer122, 'uint16', 148, 696);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(5, buffer16, 0, 4_389);
} catch {}
try {
renderBundleEncoder23.setBindGroup(2, bindGroup34, new Uint32Array(227), 17, 0);
} catch {}
let bindGroup97 = device0.createBindGroup({layout: autogeneratedBindGroupLayout15, entries: [{binding: 235, resource: textureView103}]});
let commandEncoder200 = device0.createCommandEncoder({label: '\u{1fe6b}\u5392\u0608\u7117\u1e18'});
let computePassEncoder177 = commandEncoder200.beginComputePass({});
let sampler128 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 14,
});
try {
computePassEncoder163.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder50.setBindGroup(2, bindGroup43);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer105, 'uint16', 46, 19);
} catch {}
try {
renderBundleEncoder23.setBindGroup(1, bindGroup67);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(3, buffer44, 252, 829);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 3, height: 99, depthOrArrayLayers: 1}
*/
{
  source: imageData8,
  origin: { x: 0, y: 2 },
  flipY: false,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 29, depthOrArrayLayers: 0});
} catch {}
let textureView176 = texture152.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1});
let renderBundle23 = renderBundleEncoder23.finish({});
try {
computePassEncoder177.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer125);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture145,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(21).fill(232), /* required buffer size: 21 */
{offset: 21, bytesPerRow: 30, rowsPerImage: 55}, {width: 1, height: 49, depthOrArrayLayers: 0});
} catch {}
let pipeline36 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment2',
  constants: {},
  targets: [{
  format: 'rg8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule9,
    buffers: [
      {
        arrayStride: 208,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 20, shaderLocation: 13}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let canvas6 = document.createElement('canvas');
let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt709', transfer: 'smpteSt4281'} });
try {
computePassEncoder111.setBindGroup(0, bindGroup31);
} catch {}
try {
renderPassEncoder53.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer12, 'uint16', 1_766, 688);
} catch {}
try {
renderPassEncoder35.setPipeline(pipeline33);
} catch {}
let canvas7 = document.createElement('canvas');
let sampler129 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.50,
});
try {
computePassEncoder90.setBindGroup(0, bindGroup56);
} catch {}
let gpuCanvasContext8 = canvas6.getContext('webgpu');
let img5 = await imageWithData(97, 4, '#10101010', '#20202020');
try {
canvas7.getContext('webgpu');
} catch {}
let querySet26 = device0.createQuerySet({type: 'occlusion', count: 609});
let textureView177 = texture13.createView({baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder121.setBindGroup(0, bindGroup28, new Uint32Array(140), 1, 0);
} catch {}
try {
renderPassEncoder36.setViewport(2.323123118143268, 42.52500989731653, 0.1789983184146901, 13.298466764253327, 0.7905119120575942, 0.9570113889909783);
} catch {}
let bindGroup98 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout13,
  entries: [
    {binding: 48, resource: {buffer: buffer62, offset: 0}},
    {binding: 263, resource: {buffer: buffer4, offset: 0, size: 1460}},
  ],
});
let commandEncoder201 = device0.createCommandEncoder();
let textureView178 = texture99.createView({mipLevelCount: 1});
let texture186 = device0.createTexture({
  size: [30, 20, 1],
  mipLevelCount: 2,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 20, depthOrArrayLayers: 286}
*/
{
  source: videoFrame18,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 4, y: 1, z: 205},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline37 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout3,
  fragment: {module: shaderModule3, constants: {}, targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALPHA}]},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 104,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 36, shaderLocation: 2},
          {format: 'sint16x4', offset: 8, shaderLocation: 5},
          {format: 'float32x2', offset: 0, shaderLocation: 7},
          {format: 'sint32x4', offset: 0, shaderLocation: 15},
          {format: 'uint8x4', offset: 16, shaderLocation: 4},
          {format: 'uint32x2', offset: 16, shaderLocation: 11},
          {format: 'sint16x4', offset: 56, shaderLocation: 8},
          {format: 'snorm8x4', offset: 0, shaderLocation: 10},
          {format: 'uint8x4', offset: 8, shaderLocation: 0},
          {format: 'unorm16x2', offset: 64, shaderLocation: 12},
          {format: 'snorm8x4', offset: 12, shaderLocation: 3},
          {format: 'sint32x3', offset: 0, shaderLocation: 9},
          {format: 'uint16x4', offset: 0, shaderLocation: 1},
          {format: 'unorm16x2', offset: 8, shaderLocation: 6},
          {format: 'snorm16x4', offset: 32, shaderLocation: 13},
          {format: 'sint8x4', offset: 32, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'ccw', unclippedDepth: true},
});
let commandEncoder202 = device0.createCommandEncoder();
let computePassEncoder178 = commandEncoder201.beginComputePass({});
let renderPassEncoder54 = commandEncoder202.beginRenderPass({colorAttachments: [{view: textureView163, depthSlice: 25, loadOp: 'load', storeOp: 'discard'}]});
let sampler130 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 68.77, maxAnisotropy: 9});
try {
computePassEncoder17.setBindGroup(0, bindGroup33, new Uint32Array(325), 4, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder88); computePassEncoder88.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder47.setBindGroup(2, bindGroup97, new Uint32Array(1277), 232, 0);
} catch {}
try {
renderPassEncoder37.end();
} catch {}
try {
renderPassEncoder48.setVertexBuffer(0, buffer44, 808);
} catch {}
try {
  await shaderModule7.getCompilationInfo();
} catch {}
try {
buffer60.unmap();
} catch {}
try {
commandEncoder18.copyTextureToTexture({
  texture: texture136,
  mipLevel: 0,
  origin: {x: 117, y: 0, z: 44},
  aspect: 'all',
},
{
  texture: texture112,
  mipLevel: 0,
  origin: {x: 6, y: 11, z: 0},
  aspect: 'all',
},
{width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let textureView179 = texture76.createView({dimension: '2d-array'});
let computePassEncoder179 = commandEncoder18.beginComputePass();
try {
renderPassEncoder32.setBindGroup(2, bindGroup5, new Uint32Array(760), 196, 0);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(7, buffer123, 2_380, 329);
} catch {}
try {
device0.queue.writeBuffer(buffer85, 7132, new Float32Array(12263), 2093, 248);
} catch {}
document.body.prepend(canvas6);
let buffer136 = device0.createBuffer({
  size: 1569,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder203 = device0.createCommandEncoder({});
let computePassEncoder180 = commandEncoder203.beginComputePass();
try {
computePassEncoder180.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(230);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle0, renderBundle1, renderBundle16, renderBundle0, renderBundle0]);
} catch {}
try {
device0.queue.writeBuffer(buffer133, 10380, new BigUint64Array(11297), 7195, 620);
} catch {}
let commandEncoder204 = device0.createCommandEncoder({});
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderPassEncoder36.setIndexBuffer(buffer82, 'uint16', 130, 34);
} catch {}
try {
renderPassEncoder47.setVertexBuffer(5, buffer106);
} catch {}
try {
commandEncoder204.copyBufferToTexture({
  /* bytesInLastRow: 118 widthInBlocks: 59 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 544 */
  offset: 544,
  bytesPerRow: 5376,
  buffer: buffer83,
}, {
  texture: texture2,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 1},
  aspect: 'all',
}, {width: 59, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'display-p3',
});
} catch {}
try {
adapter0.label = '\u0f83\ube02\u1f97\u0bfb\u9c4d\ue3ba\u{1f851}';
} catch {}
let autogeneratedBindGroupLayout33 = pipeline27.getBindGroupLayout(0);
let bindGroup99 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [{binding: 167, resource: textureView97}, {binding: 235, resource: textureView129}],
});
let buffer137 = device0.createBuffer({
  size: 3849,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder205 = device0.createCommandEncoder({});
let querySet27 = device0.createQuerySet({label: '\u9d16\u{1fd56}\u986e\u{1f694}', type: 'occlusion', count: 1750});
let texture187 = gpuCanvasContext5.getCurrentTexture();
let computePassEncoder181 = commandEncoder205.beginComputePass({});
let sampler131 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'always',
});
try {
computePassEncoder115.setBindGroup(3, bindGroup27, new Uint32Array(722), 167, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder45.end();
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer42, 'uint32', 280, 398);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(3, buffer71, 2_840);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
document.body.append(img4);
try {
globalThis.someLabel = commandEncoder47.label;
} catch {}
let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 50,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'float', multisampled: false },
    },
  ],
});
let texture188 = device0.createTexture({
  size: {width: 7, height: 5, depthOrArrayLayers: 68},
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView180 = texture117.createView({});
let computePassEncoder182 = commandEncoder56.beginComputePass({});
let sampler132 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 99.16});
try {
computePassEncoder126.setBindGroup(0, bindGroup48);
} catch {}
try {
computePassEncoder76.end();
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup41, new Uint32Array(390), 133, 0);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer8, 'uint32', 68, 494);
} catch {}
try {
commandEncoder204.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7264 */
  offset: 7264,
  bytesPerRow: 2048,
  buffer: buffer60,
}, {
  texture: texture181,
  mipLevel: 0,
  origin: {x: 27, y: 21, z: 0},
  aspect: 'all',
}, {width: 6, height: 7, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout44 = pipeline37.getBindGroupLayout(0);
let bindGroup100 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 56, resource: textureView0},
    {binding: 227, resource: {buffer: buffer66, offset: 2048, size: 1956}},
  ],
});
let texture189 = device0.createTexture({
  size: [120],
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder183 = commandEncoder204.beginComputePass({});
let renderPassEncoder55 = commandEncoder91.beginRenderPass({
  colorAttachments: [{
  view: textureView18,
  clearValue: { r: 447.2, g: 746.3, b: -727.6, a: 231.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet23,
});
try {
computePassEncoder127.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder49.setBindGroup(0, bindGroup82);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup59, new Uint32Array(2582), 39, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
document.body.prepend(canvas1);
let textureView181 = texture117.createView({arrayLayerCount: 1});
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: false});
let sampler133 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 96.48});
try {
computePassEncoder148.setBindGroup(0, bindGroup12);
} catch {}
try {
computePassEncoder182.setPipeline(pipeline32);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle16]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer95, 0, 706);
} catch {}
try {
if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); };
} catch {}
let canvas8 = document.createElement('canvas');
let videoFrame27 = new VideoFrame(imageBitmap0, {timestamp: 0});
let texture190 = device0.createTexture({
  size: {width: 30, height: 12, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder47.setBindGroup(3, bindGroup34);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer90, 'uint16', 1_474, 69);
} catch {}
try {
renderPassEncoder55.setVertexBuffer(2, undefined, 0, 861_983_014);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline30);
} catch {}
let arrayBuffer26 = buffer0.getMappedRange(168, 0);
await gc();
let bindGroup101 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout28,
  entries: [
    {binding: 263, resource: {buffer: buffer50, offset: 2048, size: 648}},
    {binding: 48, resource: {buffer: buffer82, offset: 512, size: 4236}},
    {binding: 235, resource: textureView150},
  ],
});
let commandEncoder206 = device0.createCommandEncoder({});
let renderPassEncoder56 = commandEncoder206.beginRenderPass({
  colorAttachments: [{
  view: textureView163,
  depthSlice: 2,
  clearValue: { r: 594.6, g: 680.4, b: 447.1, a: 154.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 35504805,
});
try {
renderPassEncoder2.executeBundles([renderBundle15]);
} catch {}
try {
renderBundleEncoder24.setBindGroup(1, bindGroup76);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline35);
} catch {}
try {
  await promise28;
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder207 = device0.createCommandEncoder();
let textureView182 = texture163.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 20, arrayLayerCount: 13});
let renderPassEncoder57 = commandEncoder207.beginRenderPass({
  colorAttachments: [{
  view: textureView163,
  depthSlice: 16,
  clearValue: { r: 949.2, g: -463.8, b: -485.6, a: 545.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 44984269,
});
try {
renderPassEncoder31.executeBundles([renderBundle5]);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer57, 'uint32', 2_836, 4_611);
} catch {}
let bindGroup102 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout18,
  entries: [
    {binding: 48, resource: {buffer: buffer50, offset: 1024}},
    {binding: 263, resource: {buffer: buffer105, offset: 0, size: 96}},
  ],
});
let commandEncoder208 = device0.createCommandEncoder({});
let computePassEncoder184 = commandEncoder208.beginComputePass({});
try {
computePassEncoder164.setBindGroup(3, bindGroup9);
} catch {}
try {
computePassEncoder181.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder42.executeBundles([renderBundle16, renderBundle23]);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer34, 'uint16', 218, 871);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline28);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext8.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC});
} catch {}
let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470m', transfer: 'bt2020_10bit'} });
let commandEncoder209 = device0.createCommandEncoder({});
let textureView183 = texture68.createView({dimension: '1d'});
let computePassEncoder185 = commandEncoder209.beginComputePass({});
let sampler134 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 93.74});
try {
computePassEncoder144.setBindGroup(3, bindGroup100, new Uint32Array(1398), 849, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder101); computePassEncoder101.dispatchWorkgroupsIndirect(buffer49, 92); };
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(4, buffer49, 4, 5);
} catch {}
try {
renderBundleEncoder24.insertDebugMarker('\u259f');
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let shaderModule12 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

enable f16;

diagnostic(info, xyz);

requires unrestricted_pointer_parameters;

struct FragmentOutput7 {
  @location(4) f0: i32,
  @location(0) f1: vec2i,
}

var<private> vp12: f32 = f32(0.2783);

struct VertexOutput11 {
  @location(15) @interpolate(flat, sample) f27: vec2u,
  @location(3) @interpolate(flat, sample) f28: f16,
  @invariant @builtin(position) f29: vec4f,
}

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

var<private> vp13 = array(modf(f16(405.7)));

@group(0) @binding(48) var<storage, read_write> buffer138: array<array<array<f32, 11>, 4>>;

fn fn0() -> f32 {
  var out: f32;
  let ptr124: ptr<storage, f32, read_write> = &buffer138[arrayLength(&buffer138)][3][u32(unconst_u32(29))];
  let ptr125: ptr<storage, array<array<f32, 11>, 4>, read_write> = &buffer138[u32(unconst_u32(192))];
  var vf135: f16 = determinant(mat4x4h());
  let ptr126: ptr<storage, f32, read_write> = &(*ptr125)[u32(unconst_u32(38))][10];
  let ptr127: ptr<storage, f32, read_write> = &buffer138[u32(unconst_u32(109))][3][10];
  return out;
  _ = buffer138;
}

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

alias vec3b = vec3<bool>;

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

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

struct T0 {
  f0: array<u32>,
}

var<private> vp14: FragmentOutput7 = FragmentOutput7(i32(34), vec2i(200, 250));

@group(0) @binding(263) var<storage, read> buffer139: u32;

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

@vertex
fn vertex11() -> VertexOutput11 {
  var out: VertexOutput11;
  let ptr128 = &vp13[u32(vp13[u32(unconst_u32(77))].fract)];
  out.f29 = vec4f(f32(vp13[u32(unconst_u32(73))].fract));
  let ptr129: ptr<storage, u32, read> = &(*&buffer139);
  out.f28 *= vp13[u32(unconst_u32(14))].whole;
  out.f27 |= bitcast<vec2u>(vp14.f1);
  let ptr130: ptr<private, f16> = &(*ptr128).whole;
  let ptr131: ptr<private, f16> = &vp13[bitcast<u32>(vp14.f1[u32(unconst_u32(23))])].whole;
  let ptr132 = &vp13[u32(unconst_u32(59))];
  let ptr133: ptr<private, f16> = &(*ptr130);
  let ptr134: ptr<private, vec2i> = &vp14.f1;
  vp12 *= f32(vp13[u32(unconst_u32(93))].fract);
  out.f27 *= vec2u(u32((*ptr128).whole));
  let ptr135: ptr<private, vec2i> = &vp14.f1;
  return out;
  _ = buffer139;
}

@fragment
fn fragment7(@builtin(sample_index) a0: u32, @location(3) @interpolate(perspective, center) a1: f16) -> FragmentOutput7 {
  var out: FragmentOutput7;
  out.f1 ^= vec2i(bitcast<i32>(buffer138[i32(unconst_i32(97))][3][10]));
  let ptr136: ptr<private, f16> = &vp13[bitcast<u32>((*&buffer138)[u32(unconst_u32(163))][u32(unconst_u32(58))][10])].whole;
  let ptr137: ptr<private, vec2i> = &vp14.f1;
  vp13[u32(unconst_u32(53))].fract *= f16((*&buffer138)[u32(unconst_u32(42))][bitcast<u32>((*&buffer138)[u32(unconst_u32(9))][u32(unconst_u32(5))][u32(unconst_u32(674))])][10]);
  buffer138[u32(unconst_u32(340))][u32(unconst_u32(308))][u32(unconst_u32(9))] = bitcast<f32>((*&buffer139));
  vp12 = (*&buffer138)[arrayLength(&(*&buffer138))][3][10];
  out.f1 &= vec2i(bitcast<i32>((*&buffer138)[u32(unconst_u32(26))][3][10]));
  out = FragmentOutput7((*ptr137)[u32(unconst_u32(103))], vec2i((*ptr137)[u32(unconst_u32(103))]));
  let ptr138: ptr<storage, array<f32, 11>, read_write> = &(*&buffer138)[arrayLength(&(*&buffer138))][3];
  buffer138[u32(unconst_u32(149))][u32(unconst_u32(3))][u32(unconst_u32(94))] *= vec4f(asin(vec4h(unconst_f16(25015.5), unconst_f16(823.7), unconst_f16(5394.0), unconst_f16(8339.9)))).x;
  let ptr139 = &vp13[0];
  let ptr140: ptr<storage, f32, read_write> = &buffer138[u32(unconst_u32(44))][3][10];
  let ptr141: ptr<storage, f32, read_write> = &buffer138[bitcast<u32>(buffer138[arrayLength(&buffer138)][u32(unconst_u32(149))][10])][3][u32(unconst_u32(14))];
  let ptr142: ptr<storage, f32, read_write> = &buffer138[arrayLength(&buffer138)][u32(buffer138[u32((*&buffer138)[u32(unconst_u32(121))][u32(unconst_u32(424))][10])][3][u32(unconst_u32(165))])][u32(unconst_u32(66))];
  return out;
  _ = buffer139;
  _ = buffer138;
}

@compute @workgroup_size(1, 1, 1)
fn compute16(@builtin(num_workgroups) a0: vec3u) {
  vp14 = FragmentOutput7(vp14.f1[u32(unconst_u32(72))], vec2i(vp14.f1[u32(unconst_u32(72))]));
  fn0();
  var vf136: vec3h = asinh(vec3h(unconst_f16(8233.3), unconst_f16(4323.1), unconst_f16(19343.6)));
  buffer138[u32(unconst_u32(158))][u32(unconst_u32(86))][u32(unconst_u32(140))] -= buffer138[arrayLength(&buffer138)][3][10];
  var vf137 = fn0();
  let ptr143: ptr<storage, array<array<f32, 11>, 4>, read_write> = &buffer138[i32(unconst_i32(63))];
  var vf138 = fn0();
  let ptr144: ptr<storage, array<f32, 11>, read_write> = &(*&buffer138)[arrayLength(&(*&buffer138))][u32(unconst_u32(133))];
  fn0();
  vp12 = f32(vp14.f0);
  vf137 *= buffer138[u32(unconst_u32(137))][u32(unconst_u32(112))][10];
  _ = buffer138;
}`,
});
let commandEncoder210 = device0.createCommandEncoder();
let textureView184 = texture28.createView({dimension: '2d-array', mipLevelCount: 2});
let renderPassEncoder58 = commandEncoder210.beginRenderPass({
  colorAttachments: [{view: textureView67, depthSlice: 0, loadOp: 'load', storeOp: 'store'}],
  maxDrawCount: 421723935,
});
try {
computePassEncoder152.setBindGroup(1, bindGroup57);
} catch {}
try {
renderBundleEncoder25.setBindGroup(0, bindGroup52, new Uint32Array(1052), 59, 0);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(5, buffer101, 1_044);
} catch {}
document.body.append(canvas2);
let autogeneratedBindGroupLayout34 = pipeline16.getBindGroupLayout(0);
let renderBundle24 = renderBundleEncoder24.finish({});
try {
computePassEncoder21.setBindGroup(0, bindGroup28, new Uint32Array(541), 44, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder184.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setViewport(36.603050869166374, 0.9725004844937891, 77.46388548422584, 0.015745480830833266, 0.07046997150958434, 0.5038058397637845);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup15, new Uint32Array(1503), 205, 0);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer127, 'uint16', 756, 266);
} catch {}
let promise30 = device0.queue.onSubmittedWorkDone();
try {
computePassEncoder176.setBindGroup(1, bindGroup22);
} catch {}
try {
computePassEncoder183.setPipeline(pipeline29);
} catch {}
try {
renderPassEncoder49.setBindGroup(3, bindGroup19, []);
} catch {}
try {
renderPassEncoder41.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder55.setVertexBuffer(3, buffer101, 388);
} catch {}
try {
renderBundleEncoder25.setBindGroup(2, bindGroup21);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer89, 'uint32', 16, 530);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(5, buffer40);
} catch {}
let pipeline38 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 1, mask: 0x15ef7cd},
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment5',
  targets: [{
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'src-alpha'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
}],
},
  depthStencil: {
    format: 'depth16unorm',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilReadMask: 572145252,
    stencilWriteMask: 2487460437,
    depthBias: -1998426989,
    depthBiasSlopeScale: 502.6673738419173,
    depthBiasClamp: 375.81159838633295,
  },
  vertex: {
    module: shaderModule6,
    constants: {},
    buffers: [{arrayStride: 60, attributes: [{format: 'sint32', offset: 0, shaderLocation: 7}]}],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let gpuCanvasContext9 = canvas8.getContext('webgpu');
let texture191 = device0.createTexture({
  size: [12, 396, 1],
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView185 = texture139.createView({arrayLayerCount: 1});
let renderBundle25 = renderBundleEncoder25.finish({});
try {
computePassEncoder134.setBindGroup(0, bindGroup77, []);
} catch {}
try {
computePassEncoder50.setBindGroup(0, bindGroup32, new Uint32Array(3092), 86, 0);
} catch {}
try {
computePassEncoder179.setPipeline(pipeline32);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer123, 'uint16', 1_654, 656);
} catch {}
try {
device0.queue.submit([]);
} catch {}
document.body.prepend(canvas1);
let img6 = await imageWithData(10, 81, '#10101010', '#20202020');
let commandEncoder211 = device0.createCommandEncoder();
let texture192 = device0.createTexture({
  size: [30],
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm'],
});
let renderPassEncoder59 = commandEncoder211.beginRenderPass({
  colorAttachments: [{view: textureView163, depthSlice: 34, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 151744753,
});
let sampler135 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 92.51});
try {
renderPassEncoder57.setPipeline(pipeline35);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 4792, new Int16Array(4040), 77, 16);
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); };
} catch {}
let bindGroup103 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout26,
  entries: [
    {binding: 48, resource: {buffer: buffer114, offset: 256, size: 936}},
    {binding: 235, resource: textureView150},
    {binding: 263, resource: {buffer: buffer24, offset: 1280, size: 8564}},
  ],
});
let textureView186 = texture150.createView({dimension: '3d', baseMipLevel: 0});
try {
renderPassEncoder31.setBindGroup(0, bindGroup79);
} catch {}
try {
renderPassEncoder52.setIndexBuffer(buffer122, 'uint32', 1_520, 561);
} catch {}
let buffer140 = device0.createBuffer({size: 18420, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder212 = device0.createCommandEncoder({});
try {
computePassEncoder14.setBindGroup(3, bindGroup52, new Uint32Array(93), 8, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder95); computePassEncoder95.dispatchWorkgroupsIndirect(buffer68, 36); };
} catch {}
try {
computePassEncoder185.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder39.beginOcclusionQuery(2);
} catch {}
try {
renderPassEncoder39.endOcclusionQuery();
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder53.setPipeline(pipeline31);
} catch {}
try {
renderPassEncoder47.setVertexBuffer(2, buffer89, 304, 801);
} catch {}
try {
commandEncoder212.copyBufferToBuffer(buffer51, 744, buffer30, 5912, 32);
} catch {}
try {
computePassEncoder117.pushDebugGroup('\ue962');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
try {
globalThis.someLabel = computePassEncoder32.label;
} catch {}
let autogeneratedBindGroupLayout35 = pipeline34.getBindGroupLayout(1);
let buffer141 = device0.createBuffer({size: 6551, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder213 = device0.createCommandEncoder();
let texture193 = device0.createTexture({size: [30, 12, 49], mipLevelCount: 1, format: 'rg8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView187 = texture14.createView({dimension: '2d', baseArrayLayer: 5});
let computePassEncoder186 = commandEncoder213.beginComputePass({});
try {
computePassEncoder178.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup77);
} catch {}
try {
commandEncoder212.copyTextureToBuffer({
  texture: texture172,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1248 */
  offset: 1248,
  bytesPerRow: 5376,
  buffer: buffer127,
}, {width: 15, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder47.insertDebugMarker('\u075a');
} catch {}
try {
computePassEncoder43.setBindGroup(0, bindGroup52, new Uint32Array(1187), 227, 0);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer82, 'uint32', 220, 5_914);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(1, buffer4, 0, 2_093);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let pipeline39 = device0.createRenderPipeline({
  layout: pipelineLayout8,
  fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rg8sint', writeMask: GPUColorWrite.BLUE}]},
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex1',
    buffers: [
      {
        arrayStride: 120,
        attributes: [
          {format: 'sint32x4', offset: 4, shaderLocation: 13},
          {format: 'uint32x2', offset: 32, shaderLocation: 12},
          {format: 'snorm16x2', offset: 16, shaderLocation: 1},
          {format: 'uint32x3', offset: 0, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 420,
        stepMode: 'instance',
        attributes: [{format: 'sint32x2', offset: 76, shaderLocation: 7}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
await gc();
let recycledExplicitBindGroupLayout45 = pipeline8.getBindGroupLayout(0);
let buffer142 = device0.createBuffer({
  size: 1795,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder214 = device0.createCommandEncoder({});
let texture194 = device0.createTexture({
  size: {width: 1460, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder60 = commandEncoder212.beginRenderPass({colorAttachments: [{view: textureView163, depthSlice: 30, loadOp: 'load', storeOp: 'store'}]});
try {
computePassEncoder136.setBindGroup(1, bindGroup83);
} catch {}
try {
computePassEncoder167.setBindGroup(0, bindGroup76, new Uint32Array(3621), 151, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder118); computePassEncoder118.dispatchWorkgroupsIndirect(buffer1, 1_104); };
} catch {}
try {
computePassEncoder186.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder55.beginOcclusionQuery(0);
} catch {}
try {
commandEncoder214.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 724 */
  offset: 724,
  bytesPerRow: 28416,
  buffer: buffer126,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {width: 15, height: 10, depthOrArrayLayers: 0});
} catch {}
let promise31 = device0.queue.onSubmittedWorkDone();
let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte170m', transfer: 'smpteSt4281'} });
let renderPassEncoder61 = commandEncoder214.beginRenderPass({
  colorAttachments: [{
  view: textureView163,
  depthSlice: 22,
  clearValue: { r: 13.75, g: 838.9, b: 47.87, a: 429.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler136 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 97.77, compare: 'less-equal'});
try {
computePassEncoder137.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder52.setIndexBuffer(buffer127, 'uint32', 436, 912);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(2, buffer129, 236);
} catch {}
try {
buffer113.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 20, depthOrArrayLayers: 286}
*/
{
  source: videoFrame10,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 4, y: 4, z: 35},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img2);
await gc();
let buffer143 = device0.createBuffer({
  size: 4990,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder215 = device0.createCommandEncoder({});
let texture195 = device0.createTexture({
  size: [30, 20, 286],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder187 = commandEncoder215.beginComputePass();
try {
computePassEncoder187.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder55.endOcclusionQuery();
} catch {}
try {
renderPassEncoder35.executeBundles([renderBundle0, renderBundle20]);
} catch {}
try {
renderPassEncoder44.setPipeline(pipeline33);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(1, buffer112, 368);
} catch {}
try {
computePassEncoder117.popDebugGroup();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let textureView188 = texture195.createView({dimension: '3d'});
let textureView189 = texture86.createView({
  aspect: 'depth-only',
  format: 'depth16unorm',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 1,
  arrayLayerCount: 1,
});
let arrayBuffer27 = buffer72.getMappedRange(736, 88);
let pipeline40 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment4',
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {module: shaderModule4, entryPoint: 'vertex5', constants: {}, buffers: []},
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
let texture196 = device0.createTexture({
  size: {width: 6, height: 198, depthOrArrayLayers: 605},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder90.setBindGroup(3, bindGroup36);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder128); computePassEncoder128.dispatchWorkgroupsIndirect(buffer51, 656); };
} catch {}
try {
renderPassEncoder44.setIndexBuffer(buffer71, 'uint16', 64, 1_216);
} catch {}
try {
renderPassEncoder59.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder43.pushDebugGroup('\u08e8');
} catch {}
try {
computePassEncoder179.insertDebugMarker('\u9684');
} catch {}
try {
device0.queue.writeBuffer(buffer126, 192, new Int16Array(15808), 2981, 24);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
try {
  await promise31;
} catch {}
document.body.append(canvas7);
let canvas9 = document.createElement('canvas');
let bindGroup104 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout18,
  entries: [{binding: 39, resource: {buffer: buffer51, offset: 0, size: 464}}],
});
let textureView190 = texture16.createView({label: '\u0387\ua7a1\u41fe', mipLevelCount: 1});
let sampler137 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', minFilter: 'linear'});
try {
renderPassEncoder28.setBindGroup(0, bindGroup41);
} catch {}
try {
renderPassEncoder59.setIndexBuffer(buffer45, 'uint16', 80, 33);
} catch {}
try {
  await promise30;
} catch {}
let buffer144 = device0.createBuffer({size: 687, usage: GPUBufferUsage.COPY_SRC});
let textureView191 = texture2.createView({baseArrayLayer: 1, arrayLayerCount: 1});
try {
renderPassEncoder11.setPipeline(pipeline17);
} catch {}
let arrayBuffer28 = buffer0.getMappedRange(280, 12);
let shaderModule13 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

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

var<workgroup> vw43: atomic<i32>;

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

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

struct S3 {
  @location(8) @interpolate(flat, centroid) f0: vec2u,
}

@group(0) @binding(167) var tex20: texture_2d<f32>;

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

var<private> vp16 = modf(vec3f(0.01648, 0.06841, 0.3264));

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

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

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

fn fn0() -> S3 {
  var out: S3;
  vw44 = (*&vw44);
  let vf139: bool = any(vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false)));
  let vf140: vec2h = mix(vec2h(unconst_f16(40334.7), unconst_f16(175.7)), vec2h(unconst_f16(8558.6), unconst_f16(26686.4)), f16(unconst_f16(-25870.9)));
  var vf141: vec4i = unpack4xI8(u32(any(vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true)))));
  let ptr145: ptr<function, vec4i> = &vf141;
  let vf142: u32 = textureNumLevels(tex21);
  out.f0 <<= vec2u((*&vw44).f30.rb);
  out.f0 <<= vp15.f0;
  atomicAdd(&vw43, i32(unconst_i32(143)));
  out.f0 = bitcast<vec2u>(textureLoad(tex21, vec2i(unconst_i32(93), unconst_i32(260)), i32(unconst_i32(0))).ra);
  vf141 |= bitcast<vec4i>(textureLoad(tex20, vec2i(unconst_i32(93), unconst_i32(188)), i32(unconst_i32(399))));
  var vf143: i32 = atomicExchange(&(*&vw43), i32(unconst_i32(71)));
  let vf144: f16 = determinant(mat4x4h(unconst_f16(5806.3), unconst_f16(4476.3), unconst_f16(1631.7), unconst_f16(-7470.3), unconst_f16(975.7), unconst_f16(5187.3), unconst_f16(30336.8), unconst_f16(33394.3), unconst_f16(11990.2), unconst_f16(-16164.3), unconst_f16(608.4), unconst_f16(7965.4), unconst_f16(5478.3), unconst_f16(-903.0), unconst_f16(58226.7), unconst_f16(4490.9)));
  out.f0 = textureDimensions(tex20, bitcast<vec2i>(textureDimensions(tex20)).y);
  let vf145: vec4f = textureLoad(tex21, vec2i(unconst_i32(-139), unconst_i32(358)), i32(determinant(mat4x4h(unconst_f16(13204.5), unconst_f16(3755.3), unconst_f16(4117.8), unconst_f16(12553.2), unconst_f16(27300.4), unconst_f16(8465.6), unconst_f16(6831.4), unconst_f16(-9114.1), unconst_f16(213.2), unconst_f16(-4651.2), unconst_f16(6096.4), unconst_f16(1637.7), unconst_f16(4838.2), unconst_f16(169.5), unconst_f16(111.0), unconst_f16(47045.0)))));
  var vf146: vec4i = unpack4xI8(u32(unconst_u32(11)));
  atomicOr(&vw43, i32(unconst_i32(263)));
  return out;
  _ = tex21;
  _ = tex20;
}

var<workgroup> vw44: VertexOutput12;

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

@group(0) @binding(235) var tex21: texture_2d<f32>;

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

@vertex @must_use
fn vertex12(@location(12) @interpolate(linear) a0: f32, a1: S3, @location(10) @interpolate(perspective) a2: f32) -> VertexOutput12 {
  var out: VertexOutput12;
  var vf147: f16 = atan2(f16(unconst_f16(5783.6)), f16(unconst_f16(206.9)));
  let vf148: vec3f = cross(vec3f(unconst_f32(0.03877), unconst_f32(0.1379), unconst_f32(0.07636)), vec3f(unconst_f32(-0.1944), unconst_f32(0.2367), unconst_f32(0.00481)));
  out.f30 = textureLoad(tex21, vec2i(unconst_i32(37), unconst_i32(300)), i32(unconst_i32(47)));
  let ptr146: ptr<private, vec2u> = &vp15.f0;
  let vf149: u32 = pack4xU8(vec4u(unconst_u32(396), unconst_u32(51), unconst_u32(81), unconst_u32(102)));
  vp16 = modf(vec3f(f32(tanh(f16(unconst_f16(25827.6))))));
  out = VertexOutput12(vec4f(a2));
  vf147 *= vec3h(vf148)[2];
  return out;
  _ = tex21;
}

@compute @workgroup_size(2, 1, 1)
fn compute17() {
  fn0();
  vw44 = VertexOutput12(bitcast<vec4f>(textureDimensions(tex21).xyyx));
  var vf150 = fn0();
  fn0();
  let ptr147: ptr<workgroup, vec4f> = &vw44.f30;
  var vf151 = fn0();
  vp15.f0 = bitcast<vec2u>(radians(vec2f(unconst_f32(0.5284), unconst_f32(0.1366))));
  var vf152 = fn0();
  var vf153 = fn0();
  var vf154: f32 = (*ptr147)[u32(unconst_u32(96))];
  var vf155: vec3h = abs(vec3h(unconst_f16(2562.4), unconst_f16(18708.1), unconst_f16(9675.1)));
  _ = tex20;
  _ = tex21;
}`,
});
let recycledExplicitBindGroupLayout46 = pipeline37.getBindGroupLayout(0);
let bindGroup105 = device0.createBindGroup({
  label: '\u{1f661}\u0b9d\u281e\u068c\u{1fd93}\u032a',
  layout: autogeneratedBindGroupLayout7,
  entries: [
    {binding: 48, resource: {buffer: buffer119, offset: 0, size: 936}},
    {binding: 263, resource: {buffer: buffer123, offset: 0, size: 968}},
  ],
});
let buffer145 = device0.createBuffer({size: 2913, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder216 = device0.createCommandEncoder({});
let textureView192 = texture25.createView({dimension: '2d', baseArrayLayer: 3});
let computePassEncoder188 = commandEncoder216.beginComputePass({});
try {
computePassEncoder99.setBindGroup(2, bindGroup30);
} catch {}
try {
computePassEncoder26.setBindGroup(2, bindGroup88, new Uint32Array(2432), 97, 0);
} catch {}
try {
computePassEncoder188.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder42.setBindGroup(0, bindGroup63);
} catch {}
try {
renderPassEncoder43.setVertexBuffer(1, buffer125, 0);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
videoFrame0.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame6.close();
videoFrame7.close();
videoFrame9.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
videoFrame16.close();
videoFrame18.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame24.close();
videoFrame25.close();
videoFrame27.close();
videoFrame29.close();
}
async function window1() {
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {maxUniformBufferBindingSize: 23390350, maxStorageBufferBindingSize: 210020627},
});
let imageData0 = new ImageData(48, 24);
let sampler0 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'nearest'});
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let commandEncoder0 = device0.createCommandEncoder({label: '\u0485\u{1f6d6}\ubd2f\ue5b3\u0b6e\u11f1\uf151\u{1fcd1}\u{1f7e7}\u061b\u{1faec}'});
let computePassEncoder0 = commandEncoder0.beginComputePass({label: '\u0a14\u01f5\ueb84'});
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let commandEncoder1 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 146},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder1 = commandEncoder1.beginComputePass({});
let sampler1 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 96.96});
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let texture1 = device0.createTexture({
  size: [576, 1, 41],
  sampleCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let promise0 = device0.queue.onSubmittedWorkDone();
try {
  await promise0;
} catch {}
let texture2 = device0.createTexture({
  size: [128, 128, 24],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let canvas0 = document.createElement('canvas');
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let commandEncoder2 = device0.createCommandEncoder();
let textureView0 = texture1.createView({});
let texture3 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 90},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
canvas0.getContext('webgpu');
} catch {}
let bindGroup0 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 28, resource: textureView0}]});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 45});
let texture4 = device0.createTexture({
  size: {width: 72, height: 1, depthOrArrayLayers: 33},
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView1 = texture2.createView({});
let computePassEncoder2 = commandEncoder2.beginComputePass({});
try {
computePassEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(1051), 322, 0);
} catch {}
try {
computePassEncoder2.end();
} catch {}
let buffer0 = device0.createBuffer({size: 4947, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let texture5 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 26},
  mipLevelCount: 2,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture6 = device0.createTexture({
  size: [72, 1, 20],
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView2 = texture5.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 1});
let computePassEncoder3 = commandEncoder2.beginComputePass({});
try {
computePassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
try {
adapter0.label = '\u{1ff10}\u2d72\u07fc\u{1f943}\u{1fdd0}\u0e31\ua09a\uf644\u{1f6f0}';
} catch {}
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 79,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 125,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 127,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3]});
let commandEncoder3 = device0.createCommandEncoder({});
let textureView3 = texture6.createView({arrayLayerCount: 2});
let commandEncoder4 = device0.createCommandEncoder({});
let buffer1 = device0.createBuffer({size: 13094, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let computePassEncoder4 = commandEncoder3.beginComputePass({});
try {
computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(668), 47, 0);
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

requires unrestricted_pointer_parameters;

var<workgroup> vw4: mat3x2h;

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

var<workgroup> vw7: array<mat4x2h, 1>;

struct T2 {
  @size(48) f0: vec2i,
  @size(56) f1: mat2x2h,
}

struct FragmentOutput0 {
  @location(0) @interpolate(linear, sample) f0: vec4f,
  @builtin(sample_mask) f1: u32,
}

var<workgroup> vw9: f16;

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

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

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

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

@group(0) @binding(125) var tex0: texture_depth_2d;

var<workgroup> vw2: vec4i;

struct S1 {
  @location(0) @interpolate(flat, centroid) f0: vec2h,
  @location(6) @interpolate(linear) f1: vec2f,
}

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

var<workgroup> vw5: array<T2, 1>;

var<workgroup> vw1: vec4f;

struct T1 {
  @size(24) f0: vec2i,
}

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

var<workgroup> vw8: mat3x2h;

var<workgroup> vw6: atomic<u32>;

fn fn1() -> VertexOutput0 {
  var out: VertexOutput0;
  let ptr1: ptr<uniform, VertexOutput0> = &(*&buffer2)[u32(unconst_u32(119))];
  var vf5 = fn0();
  var vf6: vec3f = exp2(vec3f(fma(f32(unconst_f32(0.1242)), f32(unconst_f32(-0.01986)), f32(unconst_f32(0.1350)))));
  fn0();
  vf6 = vec3f(log(vec3h((*&buffer2)[0].f0.bra)));
  let ptr2: ptr<uniform, vec4f> = &(*ptr1).f0;
  let ptr3: ptr<uniform, vec4f> = &buffer2[0].f0;
  let ptr4: ptr<uniform, vec4f> = &buffer2[u32(unconst_u32(102))].f0;
  out = VertexOutput0(exp(bitcast<vec3f>(vf5[0].grr)).bbbr);
  let ptr5: ptr<uniform, array<VertexOutput0, 1>> = &(*&buffer2);
  out.f0 += vec4f(quantizeToF16(f32(unconst_f32(0.2052))));
  var vf7: f32 = buffer2[0].f0[u32(unconst_u32(26))];
  var vf8 = fn0();
  vf7 = buffer2[0].f0[2];
  vf7 = (*&buffer3).f0[2];
  fn0();
  vf5[u32(unconst_u32(144))] = vec2u(buffer2[u32(unconst_u32(105))].f0.ab);
  out.f0 = buffer2[0].f0;
  let ptr6: ptr<uniform, vec4f> = &(*ptr5)[0].f0;
  let ptr7: ptr<uniform, VertexOutput0> = &(*ptr1);
  out = VertexOutput0((*&buffer2)[0].f0);
  out = VertexOutput0((*&buffer2)[u32(unconst_u32(25))].f0);
  let ptr8: ptr<uniform, vec4f> = &buffer3.f0;
  let ptr9: ptr<uniform, VertexOutput0> = &buffer2[0];
  return out;
  _ = buffer3;
  _ = buffer2;
}

var<workgroup> vw3: array<array<array<array<atomic<u32>, 1>, 1>, 1>, 25>;

struct T3 {
  @align(8) @size(1392) f0: array<array<f32, 1>>,
}

var<workgroup> vw0: T1;

struct S0 {
  @location(7) f0: vec2i,
  @builtin(vertex_index) f1: u32,
  @builtin(instance_index) f2: u32,
  @location(8) f3: vec2f,
  @location(9) f4: f32,
  @location(14) @interpolate(flat) f5: u32,
}

@group(1) @binding(79) var<uniform> buffer3: VertexOutput0;

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

fn fn0() -> array<vec2u, 1> {
  var out: array<vec2u, 1>;
  out[u32(unconst_u32(328))] = bitcast<vec2u>((*&buffer3).f0.ba);
  var vf0: vec2f = unpack2x16snorm(u32(unconst_u32(91)));
  let ptr0: ptr<uniform, VertexOutput0> = &buffer3;
  out[pack2x16snorm(unpack2x16snorm(u32(unconst_u32(48))))] <<= bitcast<vec2u>((*&buffer2)[u32(unconst_u32(283))].f0.yy);
  var vf1: vec4h = reflect(vec4h(unconst_f16(13768.5), unconst_f16(1177.3), unconst_f16(-1416.5), unconst_f16(4078.1)), vec4h(unconst_f16(-38446.2), unconst_f16(24050.1), unconst_f16(2218.8), unconst_f16(5697.6)));
  var vf2: vec4u = unpack4xU8(u32(unconst_u32(221)));
  vf0 += buffer2[0].f0.rr;
  let vf3: f16 = vf1[u32(unconst_u32(64))];
  vf0 = buffer3.f0.xw;
  var vf4: f32 = (*&buffer2)[0].f0[u32(unconst_u32(23))];
  vf4 = bitcast<vec4f>(unpack4xU8(u32(unconst_u32(332)))).x;
  vf0 *= (*ptr0).f0.ga;
  return out;
  _ = buffer3;
  _ = buffer2;
}

@group(0) @binding(79) var<uniform> buffer2: array<VertexOutput0, 1>;

@vertex
fn vertex0(a0: S0, a1: S1, @location(12) @interpolate(flat) a2: vec4i) -> VertexOutput0 {
  var out: VertexOutput0;
  var vf9: vec2f = a0.f3;
  out.f0 = vec4f(f32(a0.f1));
  fn0();
  var vf10 = fn0();
  fn0();
  fn0();
  out = VertexOutput0(vec4f(a1.f0.xxyx));
  out.f0 = vec4f(a0.f4);
  let ptr10: ptr<uniform, vec4f> = &(*&buffer2)[0].f0;
  fn0();
  vf10[u32(unconst_u32(131))] += vec2u(a0.f5);
  var vf11 = fn0();
  vf9 *= (*&buffer2)[u32(unconst_u32(185))].f0.ww;
  vf10[u32(unconst_u32(221))] >>= countOneBits(vec3u(unconst_u32(53), unconst_u32(20), unconst_u32(134))).xx;
  var vf12 = fn0();
  let ptr11: ptr<uniform, vec4f> = &(*&buffer2)[u32(unconst_u32(43))].f0;
  out.f0 = vec4f(textureDimensions(tex0).rgrg);
  let ptr12: ptr<function, vec2u> = &vf11[u32(unconst_u32(153))];
  fn0();
  vf12[u32(unconst_u32(127))] *= vec2u((*ptr11).yz);
  var vf13 = fn0();
  let vf14: u32 = a0.f1;
  out = VertexOutput0(unpack4x8unorm(vf11[vf14][u32(unconst_u32(190))]));
  return out;
  _ = buffer3;
  _ = tex0;
  _ = buffer2;
}

@fragment
fn fragment0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  let vf15: f32 = buffer3.f0[u32(unconst_u32(118))];
  var vf16 = fn0();
  let vf17: vec3u = countTrailingZeros(vec3u(unconst_u32(90), unconst_u32(115), unconst_u32(54)));
  let ptr13: ptr<uniform, vec4f> = &(*&buffer2)[0].f0;
  let ptr14: ptr<uniform, vec4f> = &buffer2[0].f0;
  var vf18 = fn1();
  return out;
  _ = buffer3;
  _ = buffer2;
}`,
});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let commandEncoder5 = device0.createCommandEncoder({});
let sampler2 = device0.createSampler({lodMinClamp: 75.82, lodMaxClamp: 94.58});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let imageData1 = new ImageData(72, 48);
let bindGroup1 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 127, resource: {buffer: buffer1, offset: 1536, size: 1533}},
    {binding: 79, resource: {buffer: buffer1, offset: 1536, size: 1276}},
    {binding: 125, resource: textureView2},
  ],
});
let commandEncoder6 = device0.createCommandEncoder({});
let texture7 = device0.createTexture({size: [128, 128, 13], format: 'rg32float', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
try {
computePassEncoder0.setBindGroup(2, bindGroup0, []);
} catch {}
try {
texture3.destroy();
} catch {}
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let textureView4 = texture6.createView({baseArrayLayer: 5, arrayLayerCount: 4});
try {
commandEncoder5.insertDebugMarker('\u72b1');
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 127, resource: {buffer: buffer1, offset: 512, size: 5588}},
    {binding: 125, resource: textureView2},
    {binding: 79, resource: {buffer: buffer1, offset: 0, size: 995}},
  ],
});
let buffer5 = device0.createBuffer({
  size: 7431,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder7 = device0.createCommandEncoder({});
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 171});
let textureView5 = texture5.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 2});
let textureView6 = texture0.createView({mipLevelCount: 1});
let computePassEncoder5 = commandEncoder7.beginComputePass({});
try {
computePassEncoder1.setBindGroup(2, bindGroup1);
} catch {}
try {
buffer1.unmap();
} catch {}
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'bt709', transfer: 'bt2020_12bit'} });
let commandEncoder8 = device0.createCommandEncoder({});
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 735});
let textureView7 = texture5.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 6});
let computePassEncoder6 = commandEncoder4.beginComputePass({});
let renderPassEncoder0 = commandEncoder5.beginRenderPass({
  colorAttachments: [{
  view: textureView6,
  depthSlice: 77,
  clearValue: { r: 649.7, g: -728.7, b: 119.6, a: -250.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint16', 330, 270);
} catch {}
let bindGroup3 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 28, resource: textureView0}]});
let texture8 = device0.createTexture({
  size: [30, 1, 98],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView8 = texture6.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 1});
let computePassEncoder7 = commandEncoder6.beginComputePass({});
let sampler3 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 76.19,
});
try {
computePassEncoder4.setBindGroup(1, bindGroup1);
} catch {}
let texture9 = device0.createTexture({size: [120], dimension: '1d', format: 'rgba8uint', usage: GPUTextureUsage.STORAGE_BINDING});
let computePassEncoder8 = commandEncoder8.beginComputePass({});
try {
renderPassEncoder0.setVertexBuffer(0, buffer1, 60, 1_015);
} catch {}
let bindGroup4 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 28, resource: textureView0}]});
let commandEncoder9 = device0.createCommandEncoder({});
let texture10 = device0.createTexture({
  size: [336, 1, 43],
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView9 = texture8.createView({baseArrayLayer: 10, arrayLayerCount: 40});
let computePassEncoder9 = commandEncoder9.beginComputePass({});
let sampler4 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 75.63});
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint32', 776, 1_035);
} catch {}
try {
device0.queue.writeBuffer(buffer5, 32, new DataView(new ArrayBuffer(22989)), 440, 316);
} catch {}
let texture11 = device0.createTexture({
  size: {width: 128},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint16', 166, 48);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 77, y: 1, z: 4},
  aspect: 'all',
}, new Uint8Array(83_823).fill(110), /* required buffer size: 83_823 */
{offset: 47, bytesPerRow: 236, rowsPerImage: 80}, {width: 29, height: 35, depthOrArrayLayers: 5});
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
let texture12 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 89},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView10 = texture7.createView({dimension: 'cube-array', arrayLayerCount: 6});
try {
renderPassEncoder0.setBindGroup(2, bindGroup3);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup1, new Uint32Array(630), 214, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
document.body.prepend(canvas0);
let bindGroup5 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 28, resource: textureView6}]});
let commandEncoder10 = device0.createCommandEncoder({});
try {
computePassEncoder6.setBindGroup(0, bindGroup2, new Uint32Array(2144), 1_050, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
let textureView11 = texture9.createView({baseMipLevel: 0});
try {
computePassEncoder6.setBindGroup(2, bindGroup3);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer1, 0, 915);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 19, y: 38, z: 6},
  aspect: 'all',
}, new Uint8Array(30_311).fill(166), /* required buffer size: 30_311 */
{offset: 394, bytesPerRow: 167, rowsPerImage: 156}, {width: 3, height: 24, depthOrArrayLayers: 2});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
try {
texture2.label = '\u0dec\ubf28\u{1f9af}\u0a27\u0ecc';
} catch {}
let bindGroup6 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 125, resource: textureView7},
    {binding: 79, resource: {buffer: buffer5, offset: 1536, size: 450}},
    {binding: 127, resource: {buffer: buffer5, offset: 1792, size: 1788}},
  ],
});
let texture13 = device0.createTexture({
  label: '\u0bc7\u873c\u{1ff5b}\u21cd\u{1facc}\u06c6\ud6d1\u5091\u0899',
  size: {width: 128, height: 128, depthOrArrayLayers: 500},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView12 = texture0.createView({format: 'rg32float', arrayLayerCount: 1});
try {
computePassEncoder4.setBindGroup(0, bindGroup3, new Uint32Array(257), 64, 0);
} catch {}
let commandEncoder11 = device0.createCommandEncoder({});
let sampler5 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.87,
  maxAnisotropy: 5,
});
try {
renderPassEncoder0.setBindGroup(3, bindGroup2);
} catch {}
try {
globalThis.someLabel = buffer5.label;
} catch {}
let computePassEncoder10 = commandEncoder11.beginComputePass({});
try {
computePassEncoder9.setBindGroup(3, bindGroup2, new Uint32Array(831), 70, 0);
} catch {}
try {
renderPassEncoder0.setStencilReference(774);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer1, 0, 2_116);
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let imageBitmap0 = await createImageBitmap(imageData1);
let commandEncoder12 = device0.createCommandEncoder();
let texture14 = device0.createTexture({
  size: [336, 1, 165],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], stencilReadOnly: true});
let sampler6 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 2.827,
  maxAnisotropy: 11,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup2, new Uint32Array(1580), 1_106, 0);
} catch {}
try {
renderPassEncoder0.setViewport(1.2604402547373705, 0.6893912810879155, 20.097981876513032, 0.08078528543743016, 0.03976440224998945, 0.23942855279759465);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer0, 'uint16', 668, 2_336);
} catch {}
try {
  await promise1;
} catch {}
let computePassEncoder11 = commandEncoder10.beginComputePass({});
try {
computePassEncoder11.setBindGroup(3, bindGroup2, new Uint32Array(511), 17, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer1, 2_828, 49);
} catch {}
let commandEncoder13 = device0.createCommandEncoder({});
let textureView13 = texture9.createView({format: 'rgba8uint'});
try {
computePassEncoder8.setBindGroup(2, bindGroup0, new Uint32Array(3070), 781, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup4, new Uint32Array(895), 59, 0);
} catch {}
try {
renderBundleEncoder0.setBindGroup(3, bindGroup5);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(4, buffer1, 3_684, 1_628);
} catch {}
try {
commandEncoder13.copyTextureToBuffer({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 12},
  aspect: 'all',
}, {
  /* bytesInLastRow: 304 widthInBlocks: 38 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1416 */
  offset: 1416,
  bytesPerRow: 1792,
  buffer: buffer5,
}, {width: 38, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u09bc\u{1f703}\u0611\u1265\u49d3\u{1ff55}\ue14c\u5143\uf8b9\u71b9';
} catch {}
let computePassEncoder12 = commandEncoder13.beginComputePass({});
try {
computePassEncoder7.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder0.setViewport(4.0570814733131355, 0.3185411089333252, 25.888851434016935, 0.5442521942244656, 0.5031068219173498, 0.6211870956482126);
} catch {}
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 79, resource: {buffer: buffer1, offset: 2560, size: 350}},
    {binding: 127, resource: {buffer: buffer5, offset: 1024, size: 3776}},
    {binding: 125, resource: textureView2},
  ],
});
try {
renderPassEncoder0.setBindGroup(3, bindGroup2);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(3, buffer1);
} catch {}
try {
commandEncoder12.copyTextureToTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 0, y: 8, z: 2},
  aspect: 'all',
},
{
  texture: texture1,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 5});
} catch {}
try {
commandEncoder12.clearBuffer(buffer5, 100, 960);
} catch {}
try {
computePassEncoder3.insertDebugMarker('\u0bb2');
} catch {}
try {
device0.queue.writeBuffer(buffer5, 1732, new Float32Array(13330), 660, 160);
} catch {}
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 448});
let texture15 = device0.createTexture({
  size: [120, 1, 32],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder13 = commandEncoder12.beginComputePass({});
try {
renderBundleEncoder0.setBindGroup(0, bindGroup5, new Uint32Array(3226), 46, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(2, buffer1, 2_332);
} catch {}
try {
device0.queue.writeBuffer(buffer5, 3120, new Float32Array(5138), 1048, 24);
} catch {}
let texture16 = device0.createTexture({
  size: [2688, 1, 1],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle0 = renderBundleEncoder0.finish();
try {
renderPassEncoder0.setBindGroup(3, bindGroup4, new Uint32Array(1110), 21, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer1, 1_396, 954);
} catch {}
try {
texture1.label = '\ud724\u83cb\u{1f76b}\u057d\u{1f608}\u0bb8\u{1fbb2}';
} catch {}
let buffer6 = device0.createBuffer({size: 9853, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView14 = texture11.createView({dimension: '1d'});
try {
renderPassEncoder0.setBindGroup(1, bindGroup0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let promise3 = device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 60,
        attributes: [
          {format: 'sint8x4', offset: 4, shaderLocation: 12},
          {format: 'unorm8x4', offset: 16, shaderLocation: 0},
          {format: 'sint32', offset: 8, shaderLocation: 7},
          {format: 'uint16x4', offset: 12, shaderLocation: 14},
          {format: 'snorm16x2', offset: 4, shaderLocation: 6},
          {format: 'snorm8x4', offset: 8, shaderLocation: 8},
          {format: 'float32x3', offset: 0, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true},
});
let imageData2 = new ImageData(8, 128);
let bindGroup8 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 28, resource: textureView12}]});
let commandEncoder14 = device0.createCommandEncoder({});
let texture17 = device0.createTexture({
  size: [72, 1, 61],
  dimension: '2d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView15 = texture9.createView({});
let computePassEncoder14 = commandEncoder14.beginComputePass({});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder12.setBindGroup(2, bindGroup3);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup0, new Uint32Array(730), 95, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint16', 868, 554);
} catch {}
try {
  await promise2;
} catch {}
let textureView16 = texture4.createView({format: 'depth32float-stencil8', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 9});
let textureView17 = texture8.createView({dimension: '2d', baseArrayLayer: 1});
try {
computePassEncoder5.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder0.setScissorRect(1, 0, 1, 0);
} catch {}
let sampler7 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMaxClamp: 66.11, compare: 'equal'});
try {
computePassEncoder10.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup7, new Uint32Array(1595), 17, 0);
} catch {}
let textureView18 = texture5.createView({mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 5});
let texture18 = device0.createTexture({
  size: [60, 1, 44],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder5.setBindGroup(3, bindGroup6);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint32', 332, 92);
} catch {}
let pipeline0 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {},
  fragment: {module: shaderModule0, targets: [{format: 'rg32float', writeMask: 0}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 384,
        attributes: [
          {format: 'float16x2', offset: 64, shaderLocation: 6},
          {format: 'sint32x3', offset: 12, shaderLocation: 12},
          {format: 'float32', offset: 4, shaderLocation: 0},
          {format: 'sint32', offset: 60, shaderLocation: 7},
          {format: 'snorm16x4', offset: 40, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 556,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 72, shaderLocation: 9},
          {format: 'uint8x4', offset: 264, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {cullMode: 'front', unclippedDepth: false},
});
let autogeneratedBindGroupLayout0 = pipeline0.getBindGroupLayout(1);
let commandEncoder15 = device0.createCommandEncoder({});
let texture19 = device0.createTexture({
  size: [336, 1, 1],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup4, new Uint32Array(1577), 177, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer1, 540, 404);
} catch {}
try {
commandEncoder15.insertDebugMarker('\uaf66');
} catch {}
let autogeneratedBindGroupLayout1 = pipeline0.getBindGroupLayout(0);
let buffer7 = device0.createBuffer({
  size: 1268,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder16 = device0.createCommandEncoder({label: '\u{1fd4b}\uc9f4\u{1fd24}\u1c28\u{1faa2}\u8743'});
let texture20 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 7},
  mipLevelCount: 1,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder14.setBindGroup(3, bindGroup6);
} catch {}
try {
computePassEncoder12.setBindGroup(1, bindGroup8, new Uint32Array(1195), 74, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup4, new Uint32Array(1748), 40, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer5, 1808, new Int16Array(4816), 671, 336);
} catch {}
let texture21 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 136},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture22 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 100},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView19 = texture8.createView({aspect: 'all', baseArrayLayer: 10, arrayLayerCount: 7});
let computePassEncoder15 = commandEncoder16.beginComputePass({});
let renderPassEncoder1 = commandEncoder15.beginRenderPass({
  colorAttachments: [{view: textureView6, depthSlice: 4, loadOp: 'clear', storeOp: 'store'}],
  maxDrawCount: 836889333,
});
try {
computePassEncoder6.setBindGroup(2, bindGroup5);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer7, 0);
} catch {}
let texture23 = device0.createTexture({size: [72, 1, 1], format: 'rg32float', usage: GPUTextureUsage.STORAGE_BINDING, viewFormats: []});
try {
renderPassEncoder1.setBindGroup(3, bindGroup2, new Uint32Array(1835), 98, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint16', 370, 20);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline0);
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let texture24 = device0.createTexture({
  size: [576, 1, 49],
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture25 = device0.createTexture({
  size: [128, 128, 13],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder0.setVertexBuffer(6, buffer1, 464, 354);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 16, y: 7, z: 0},
  aspect: 'all',
}, new Uint8Array(118).fill(187), /* required buffer size: 118 */
{offset: 118, bytesPerRow: 422}, {width: 33, height: 5, depthOrArrayLayers: 0});
} catch {}
let pipeline1 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule0, targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALL}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 196,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm16x4', offset: 12, shaderLocation: 9},
          {format: 'float16x2', offset: 48, shaderLocation: 6},
          {format: 'sint32x2', offset: 8, shaderLocation: 12},
          {format: 'uint32x4', offset: 28, shaderLocation: 14},
          {format: 'sint16x4', offset: 28, shaderLocation: 7},
          {format: 'snorm16x2', offset: 48, shaderLocation: 0},
          {format: 'unorm16x2', offset: 84, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32'},
});
let querySet4 = device0.createQuerySet({type: 'occlusion', count: 303});
let textureView20 = texture20.createView({dimension: '2d', baseArrayLayer: 2});
let textureView21 = texture19.createView({});
let computePassEncoder16 = commandEncoder17.beginComputePass({});
try {
computePassEncoder11.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder3.setBindGroup(2, bindGroup3, new Uint32Array(6323), 525, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 49, y: 0, z: 23},
  aspect: 'all',
}, new Uint8Array(16_050).fill(45), /* required buffer size: 16_050 */
{offset: 226, bytesPerRow: 86, rowsPerImage: 23}, {width: 6, height: 0, depthOrArrayLayers: 9});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline2 = await promise3;
document.body.append(canvas0);
let autogeneratedBindGroupLayout2 = pipeline1.getBindGroupLayout(1);
let commandEncoder18 = device0.createCommandEncoder({});
let textureView22 = texture21.createView({});
try {
computePassEncoder7.setBindGroup(3, bindGroup0, new Uint32Array(1930), 284, 0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let buffer8 = device0.createBuffer({
  size: 24935,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder19 = device0.createCommandEncoder();
let renderPassEncoder2 = commandEncoder18.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: -958.2, g: -308.3, b: -556.7, a: 759.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder0.setViewport(14.965790302351385, 0.2812352790833901, 7.453181044276601, 0.47516486751363074, 0.6191788731297854, 0.6672946683394873);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 0, y: 8, z: 0},
  aspect: 'all',
}, new Uint8Array(2_558).fill(233), /* required buffer size: 2_558 */
{offset: 91, bytesPerRow: 69}, {width: 13, height: 36, depthOrArrayLayers: 1});
} catch {}
try {
  await promise4;
} catch {}
let autogeneratedBindGroupLayout3 = pipeline1.getBindGroupLayout(0);
let computePassEncoder17 = commandEncoder19.beginComputePass({});
let sampler8 = device0.createSampler({addressModeW: 'repeat', magFilter: 'linear', mipmapFilter: 'nearest'});
try {
renderPassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer8, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(425).fill(92), /* required buffer size: 425 */
{offset: 425}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u07c2\u0164';
} catch {}
try {
computePassEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(803), 79, 0);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -802.4, g: -801.2, b: -716.6, a: -272.0, });
} catch {}
try {
buffer5.unmap();
} catch {}
let bindGroup9 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [
    {binding: 79, resource: {buffer: buffer1, offset: 768, size: 1299}},
    {binding: 125, resource: textureView7},
  ],
});
let commandEncoder20 = device0.createCommandEncoder({});
let texture26 = device0.createTexture({
  size: [336],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder3 = commandEncoder20.beginRenderPass({colorAttachments: [{view: textureView12, depthSlice: 29, loadOp: 'load', storeOp: 'store'}]});
let sampler9 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat'});
try {
computePassEncoder8.setBindGroup(1, bindGroup0, new Uint32Array(603), 184, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup9, new Uint32Array(281), 40, 0);
} catch {}
try {
renderPassEncoder2.setStencilReference(1353);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer1, 0);
} catch {}
let buffer9 = device0.createBuffer({
  size: 12582,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder21 = device0.createCommandEncoder({label: '\ua5a4\u05f9\uc9c4\u0c90\u{1fd76}'});
let sampler10 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 17.37,
});
try {
buffer0.unmap();
} catch {}
try {
commandEncoder21.copyBufferToTexture({
  /* bytesInLastRow: 2152 widthInBlocks: 269 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2312 */
  offset: 2312,
  buffer: buffer8,
}, {
  texture: texture20,
  mipLevel: 0,
  origin: {x: 295, y: 0, z: 0},
  aspect: 'all',
}, {width: 269, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder21.copyTextureToTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 84, y: 49, z: 4},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 0,
  origin: {x: 33, y: 1, z: 0},
  aspect: 'all',
},
{width: 5, height: 52, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 220, new Int16Array(17122), 4673, 4);
} catch {}
let pipeline3 = device0.createRenderPipeline({
  label: '\uce1d\ud2c9\u4b1b\u7e59\u{1fde6}\u0cf8',
  layout: 'auto',
  fragment: {module: shaderModule0, constants: {}, targets: [{format: 'rg32float'}]},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 444,
        attributes: [
          {format: 'float32x4', offset: 12, shaderLocation: 0},
          {format: 'snorm8x4', offset: 96, shaderLocation: 9},
          {format: 'sint16x2', offset: 260, shaderLocation: 12},
          {format: 'unorm8x4', offset: 56, shaderLocation: 8},
          {format: 'sint32x3', offset: 36, shaderLocation: 7},
          {format: 'uint8x2', offset: 4, shaderLocation: 14},
          {format: 'float32x4', offset: 72, shaderLocation: 6},
        ],
      },
    ],
  },
});
let buffer10 = device0.createBuffer({size: 5333, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder5.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder0.setScissorRect(5, 0, 1, 0);
} catch {}
let autogeneratedBindGroupLayout4 = pipeline0.getBindGroupLayout(0);
let buffer11 = device0.createBuffer({size: 21558, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder22 = device0.createCommandEncoder({});
let textureView23 = texture24.createView({});
let renderPassEncoder4 = commandEncoder22.beginRenderPass({colorAttachments: [{view: textureView21, loadOp: 'clear', storeOp: 'discard'}]});
try {
renderPassEncoder4.setBindGroup(0, bindGroup8, new Uint32Array(1723), 160, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(5, buffer8, 2_548);
} catch {}
let commandEncoder23 = device0.createCommandEncoder({});
let renderPassEncoder5 = commandEncoder23.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  depthSlice: 54,
  clearValue: { r: -509.8, g: -680.3, b: -618.7, a: -589.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder1.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup7, new Uint32Array(1514), 382, 0);
} catch {}
try {
commandEncoder21.copyBufferToBuffer(buffer11, 1484, buffer6, 4804, 776);
} catch {}
try {
commandEncoder21.copyTextureToTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 0,
  origin: {x: 29, y: 18, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder21.resolveQuerySet(querySet3, 75, 139, buffer9, 512);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 19},
  aspect: 'all',
}, new Uint8Array(7).fill(230), /* required buffer size: 7 */
{offset: 7, bytesPerRow: 39, rowsPerImage: 0}, {width: 6, height: 0, depthOrArrayLayers: 4});
} catch {}
let autogeneratedBindGroupLayout5 = pipeline3.getBindGroupLayout(1);
let textureView24 = texture20.createView({dimension: '2d'});
let sampler11 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 98.35});
try {
renderPassEncoder0.setViewport(6.871943718239963, 0.8118316471508535, 7.970697174238395, 0.0452479163812703, 0.9417876257478311, 0.9471332783687948);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(16_555).fill(49), /* required buffer size: 16_555 */
{offset: 157, bytesPerRow: 101, rowsPerImage: 27}, {width: 36, height: 1, depthOrArrayLayers: 7});
} catch {}
document.body.prepend(canvas0);
let imageData3 = new ImageData(24, 40);
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpteRp431', transfer: 'smpte240m'} });
let bindGroup10 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 28, resource: textureView6}]});
let textureView25 = texture13.createView({});
let sampler12 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 74.26,
  maxAnisotropy: 4,
});
try {
computePassEncoder12.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder12.setBindGroup(0, bindGroup7, new Uint32Array(3651), 884, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint32', 8, 686);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer7);
} catch {}
try {
commandEncoder21.copyBufferToTexture({
  /* bytesInLastRow: 116 widthInBlocks: 29 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 920 */
  offset: 920,
  bytesPerRow: 7680,
  buffer: buffer8,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 29, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder21.copyTextureToBuffer({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1488 */
  offset: 1488,
  buffer: buffer6,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder21.copyTextureToTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
},
{
  texture: texture12,
  mipLevel: 0,
  origin: {x: 80, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout6 = pipeline3.getBindGroupLayout(0);
let commandEncoder24 = device0.createCommandEncoder({});
try {
computePassEncoder0.setBindGroup(2, bindGroup8, new Uint32Array(717), 39, 0);
} catch {}
try {
renderPassEncoder1.setStencilReference(64);
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 6612 */
  offset: 6612,
  buffer: buffer11,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder21.resolveQuerySet(querySet1, 43, 33, buffer9, 0);
} catch {}
try {
adapter0.label = '\u9bf0\u99b7\u01b0\ue1a8';
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 79,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 125,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 127,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup11 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 125, resource: textureView7}, {binding: 79, resource: {buffer: buffer7, offset: 0}}],
});
let buffer12 = device0.createBuffer({
  size: 13611,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder25 = device0.createCommandEncoder({});
let textureView26 = texture23.createView({dimension: '2d-array', format: 'rg32float'});
let computePassEncoder18 = commandEncoder25.beginComputePass({});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg32float']});
let renderBundle1 = renderBundleEncoder1.finish({});
let sampler13 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  lodMinClamp: 94.47,
  lodMaxClamp: 95.91,
  compare: 'equal',
  maxAnisotropy: 1,
});
try {
computePassEncoder4.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup3, new Uint32Array(501), 39, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle1, renderBundle1, renderBundle1, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: 622.8, g: -864.5, b: -639.4, a: -566.5, });
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer7, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let pipeline4 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0xffffffff},
  fragment: {module: shaderModule0, targets: [{format: 'rg32float'}]},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 220,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 4, shaderLocation: 7},
          {format: 'unorm16x4', offset: 16, shaderLocation: 8},
          {format: 'uint32', offset: 20, shaderLocation: 14},
          {format: 'float32x2', offset: 24, shaderLocation: 6},
          {format: 'snorm16x2', offset: 4, shaderLocation: 0},
          {format: 'sint16x2', offset: 56, shaderLocation: 12},
          {format: 'unorm16x2', offset: 28, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'front'},
});
let commandEncoder26 = device0.createCommandEncoder({});
let texture27 = device0.createTexture({
  size: [576],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder19 = commandEncoder26.beginComputePass({});
try {
renderPassEncoder1.setPipeline(pipeline3);
} catch {}
try {
commandEncoder21.resolveQuerySet(querySet3, 4, 151, buffer12, 512);
} catch {}
document.body.prepend(canvas0);
let texture28 = device0.createTexture({
  size: [288, 1, 36],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder11.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup1);
} catch {}
let buffer13 = device0.createBuffer({size: 30155, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let commandEncoder27 = device0.createCommandEncoder();
try {
computePassEncoder1.setBindGroup(2, bindGroup9);
} catch {}
try {
computePassEncoder10.setBindGroup(0, bindGroup5, new Uint32Array(1600), 670, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup8, new Uint32Array(329), 66, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 2_774, 370);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 788 widthInBlocks: 197 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 912 */
  offset: 912,
  bytesPerRow: 6912,
  buffer: buffer11,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 105, y: 0, z: 0},
  aspect: 'all',
}, {width: 197, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 1, depthOrArrayLayers: 36}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture28,
  mipLevel: 0,
  origin: {x: 79, y: 0, z: 7},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder20 = commandEncoder21.beginComputePass({});
try {
computePassEncoder18.setBindGroup(2, bindGroup9);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: 643.0, g: 945.3, b: 969.1, a: -134.2, });
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer8, 2056, buffer6, 3180, 4048);
} catch {}
let buffer14 = device0.createBuffer({size: 31071, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let computePassEncoder21 = commandEncoder24.beginComputePass({});
let renderPassEncoder6 = commandEncoder27.beginRenderPass({
  colorAttachments: [{
  view: textureView6,
  depthSlice: 28,
  clearValue: { r: 210.3, g: -649.2, b: -153.7, a: -303.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 337459693,
});
try {
renderPassEncoder6.setPipeline(pipeline2);
} catch {}
let autogeneratedBindGroupLayout7 = pipeline3.getBindGroupLayout(1);
let textureView27 = texture10.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 3});
let sampler14 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 75.89,
  maxAnisotropy: 6,
});
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
buffer5.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 9}
*/
{
  source: imageData3,
  origin: { x: 1, y: 3 },
  flipY: false,
}, {
  texture: texture28,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData4 = new ImageData(28, 20);
let autogeneratedBindGroupLayout8 = pipeline3.getBindGroupLayout(1);
let buffer15 = device0.createBuffer({
  size: 1030,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture29 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 2},
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler15 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'never',
  maxAnisotropy: 14,
});
try {
computePassEncoder19.setBindGroup(3, bindGroup11);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup3, new Uint32Array(444), 2, 0);
} catch {}
try {
renderPassEncoder4.setBlendConstant({ r: 658.7, g: 385.4, b: 218.1, a: -18.65, });
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer8, 'uint32', 2_880, 4_968);
} catch {}
try {
buffer9.unmap();
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
let texture30 = device0.createTexture({
  size: {width: 576},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler16 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 56.22,
  lodMaxClamp: 99.64,
  maxAnisotropy: 11,
});
try {
computePassEncoder13.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer9, 'uint16', 1_746, 4_399);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let commandEncoder28 = device0.createCommandEncoder({});
let texture31 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 24},
  mipLevelCount: 5,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView28 = texture1.createView({label: '\udde9\u0ef7\u{1f88b}\u{1fd28}', format: 'rg32float'});
let renderPassEncoder7 = commandEncoder28.beginRenderPass({
  colorAttachments: [{view: textureView12, depthSlice: 124, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet2,
});
try {
computePassEncoder11.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(280);
} catch {}
try {
device0.queue.label = '\u{1f6e5}\u02b7\u0911\u{1fe5e}\u0cba\u03b4';
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [
    {binding: 79, resource: {buffer: buffer15, offset: 0, size: 878}},
    {binding: 125, resource: textureView2},
  ],
});
let texture32 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 13},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
computePassEncoder14.setBindGroup(0, bindGroup3, new Uint32Array(4558), 514, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline0);
} catch {}
await gc();
let videoFrame2 = new VideoFrame(videoFrame0, {timestamp: 0});
let commandEncoder29 = device0.createCommandEncoder({});
let renderPassEncoder8 = commandEncoder29.beginRenderPass({
  colorAttachments: [{
  view: textureView6,
  depthSlice: 75,
  clearValue: { r: 508.1, g: 584.7, b: -23.61, a: -935.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder2.setBindGroup(2, bindGroup3);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup6, new Uint32Array(857), 411, 0);
} catch {}
let commandEncoder30 = device0.createCommandEncoder({});
let textureView29 = texture12.createView({baseArrayLayer: 6, arrayLayerCount: 17});
let computePassEncoder22 = commandEncoder30.beginComputePass();
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: false});
try {
renderBundleEncoder2.setBindGroup(2, bindGroup7, new Uint32Array(7827), 3_842, 0);
} catch {}
try {
  await promise5;
} catch {}
let texture33 = device0.createTexture({
  size: [144, 1, 177],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView30 = texture21.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
renderBundleEncoder2.setIndexBuffer(buffer12, 'uint32', 644, 3_655);
} catch {}
document.body.append(canvas0);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let autogeneratedBindGroupLayout9 = pipeline0.getBindGroupLayout(0);
try {
renderPassEncoder4.setIndexBuffer(buffer15, 'uint32', 316, 57);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(1, buffer7, 0, 24);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer7, 'uint16', 346, 7);
} catch {}
let texture34 = device0.createTexture({
  size: [72, 1, 29],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView31 = texture30.createView({mipLevelCount: 1});
try {
computePassEncoder14.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer7, 'uint16', 20, 10);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup9);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer15, 'uint32', 288, 217);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 68, new BigUint64Array(7613), 81, 144);
} catch {}
document.body.prepend(canvas0);
let buffer16 = device0.createBuffer({size: 3326, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let textureView32 = texture23.createView({});
let sampler17 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder9.setBindGroup(1, bindGroup8);
} catch {}
try {
computePassEncoder1.setBindGroup(1, bindGroup12, new Uint32Array(124), 8, 0);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -223.4, g: 202.1, b: -909.4, a: 117.6, });
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer9, 'uint16', 1_646, 8_121);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup3, new Uint32Array(2751), 1_389, 0);
} catch {}
try {
buffer16.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer14, 632, new BigUint64Array(26064), 1842, 484);
} catch {}
let commandEncoder31 = device0.createCommandEncoder();
let texture35 = device0.createTexture({
  label: '\u0bbe\u1736\u0d5a\u{1f651}\u72c0\u19b7\u047e\u449f\u481f\u0cfd\u{1f800}',
  size: [336],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView33 = texture30.createView({});
let renderPassEncoder9 = commandEncoder31.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  depthSlice: 41,
  clearValue: { r: -760.2, g: -82.32, b: -158.5, a: -638.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 137252183,
});
try {
computePassEncoder18.setBindGroup(0, bindGroup0, new Uint32Array(223), 11, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer8, 'uint32', 1_920, 846);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup6, new Uint32Array(1216), 323, 0);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline4);
} catch {}
try {
buffer9.unmap();
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
let sampler18 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  compare: 'never',
});
try {
computePassEncoder12.setBindGroup(0, bindGroup12, new Uint32Array(541), 126, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer15, 'uint16', 130, 38);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer15, 'uint32', 36, 698);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let canvas1 = document.createElement('canvas');
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let textureView34 = texture17.createView({dimension: '2d', baseArrayLayer: 9});
try {
computePassEncoder14.setBindGroup(3, bindGroup12);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup11, new Uint32Array(2043), 232, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer9, 'uint16', 216, 939);
} catch {}
await gc();
let autogeneratedBindGroupLayout10 = pipeline4.getBindGroupLayout(0);
let textureView35 = texture22.createView({dimension: '2d', baseArrayLayer: 35, arrayLayerCount: 1});
let renderBundle2 = renderBundleEncoder2.finish({});
try {
renderPassEncoder5.setBindGroup(3, bindGroup11, new Uint32Array(754), 29, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer8, 1_216, 18_159);
} catch {}
let imageData5 = new ImageData(12, 4);
let commandEncoder32 = device0.createCommandEncoder({});
let texture36 = device0.createTexture({
  size: [672, 1, 771],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder23 = commandEncoder32.beginComputePass({});
try {
computePassEncoder1.setBindGroup(0, bindGroup1, new Uint32Array(501), 53, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup0, new Uint32Array(780), 604, 0);
} catch {}
let sampler19 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 97.03});
try {
renderPassEncoder9.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup10, new Uint32Array(4608), 206, 0);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(443);
} catch {}
try {
renderPassEncoder7.setStencilReference(309);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer9, 'uint16', 436, 1_278);
} catch {}
try {
device0.queue.writeBuffer(buffer16, 1420, new Float32Array(5854), 72, 8);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 1, depthOrArrayLayers: 36}
*/
{
  source: canvas0,
  origin: { x: 3, y: 45 },
  flipY: true,
}, {
  texture: texture28,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
canvas1.getContext('webgl');
} catch {}
let bindGroup13 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout8,
  entries: [{binding: 79, resource: {buffer: buffer15, offset: 0, size: 376}}],
});
let buffer17 = device0.createBuffer({size: 18122, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder33 = device0.createCommandEncoder({});
let texture37 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 6},
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder24 = commandEncoder33.beginComputePass({});
try {
computePassEncoder16.setBindGroup(2, bindGroup10);
} catch {}
try {
computePassEncoder24.setBindGroup(2, bindGroup7, new Uint32Array(971), 110, 0);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
device0.queue.writeBuffer(buffer7, 4, new DataView(new ArrayBuffer(9719)), 7935, 136);
} catch {}
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout5]});
let buffer18 = device0.createBuffer({size: 1302, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let sampler20 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat'});
try {
computePassEncoder7.setBindGroup(0, bindGroup13, new Uint32Array(534), 120, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup3, new Uint32Array(2290), 328, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline4);
} catch {}
let texture38 = device0.createTexture({
  size: {width: 72, height: 1, depthOrArrayLayers: 39},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView36 = texture17.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5});
try {
computePassEncoder15.setBindGroup(3, bindGroup5, new Uint32Array(182), 34, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(3, buffer8, 6_576, 3_135);
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 79, resource: {buffer: buffer1, offset: 2816, size: 2189}}],
});
let commandEncoder34 = device0.createCommandEncoder();
let computePassEncoder25 = commandEncoder34.beginComputePass({});
let sampler21 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
computePassEncoder1.setBindGroup(2, bindGroup2, new Uint32Array(1162), 39, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup2, new Uint32Array(510), 23, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, buffer7);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 9}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture28,
  mipLevel: 2,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.label = '\u0942\u0506\u1283\uc5b0\u{1f854}\u{1f894}';
} catch {}
let autogeneratedBindGroupLayout11 = pipeline0.getBindGroupLayout(1);
let commandEncoder35 = device0.createCommandEncoder({});
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 247});
let renderPassEncoder10 = commandEncoder35.beginRenderPass({
  colorAttachments: [{view: textureView25, depthSlice: 352, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 873420477,
});
try {
computePassEncoder6.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(844), 7, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer18, 'uint16', 240, 23);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 22, y: 5, z: 0},
  aspect: 'all',
}, new Uint8Array(144).fill(148), /* required buffer size: 144 */
{offset: 112, bytesPerRow: 44}, {width: 4, height: 1, depthOrArrayLayers: 1});
} catch {}
let textureView37 = texture13.createView({});
try {
computePassEncoder16.setBindGroup(3, bindGroup10);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup6, new Uint32Array(2579), 259, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder1.setViewport(23.427316790145785, 0.2817686247374114, 5.929036780599876, 0.3446477349862695, 0.671233292805835, 0.9864043975275467);
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt470bg', transfer: 'gamma22curve'} });
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 36,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let autogeneratedBindGroupLayout12 = pipeline2.getBindGroupLayout(1);
let commandEncoder36 = device0.createCommandEncoder({});
let computePassEncoder26 = commandEncoder36.beginComputePass({});
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle2, renderBundle2, renderBundle1]);
} catch {}
try {
renderPassEncoder2.setViewport(4.990544369747079, 0.712028792737494, 130.8520408871011, 0.2665118374810802, 0.6691206269271804, 0.8976240679814238);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 19, y: 10, z: 2},
  aspect: 'all',
}, new Uint8Array(2).fill(27), /* required buffer size: 2 */
{offset: 2, bytesPerRow: 106}, {width: 1, height: 74, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas0);
let canvas2 = document.createElement('canvas');
let commandEncoder37 = device0.createCommandEncoder({});
let computePassEncoder27 = commandEncoder37.beginComputePass({});
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint16', 736, 37);
} catch {}
try {
  await promise6;
} catch {}
let texture39 = device0.createTexture({
  size: {width: 336, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler22 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  lodMaxClamp: 96.63,
});
try {
renderPassEncoder5.setBindGroup(0, bindGroup9, new Uint32Array(738), 144, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer16, 'uint32', 176, 171);
} catch {}
let sampler23 = device0.createSampler({addressModeW: 'mirror-repeat', magFilter: 'linear', minFilter: 'linear', lodMaxClamp: 90.56});
try {
computePassEncoder10.setBindGroup(2, bindGroup6, new Uint32Array(641), 21, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup14, new Uint32Array(889), 93, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer7, 0, 58);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData6 = new ImageData(16, 44);
let buffer19 = device0.createBuffer({
  size: 29676,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView38 = texture34.createView({
  label: '\ueda0\u{1ffee}\u{1fe6d}\u{1f839}\u3700\u2ab5\uc8aa\u0b6e',
  mipLevelCount: 1,
  baseArrayLayer: 0,
});
try {
computePassEncoder18.setBindGroup(0, bindGroup10, new Uint32Array(777), 93, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup9, new Uint32Array(3024), 433, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 1, depthOrArrayLayers: 18}
*/
{
  source: imageData6,
  origin: { x: 3, y: 0 },
  flipY: true,
}, {
  texture: texture28,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
globalThis.someLabel = device0.label;
} catch {}
let texture40 = device0.createTexture({
  size: [240, 1, 98],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder17.setBindGroup(3, bindGroup5);
} catch {}
try {
computePassEncoder22.setBindGroup(0, bindGroup11, new Uint32Array(959), 75, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup3, new Uint32Array(357), 95, 0);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(7, buffer7, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u014c');
} catch {}
let texture41 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 79},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder19.setBindGroup(1, bindGroup3, new Uint32Array(4268), 895, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline4);
} catch {}
let imageData7 = new ImageData(48, 8);
let videoFrame4 = videoFrame1.clone();
try {
canvas2.getContext('bitmaprenderer');
} catch {}
let autogeneratedBindGroupLayout13 = pipeline3.getBindGroupLayout(0);
let bindGroup15 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout12,
  entries: [{binding: 79, resource: {buffer: buffer12, offset: 1792, size: 3776}}],
});
let texture42 = device0.createTexture({
  size: [60, 1, 140],
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler24 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 94.93});
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle2, renderBundle2, renderBundle1, renderBundle1]);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let autogeneratedBindGroupLayout14 = pipeline1.getBindGroupLayout(0);
let textureView39 = texture42.createView({label: '\u06fc\u2994\u5fea\u0680\u067e'});
let texture43 = device0.createTexture({
  size: [128],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView40 = texture20.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
try {
device0.queue.writeBuffer(buffer14, 18620, new Int16Array(8315), 512, 2632);
} catch {}
let autogeneratedBindGroupLayout15 = pipeline4.getBindGroupLayout(0);
let commandEncoder38 = device0.createCommandEncoder({});
let computePassEncoder28 = commandEncoder38.beginComputePass({});
try {
computePassEncoder18.setBindGroup(1, bindGroup11, new Uint32Array(531), 159, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup12);
} catch {}
document.body.append(canvas1);
let autogeneratedBindGroupLayout16 = pipeline1.getBindGroupLayout(1);
let texture44 = device0.createTexture({
  size: [336, 1, 650],
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView41 = texture19.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder23.setBindGroup(0, bindGroup9);
} catch {}
try {
computePassEncoder6.setBindGroup(3, bindGroup5, new Uint32Array(2316), 604, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup14, new Uint32Array(141), 0, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer6, 812, new BigUint64Array(24338), 4428, 192);
} catch {}
try {
  await promise7;
} catch {}
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 35,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 67,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 91, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let bindGroup16 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout8,
  entries: [{binding: 79, resource: {buffer: buffer1, offset: 2048, size: 1032}}],
});
let texture45 = device0.createTexture({
  size: [672, 1, 54],
  mipLevelCount: 3,
  format: 'rgba8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup6, new Uint32Array(1500), 87, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer18, 'uint32', 272, 47);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(7, buffer1);
} catch {}
canvas0.height = 1849;
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpteRp431', transfer: 'smpteSt4281'} });
let commandEncoder39 = device0.createCommandEncoder({});
let texture46 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 19},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView42 = texture18.createView({baseArrayLayer: 11, arrayLayerCount: 8});
let computePassEncoder29 = commandEncoder39.beginComputePass({});
try {
computePassEncoder22.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle2]);
} catch {}
let pipeline5 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 576,
        attributes: [
          {format: 'float32x4', offset: 16, shaderLocation: 0},
          {format: 'float32x4', offset: 44, shaderLocation: 8},
          {format: 'uint32x2', offset: 8, shaderLocation: 14},
          {format: 'unorm8x2', offset: 132, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 36, shaderLocation: 9},
          {format: 'sint32x2', offset: 28, shaderLocation: 7},
          {format: 'sint16x2', offset: 68, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {cullMode: 'front', unclippedDepth: true},
});
let commandEncoder40 = device0.createCommandEncoder();
let texture47 = device0.createTexture({
  size: [1344],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let renderPassEncoder11 = commandEncoder40.beginRenderPass({colorAttachments: [{view: textureView21, loadOp: 'clear', storeOp: 'discard'}]});
try {
renderPassEncoder7.beginOcclusionQuery(191);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer15, 'uint32', 44, 49);
} catch {}
let bindGroup17 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout13,
  entries: [{binding: 79, resource: {buffer: buffer19, offset: 6400}}, {binding: 125, resource: textureView2}],
});
let buffer20 = device0.createBuffer({size: 10979, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder41 = device0.createCommandEncoder();
let textureView43 = texture42.createView({dimension: '3d', baseMipLevel: 0});
let computePassEncoder30 = commandEncoder41.beginComputePass();
let sampler25 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'not-equal',
  maxAnisotropy: 6,
});
try {
computePassEncoder17.setBindGroup(2, bindGroup15);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup14, new Uint32Array(1929), 79, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer15, 'uint32', 180, 1);
} catch {}
document.body.prepend(canvas1);
let imageData8 = new ImageData(80, 28);
let sampler26 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
computePassEncoder6.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer9, 'uint16', 428, 849);
} catch {}
try {
buffer20.unmap();
} catch {}
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 35,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 67,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 91, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let texture48 = device0.createTexture({
  size: {width: 336, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder9.setIndexBuffer(buffer18, 'uint32', 284, 45);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup18 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout8,
  entries: [{binding: 79, resource: {buffer: buffer7, offset: 256}}],
});
let texture49 = device0.createTexture({
  size: [336, 1, 51],
  mipLevelCount: 3,
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture50 = device0.createTexture({
  size: [30],
  dimension: '1d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView44 = texture15.createView({
  label: '\u{1fc94}\u08c4\u0dde\u09bd\u4a0b\u4131\u01c2\u{1fafe}\u71dd',
  dimension: '2d',
  aspect: 'all',
  baseArrayLayer: 1,
});
let sampler27 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 96.86,
});
try {
computePassEncoder28.setBindGroup(1, bindGroup10, new Uint32Array(587), 46, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer12, 'uint16', 2_138, 4_408);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 1, depthOrArrayLayers: 36}
*/
{
  source: imageData5,
  origin: { x: 2, y: 0 },
  flipY: true,
}, {
  texture: texture28,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 18},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout17 = pipeline4.getBindGroupLayout(1);
let commandEncoder42 = device0.createCommandEncoder();
let texture51 = device0.createTexture({
  label: '\u68b0\u{1f6a5}\u4334\u0648\u{1fd49}\u364b\u5129\u9740',
  size: [30, 1, 1],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture52 = device0.createTexture({
  size: {width: 240, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgba8uint'],
});
let textureView45 = texture50.createView({});
try {
computePassEncoder17.setBindGroup(3, bindGroup16);
} catch {}
try {
commandEncoder42.copyBufferToBuffer(buffer11, 372, buffer10, 624, 116);
} catch {}
try {
commandEncoder42.copyTextureToTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 0, y: 8, z: 7},
  aspect: 'all',
},
{
  texture: texture32,
  mipLevel: 0,
  origin: {x: 32, y: 34, z: 0},
  aspect: 'all',
},
{width: 2, height: 6, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout18 = pipeline3.getBindGroupLayout(0);
let texture53 = device0.createTexture({
  size: {width: 672, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'depth24plus',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture54 = device0.createTexture({
  size: {width: 672, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView46 = texture33.createView({mipLevelCount: 1});
let computePassEncoder31 = commandEncoder42.beginComputePass({});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: true});
let sampler28 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 63.08,
});
let externalTexture1 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder4.setBindGroup(1, bindGroup11);
} catch {}
try {
computePassEncoder31.setBindGroup(2, bindGroup0, new Uint32Array(834), 154, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup0);
} catch {}
let autogeneratedBindGroupLayout19 = pipeline0.getBindGroupLayout(0);
let commandEncoder43 = device0.createCommandEncoder({});
let textureView47 = texture49.createView({dimension: '2d', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 7});
let texture55 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 13},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder32 = commandEncoder43.beginComputePass({});
try {
renderPassEncoder6.setIndexBuffer(buffer8, 'uint32', 848, 648);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer1, 0, 909);
} catch {}
try {
buffer0.unmap();
} catch {}
document.body.append(canvas0);
let textureView48 = texture49.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 12});
let externalTexture2 = device0.importExternalTexture({source: videoFrame4});
try {
renderPassEncoder7.setIndexBuffer(buffer15, 'uint16', 58, 468);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer7, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer8, 'uint32', 6_232, 699);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline0);
} catch {}
let buffer21 = device0.createBuffer({
  size: 6184,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView49 = texture53.createView({aspect: 'depth-only', mipLevelCount: 1});
let renderBundle3 = renderBundleEncoder3.finish({});
try {
computePassEncoder13.setBindGroup(3, bindGroup11);
} catch {}
try {
computePassEncoder10.setBindGroup(0, bindGroup16, new Uint32Array(1737), 34, 0);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup15, new Uint32Array(3847), 771, 0);
} catch {}
try {
renderPassEncoder3.end();
} catch {}
try {
commandEncoder20.copyBufferToBuffer(buffer8, 1916, buffer20, 704, 640);
} catch {}
try {
commandEncoder20.resolveQuerySet(querySet1, 100, 10, buffer5, 1024);
} catch {}
let textureView50 = texture32.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 12});
try {
computePassEncoder23.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(3, buffer7);
} catch {}
let computePassEncoder33 = commandEncoder20.beginComputePass();
try {
computePassEncoder15.setBindGroup(3, bindGroup13, []);
} catch {}
try {
computePassEncoder10.setBindGroup(1, bindGroup4, new Uint32Array(206), 143, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle1, renderBundle2]);
} catch {}
try {
renderPassEncoder9.setStencilReference(300);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer7, 488, 246);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 5},
  aspect: 'all',
}, new Uint8Array(110).fill(20), /* required buffer size: 110 */
{offset: 110, bytesPerRow: 139}, {width: 13, height: 64, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 2, y: 6, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout20 = pipeline2.getBindGroupLayout(1);
let textureView51 = texture50.createView({baseMipLevel: 0});
try {
renderPassEncoder11.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder8.setBindGroup(0, bindGroup3);
} catch {}
try {
computePassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(1636), 427, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer21, 0, 2_071);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup19 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [
    {binding: 79, resource: {buffer: buffer1, offset: 2048, size: 5257}},
    {binding: 125, resource: textureView2},
  ],
});
let texture56 = device0.createTexture({
  size: [1344],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView52 = texture54.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], sampleCount: 1, stencilReadOnly: true});
try {
computePassEncoder11.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(127);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(4, buffer1, 0, 580);
} catch {}
try {
buffer14.unmap();
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let imageData9 = new ImageData(56, 4);
let commandEncoder44 = device0.createCommandEncoder({});
let textureView53 = texture8.createView({dimension: '2d-array', baseArrayLayer: 14, arrayLayerCount: 21});
let renderPassEncoder12 = commandEncoder44.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: -952.3, g: 563.3, b: 737.6, a: -976.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let renderBundle4 = renderBundleEncoder4.finish();
try {
computePassEncoder31.setBindGroup(1, bindGroup16, new Uint32Array(1911), 24, 0);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup5, new Uint32Array(1770), 507, 0);
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [{binding: 79, resource: {buffer: buffer1, offset: 256, size: 7707}}],
});
try {
renderPassEncoder5.setIndexBuffer(buffer19, 'uint32', 5_632, 618);
} catch {}
let autogeneratedBindGroupLayout21 = pipeline1.getBindGroupLayout(1);
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout7]});
try {
computePassEncoder9.setBindGroup(1, bindGroup11);
} catch {}
try {
computePassEncoder20.setBindGroup(3, bindGroup11, new Uint32Array(153), 3, 0);
} catch {}
document.body.prepend(canvas1);
let bindGroup21 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout1,
  entries: [{binding: 125, resource: textureView49}, {binding: 79, resource: {buffer: buffer21, offset: 512}}],
});
let buffer22 = device0.createBuffer({
  label: '\u0f5f\u{1fab9}\u0791\u6220\u0e7f\u5f4d\ufb11',
  size: 17411,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let sampler29 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 89.93,
  maxAnisotropy: 11,
});
try {
renderPassEncoder5.setBindGroup(3, bindGroup6);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
let autogeneratedBindGroupLayout22 = pipeline1.getBindGroupLayout(1);
let buffer23 = device0.createBuffer({size: 611, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
try {
computePassEncoder30.setBindGroup(2, bindGroup10, new Uint32Array(5099), 378, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(6, buffer1);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: imageData0,
  origin: { x: 2, y: 4 },
  flipY: false,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 13, y: 8, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 6, height: 4, depthOrArrayLayers: 0});
} catch {}
let bindGroup22 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [{binding: 79, resource: {buffer: buffer7, offset: 256}}, {binding: 125, resource: textureView49}],
});
let commandEncoder45 = device0.createCommandEncoder({});
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 28});
let texture57 = device0.createTexture({
  size: {width: 72},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView54 = texture30.createView({});
let computePassEncoder34 = commandEncoder45.beginComputePass({});
try {
computePassEncoder27.setBindGroup(0, bindGroup14, new Uint32Array(3377), 128, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup20, new Uint32Array(609), 65, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.insertDebugMarker('\u7420');
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas2);
let buffer24 = device0.createBuffer({size: 7518, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let texture58 = device0.createTexture({
  size: [240],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder34.setBindGroup(2, bindGroup5, new Uint32Array(521), 13, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup5, new Uint32Array(3632), 992, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer21, 'uint16', 1_876, 38);
} catch {}
let bindGroup23 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout8,
  entries: [{binding: 79, resource: {buffer: buffer1, offset: 0, size: 721}}],
});
let textureView55 = texture18.createView({dimension: '2d', format: 'rg32float'});
try {
computePassEncoder31.setBindGroup(2, bindGroup16);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup11);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint32', 0, 2);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer21);
} catch {}
try {
buffer23.unmap();
} catch {}
try {
adapter0.label = '\u02a2\u3d08\u8adc\u0f72\ue0c3\ue9d3\u{1f856}\u062f\uda56';
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup7, new Uint32Array(160), 25, 0);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(98);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer21.unmap();
} catch {}
let autogeneratedBindGroupLayout23 = pipeline5.getBindGroupLayout(1);
let commandEncoder46 = device0.createCommandEncoder({});
let texture59 = device0.createTexture({size: [576, 1, 1], format: 'rgba8uint', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 1, y: 29, z: 0},
  aspect: 'all',
}, new Uint8Array(212_051).fill(17), /* required buffer size: 212_051 */
{offset: 252, bytesPerRow: 287, rowsPerImage: 239}, {width: 35, height: 21, depthOrArrayLayers: 4});
} catch {}
let computePassEncoder35 = commandEncoder46.beginComputePass({});
try {
computePassEncoder22.setBindGroup(2, bindGroup14);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup14, new Uint32Array(2070), 126, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 9}
*/
{
  source: imageData3,
  origin: { x: 3, y: 6 },
  flipY: false,
}, {
  texture: texture28,
  mipLevel: 2,
  origin: {x: 6, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(10, 113);
let texture60 = device0.createTexture({
  size: [2688, 1, 1],
  mipLevelCount: 3,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder9.setBindGroup(1, bindGroup2, new Uint32Array(532), 73, 0);
} catch {}
let pipeline6 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 180,
        attributes: [
          {format: 'unorm16x2', offset: 8, shaderLocation: 6},
          {format: 'snorm16x2', offset: 0, shaderLocation: 8},
          {format: 'float32x2', offset: 8, shaderLocation: 0},
          {format: 'sint16x2', offset: 8, shaderLocation: 7},
          {format: 'unorm10-10-10-2', offset: 36, shaderLocation: 9},
          {format: 'uint32x4', offset: 16, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 288,
        stepMode: 'instance',
        attributes: [{format: 'sint32x2', offset: 32, shaderLocation: 12}],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'front'},
});
let autogeneratedBindGroupLayout24 = pipeline1.getBindGroupLayout(0);
let textureView56 = texture11.createView({format: 'rgba8uint'});
try {
renderPassEncoder7.beginOcclusionQuery(190);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle1, renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer21, 1_128);
} catch {}
try {
computePassEncoder35.insertDebugMarker('\u0eec');
} catch {}
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
await gc();
let buffer25 = device0.createBuffer({size: 4177, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
let textureView57 = texture8.createView({mipLevelCount: 1, baseArrayLayer: 41, arrayLayerCount: 10});
try {
renderPassEncoder8.setScissorRect(4, 0, 1, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup24 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout19,
  entries: [{binding: 79, resource: {buffer: buffer7, offset: 0}}, {binding: 125, resource: textureView2}],
});
let texture61 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
buffer17.unmap();
} catch {}
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout9]});
let textureView58 = texture22.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 9, arrayLayerCount: 1});
try {
computePassEncoder3.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer16, 'uint16', 488, 131);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer26 = device0.createBuffer({
  size: 10740,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
let textureView59 = texture25.createView({dimension: 'cube-array', format: 'rgba8uint', mipLevelCount: 1, arrayLayerCount: 6});
try {
computePassEncoder18.setBindGroup(3, bindGroup6);
} catch {}
try {
computePassEncoder8.setBindGroup(1, bindGroup2, new Uint32Array(3102), 399, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup23);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer23, 'uint32', 152, 142);
} catch {}
try {
computePassEncoder17.pushDebugGroup('\u7010');
} catch {}
let buffer27 = device0.createBuffer({size: 9858, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder1.setBindGroup(1, bindGroup3, new Uint32Array(940), 119, 0);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle3]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture59,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(177).fill(78), /* required buffer size: 177 */
{offset: 177}, {width: 180, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData10 = new ImageData(80, 48);
let videoFrame6 = new VideoFrame(offscreenCanvas0, {timestamp: 0});
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 352,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder47 = device0.createCommandEncoder({});
let textureView60 = texture25.createView({dimension: 'cube-array', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 6});
let computePassEncoder36 = commandEncoder47.beginComputePass({});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], stencilReadOnly: false});
let renderBundle5 = renderBundleEncoder5.finish({});
try {
computePassEncoder34.setBindGroup(0, bindGroup9);
} catch {}
try {
computePassEncoder24.setBindGroup(2, bindGroup16, new Uint32Array(114), 81, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup0, new Uint32Array(1250), 126, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer23, 'uint32', 220, 10);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture49,
  mipLevel: 1,
  origin: {x: 95, y: 0, z: 13},
  aspect: 'all',
}, new Uint8Array(110).fill(88), /* required buffer size: 110 */
{offset: 110}, {width: 15, height: 0, depthOrArrayLayers: 1});
} catch {}
let texture62 = device0.createTexture({
  size: [576, 1, 1],
  mipLevelCount: 10,
  format: 'rg16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder8.setBindGroup(0, bindGroup10);
} catch {}
try {
computePassEncoder11.setBindGroup(0, bindGroup6, new Uint32Array(16), 2, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder4.setBlendConstant({ r: 994.7, g: 149.8, b: -847.7, a: -0.5455, });
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 121,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let bindGroup25 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 79, resource: {buffer: buffer27, offset: 512, size: 676}}],
});
let commandEncoder48 = device0.createCommandEncoder();
let texture63 = device0.createTexture({
  size: [240, 1, 1],
  mipLevelCount: 5,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture64 = device0.createTexture({
  size: [72],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder13 = commandEncoder48.beginRenderPass({
  colorAttachments: [{
  view: textureView17,
  clearValue: { r: -428.6, g: 109.4, b: 390.7, a: -87.95, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder13.setIndexBuffer(buffer9, 'uint16', 860, 6_425);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(3, buffer7);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 1940, new BigUint64Array(14425), 1519, 88);
} catch {}
let texture65 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture66 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 13},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder7.setVertexBuffer(0, buffer26, 1_496);
} catch {}
let bindGroup26 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 28, resource: textureView28}]});
let buffer28 = device0.createBuffer({size: 15993, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder49 = device0.createCommandEncoder({});
let texture67 = device0.createTexture({
  size: {width: 240, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView61 = texture40.createView({mipLevelCount: 1});
let computePassEncoder37 = commandEncoder49.beginComputePass({});
try {
buffer27.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: imageBitmap0,
  origin: { x: 1, y: 1 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 10, y: 19, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 8, height: 5, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout25 = pipeline4.getBindGroupLayout(1);
let commandEncoder50 = device0.createCommandEncoder({});
let texture68 = device0.createTexture({
  size: [576, 1, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView62 = texture49.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 5, arrayLayerCount: 2});
let computePassEncoder38 = commandEncoder50.beginComputePass({});
try {
renderPassEncoder13.executeBundles([renderBundle0, renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder11.setScissorRect(316, 0, 6, 0);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture63,
  mipLevel: 3,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(273).fill(13), /* required buffer size: 273 */
{offset: 273, bytesPerRow: 162}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 57,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 277,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' },
    },
  ],
});
let autogeneratedBindGroupLayout26 = pipeline4.getBindGroupLayout(0);
let buffer29 = device0.createBuffer({
  size: 8418,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder51 = device0.createCommandEncoder({});
let textureView63 = texture68.createView({arrayLayerCount: 1});
let renderPassEncoder14 = commandEncoder51.beginRenderPass({
  colorAttachments: [{
  view: textureView6,
  depthSlice: 141,
  clearValue: { r: -189.7, g: 620.8, b: -429.8, a: 974.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet3,
});
let sampler30 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 18.39,
});
try {
renderPassEncoder1.setBindGroup(0, bindGroup3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: videoFrame6,
  origin: { x: 4, y: 13 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 8, y: 10, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 15, depthOrArrayLayers: 0});
} catch {}
let pipeline7 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 348,
        attributes: [
          {format: 'unorm8x4', offset: 8, shaderLocation: 9},
          {format: 'snorm16x2', offset: 12, shaderLocation: 0},
          {format: 'sint16x2', offset: 344, shaderLocation: 12},
          {format: 'snorm16x2', offset: 20, shaderLocation: 6},
          {format: 'uint32x2', offset: 36, shaderLocation: 14},
          {format: 'sint32x2', offset: 0, shaderLocation: 7},
          {format: 'unorm16x4', offset: 12, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front'},
});
try {
  await promise9;
} catch {}
let autogeneratedBindGroupLayout27 = pipeline1.getBindGroupLayout(1);
let bindGroup27 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout23,
  entries: [{binding: 79, resource: {buffer: buffer21, offset: 512}}],
});
let texture69 = device0.createTexture({
  size: [72, 1, 1],
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView64 = texture31.createView({
  label: '\u0a35\udd3c\ufbfd\u0ffd\u2da8\u0096\u7f4c\u{1ff13}\u{1ffec}\u7b8f',
  aspect: 'all',
  mipLevelCount: 1,
  baseArrayLayer: 2,
  arrayLayerCount: 3,
});
try {
computePassEncoder17.popDebugGroup();
} catch {}
let commandEncoder52 = device0.createCommandEncoder({});
let texture70 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 40},
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView65 = texture22.createView({dimension: '2d', baseArrayLayer: 8});
let renderPassEncoder15 = commandEncoder52.beginRenderPass({
  colorAttachments: [{
  view: textureView41,
  clearValue: { r: 575.0, g: 526.5, b: -715.6, a: 920.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup25);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(2, buffer23);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder53 = device0.createCommandEncoder({});
let texture71 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView66 = texture68.createView({});
let computePassEncoder39 = commandEncoder53.beginComputePass({});
try {
computePassEncoder38.setBindGroup(3, bindGroup7);
} catch {}
try {
renderPassEncoder15.setBindGroup(1, bindGroup11, new Uint32Array(1343), 809, 0);
} catch {}
document.body.prepend(canvas2);
let buffer30 = device0.createBuffer({
  size: 10309,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder54 = device0.createCommandEncoder({});
let texture72 = device0.createTexture({
  size: [2688, 1, 29],
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder16 = commandEncoder54.beginRenderPass({
  colorAttachments: [{
  view: textureView25,
  depthSlice: 155,
  clearValue: { r: 471.5, g: 707.3, b: 740.9, a: 54.14, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder10.setBindGroup(2, bindGroup8, new Uint32Array(818), 23, 0);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer19, 'uint16', 702, 2_470);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer1);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: imageData6,
  origin: { x: 1, y: 10 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 8, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture73 = device0.createTexture({
  size: [120, 1, 1],
  mipLevelCount: 4,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder31.setBindGroup(0, bindGroup7);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture74 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 7},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture75 = device0.createTexture({
  size: {width: 576},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let externalTexture3 = device0.importExternalTexture({source: videoFrame2});
try {
computePassEncoder23.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer1, 0);
} catch {}
let commandEncoder55 = device0.createCommandEncoder({});
let texture76 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 62},
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder40 = commandEncoder55.beginComputePass();
try {
renderPassEncoder4.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer8, 'uint16', 2_602, 1_798);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer21, 0, 52);
} catch {}
let bindGroup28 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout12,
  entries: [{binding: 79, resource: {buffer: buffer29, offset: 5376, size: 681}}],
});
let texture77 = device0.createTexture({
  size: [128, 128, 13],
  format: 'rgb9e5ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture78 = device0.createTexture({
  size: [72],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView67 = texture18.createView({mipLevelCount: 1, baseArrayLayer: 5, arrayLayerCount: 2});
try {
computePassEncoder12.setBindGroup(3, bindGroup0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer12, 'uint32', 1_040, 1_124);
} catch {}
let img0 = await imageWithData(60, 137, '#10101010', '#20202020');
let bindGroup29 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout22,
  entries: [{binding: 79, resource: {buffer: buffer1, offset: 3584, size: 861}}],
});
let commandEncoder56 = device0.createCommandEncoder();
let textureView68 = texture77.createView({dimension: 'cube'});
let textureView69 = texture53.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
let renderPassEncoder17 = commandEncoder56.beginRenderPass({
  colorAttachments: [{
  view: textureView52,
  clearValue: { r: -74.75, g: -297.6, b: -153.6, a: -638.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet3,
});
try {
computePassEncoder25.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder16.setBindGroup(1, bindGroup11, new Uint32Array(631), 35, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(5, buffer30, 0);
} catch {}
let bindGroup30 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 28, resource: textureView28}]});
let commandEncoder57 = device0.createCommandEncoder();
let querySet7 = device0.createQuerySet({type: 'occlusion', count: 460});
let textureView70 = texture22.createView({dimension: '2d', format: 'rgba8uint', baseArrayLayer: 4});
try {
renderPassEncoder15.setIndexBuffer(buffer0, 'uint16', 2_636, 29);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(7, buffer7, 0, 72);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
adapter0.label = '\u03cb\u021c\u2384\ud9fe\uf317\u0bb5\u9d60\u1cf6\u0d07\uefd2';
} catch {}
let computePassEncoder41 = commandEncoder57.beginComputePass({});
let sampler31 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  lodMaxClamp: 93.52,
});
try {
computePassEncoder35.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup2, new Uint32Array(6326), 131, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle5, renderBundle5, renderBundle5]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint32', 264, 100);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 76, new Float32Array(18250), 157, 4);
} catch {}
let buffer31 = device0.createBuffer({
  size: 656,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
try {
renderPassEncoder6.setBindGroup(3, bindGroup15);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(1, buffer25);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: imageData8,
  origin: { x: 3, y: 1 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 6, y: 8, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 16, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
  await promise8;
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup25);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer8, 'uint16', 5_678, 5_533);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline5);
} catch {}
let autogeneratedBindGroupLayout28 = pipeline5.getBindGroupLayout(0);
let commandEncoder58 = device0.createCommandEncoder({});
let externalTexture4 = device0.importExternalTexture({source: videoFrame5, colorSpace: 'srgb'});
try {
computePassEncoder40.setBindGroup(1, bindGroup29);
} catch {}
try {
computePassEncoder19.setBindGroup(1, bindGroup11, new Uint32Array(4286), 184, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer21, 'uint32', 456, 1_347);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder59 = device0.createCommandEncoder({});
let texture79 = device0.createTexture({
  size: [144, 1, 47],
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView71 = texture47.createView({});
let renderPassEncoder18 = commandEncoder58.beginRenderPass({
  colorAttachments: [{view: textureView21, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet6,
});
try {
computePassEncoder35.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup2, new Uint32Array(2233), 340, 0);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(3, undefined, 1_012_715_505, 2_124_073_842);
} catch {}
try {
commandEncoder59.copyTextureToTexture({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 58, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture40,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 12},
  aspect: 'all',
},
{width: 51, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture49,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 7},
  aspect: 'all',
}, new Uint8Array(4_024).fill(205), /* required buffer size: 4_024 */
{offset: 394, bytesPerRow: 55, rowsPerImage: 11}, {width: 4, height: 0, depthOrArrayLayers: 7});
} catch {}
let autogeneratedBindGroupLayout29 = pipeline1.getBindGroupLayout(0);
let bindGroup31 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout17,
  entries: [{binding: 79, resource: {buffer: buffer12, offset: 1792, size: 1331}}],
});
let buffer32 = device0.createBuffer({size: 18910, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture80 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 146},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView72 = texture62.createView({mipLevelCount: 1});
let computePassEncoder42 = commandEncoder59.beginComputePass({});
try {
computePassEncoder34.setBindGroup(3, bindGroup26, new Uint32Array(1741), 330, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer18, 'uint16', 176, 55);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 3},
  aspect: 'all',
}, new Uint8Array(5_749).fill(100), /* required buffer size: 5_749 */
{offset: 272, bytesPerRow: 45, rowsPerImage: 25}, {width: 4, height: 22, depthOrArrayLayers: 5});
} catch {}
await gc();
let commandEncoder60 = device0.createCommandEncoder({});
let computePassEncoder43 = commandEncoder60.beginComputePass();
let sampler32 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'mirror-repeat', lodMaxClamp: 99.63});
try {
renderPassEncoder1.setIndexBuffer(buffer7, 'uint16', 450, 123);
} catch {}
let commandEncoder61 = device0.createCommandEncoder({});
let renderPassEncoder19 = commandEncoder61.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  depthSlice: 75,
  clearValue: { r: -190.6, g: -712.4, b: 853.9, a: 121.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet6,
  maxDrawCount: 303060857,
});
let sampler33 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 81.95,
  lodMaxClamp: 87.04,
  maxAnisotropy: 1,
});
try {
renderPassEncoder12.setBindGroup(2, bindGroup23);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder17.setBlendConstant({ r: -141.7, g: 669.4, b: 93.92, a: 301.1, });
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline4);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture71,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(60).fill(200), /* required buffer size: 60 */
{offset: 60}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(img0);
let textureView73 = texture77.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 6});
try {
renderPassEncoder4.setBindGroup(2, bindGroup13);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
await gc();
let commandEncoder62 = device0.createCommandEncoder({});
let texture81 = device0.createTexture({
  size: [30, 1, 45],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder42.setBindGroup(0, bindGroup31);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle4, renderBundle2, renderBundle4, renderBundle4]);
} catch {}
try {
commandEncoder62.copyTextureToTexture({
  texture: texture49,
  mipLevel: 0,
  origin: {x: 192, y: 0, z: 13},
  aspect: 'all',
},
{
  texture: texture49,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 27, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder62.clearBuffer(buffer17, 7048, 284);
} catch {}
let texture82 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 256},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder44 = commandEncoder62.beginComputePass({});
let sampler34 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.25,
  maxAnisotropy: 16,
});
try {
computePassEncoder26.setBindGroup(2, bindGroup4);
} catch {}
try {
computePassEncoder43.setBindGroup(2, bindGroup6, new Uint32Array(5098), 1_332, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup13, new Uint32Array(2670), 274, 0);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
try {
globalThis.someLabel = textureView38.label;
} catch {}
let autogeneratedBindGroupLayout30 = pipeline4.getBindGroupLayout(0);
let sampler35 = device0.createSampler({addressModeW: 'repeat', minFilter: 'nearest'});
try {
computePassEncoder3.setBindGroup(0, bindGroup30);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup16, new Uint32Array(1946), 93, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer30);
} catch {}
let texture83 = device0.createTexture({
  size: [120],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder35.setBindGroup(3, bindGroup14);
} catch {}
try {
computePassEncoder15.end();
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer8);
} catch {}
try {
commandEncoder16.copyBufferToTexture({
  /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2676 */
  offset: 2676,
  bytesPerRow: 4608,
  buffer: buffer16,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer33 = device0.createBuffer({
  label: '\u0210\u0554\u{1fa59}\u{1ffba}\uaa3d\u{1fa41}\ubf03',
  size: 3651,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder63 = device0.createCommandEncoder({label: '\u0dd0\u2b0d\uc95e\ua9ad\u{1fbed}\ub856\u084f'});
let texture84 = device0.createTexture({
  size: {width: 672},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let textureView74 = texture0.createView({});
let commandEncoder64 = device0.createCommandEncoder({});
let textureView75 = texture66.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 1});
try {
renderPassEncoder4.setBindGroup(2, bindGroup12, new Uint32Array(140), 14, 0);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer0, 'uint16', 1_140, 708);
} catch {}
try {
computePassEncoder30.pushDebugGroup('\u44b4');
} catch {}
let computePassEncoder45 = commandEncoder64.beginComputePass({});
try {
computePassEncoder4.setBindGroup(0, bindGroup3);
} catch {}
try {
computePassEncoder38.setBindGroup(0, bindGroup11, new Uint32Array(4114), 1_585, 0);
} catch {}
try {
computePassEncoder30.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture26,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(0).fill(97), /* required buffer size: 0 */
{offset: 0, rowsPerImage: 20}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let imageData11 = new ImageData(84, 32);
let commandEncoder65 = device0.createCommandEncoder();
let commandBuffer0 = commandEncoder16.finish({});
let computePassEncoder46 = commandEncoder65.beginComputePass({});
let sampler36 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.72,
  compare: 'less',
  maxAnisotropy: 4,
});
try {
renderPassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer25, 0, 1_180);
} catch {}
try {
commandEncoder63.copyTextureToTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 47},
  aspect: 'all',
},
{
  texture: texture55,
  mipLevel: 0,
  origin: {x: 23, y: 47, z: 0},
  aspect: 'all',
},
{width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas2);
let autogeneratedBindGroupLayout31 = pipeline0.getBindGroupLayout(0);
let textureView76 = texture51.createView({dimension: '2d'});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({
  label: '\ue9d4\u{1fe98}\u06a3\u79cd\uef6f\u{1f896}\uc2ed\ua54f\ud299\u04ad',
  colorFormats: ['rgba8uint'],
  stencilReadOnly: true,
});
try {
computePassEncoder27.setBindGroup(1, bindGroup31);
} catch {}
try {
computePassEncoder32.setBindGroup(1, bindGroup13, new Uint32Array(1913), 161, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup29, new Uint32Array(242), 4, 0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle5, renderBundle5]);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(4, buffer21, 0, 1_603);
} catch {}
try {
renderPassEncoder8.insertDebugMarker('\u882e');
} catch {}
let buffer34 = device0.createBuffer({size: 2031, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView77 = texture18.createView({baseArrayLayer: 9, arrayLayerCount: 1});
let computePassEncoder47 = commandEncoder63.beginComputePass();
try {
renderPassEncoder2.setBindGroup(3, bindGroup30, new Uint32Array(351), 39, 0);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle1, renderBundle1]);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(2, buffer30, 2_040);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(30);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer17, 808, new Int16Array(755), 42, 220);
} catch {}
let bindGroup32 = device0.createBindGroup({
  label: '\u{1fbc7}\u8c38\u397b\u{1fed6}\u0943\ub995\u{1ff1a}\u2fb4\uc97d\u609b',
  layout: autogeneratedBindGroupLayout13,
  entries: [
    {binding: 125, resource: textureView7},
    {binding: 79, resource: {buffer: buffer5, offset: 512, size: 681}},
  ],
});
let texture85 = device0.createTexture({
  size: [576],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32float'],
});
let textureView78 = texture30.createView({format: 'rgba8uint'});
try {
renderPassEncoder14.setViewport(11.003258096423451, 0.8530988515355988, 0.5134407475208328, 0.06326103542414174, 0.415938121710437, 0.6399019963983303);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer23, 'uint16', 106, 48);
} catch {}
let texture86 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler37 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat'});
try {
computePassEncoder18.setBindGroup(2, bindGroup9, new Uint32Array(1566), 559, 0);
} catch {}
try {
computePassEncoder34.end();
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer26, 'uint16', 452, 1_057);
} catch {}
let buffer35 = device0.createBuffer({
  size: 3874,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let computePassEncoder48 = commandEncoder45.beginComputePass({});
let sampler38 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 12.89,
  maxAnisotropy: 10,
});
try {
computePassEncoder46.setBindGroup(3, bindGroup3);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
computePassEncoder18.setBindGroup(0, bindGroup15, new Uint32Array(2872), 941, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup6, new Uint32Array(469), 95, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer8, 'uint32', 3_376, 2_546);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer32, 624, 461);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup10, new Uint32Array(484), 70, 0);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer7, 'uint32', 204, 17);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(3, buffer26, 452);
} catch {}
let texture87 = device0.createTexture({
  size: [672, 1, 9],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView79 = texture57.createView({});
try {
renderPassEncoder2.setBindGroup(1, bindGroup4, []);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer7, 'uint32', 416, 195);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer7, 'uint32', 120, 109);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
document.body.prepend(img0);
let bindGroup33 = device0.createBindGroup({
  label: '\u000a\u007e\u{1f72e}\u{1f6ef}\u{1f60a}\u897a\u{1f858}',
  layout: autogeneratedBindGroupLayout26,
  entries: [{binding: 125, resource: textureView2}, {binding: 79, resource: {buffer: buffer7, offset: 0}}],
});
let commandEncoder66 = device0.createCommandEncoder();
try {
computePassEncoder13.setBindGroup(0, bindGroup23);
} catch {}
try {
computePassEncoder18.setBindGroup(1, bindGroup15, new Uint32Array(1390), 374, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(2069), 1_250, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(0, buffer32, 3_348);
} catch {}
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 448 widthInBlocks: 112 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2440 */
  offset: 2440,
  buffer: buffer6,
}, {width: 112, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture88 = device0.createTexture({
  size: [60, 1, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder49 = commandEncoder66.beginComputePass();
let sampler39 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 19,
});
try {
renderPassEncoder18.executeBundles([renderBundle5, renderBundle5, renderBundle5, renderBundle5]);
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer32);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup29);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(7, buffer26, 1_968, 1_988);
} catch {}
try {
buffer28.unmap();
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture71,
  mipLevel: 1,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
try {
globalThis.someLabel = device0.label;
} catch {}
let texture89 = device0.createTexture({
  size: {width: 672, height: 1, depthOrArrayLayers: 35},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture90 = device0.createTexture({
  size: [144, 1, 135],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle6 = renderBundleEncoder6.finish({});
try {
renderPassEncoder7.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let texture91 = device0.createTexture({
  size: [72],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder50 = commandEncoder67.beginComputePass({label: '\u78b3\u14a3\u52af\u42fa\u{1f9a7}\u7d6a\u{1fcad}\u2f8a\u0e3e'});
try {
renderPassEncoder4.setIndexBuffer(buffer26, 'uint32', 3_724, 2_818);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(3, buffer1, 12, 214);
} catch {}
let bindGroup34 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout9,
  entries: [
    {binding: 125, resource: textureView7},
    {binding: 79, resource: {buffer: buffer12, offset: 4352, size: 535}},
  ],
});
let commandEncoder68 = device0.createCommandEncoder({label: '\u0e22\u5e2e\u71df\u09b4\u{1f9ee}\u090e\u08c2'});
let texture92 = device0.createTexture({
  size: {width: 576},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder13.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder17.setBindGroup(0, bindGroup9, new Uint32Array(510), 510, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup7, new Uint32Array(506), 25, 0);
} catch {}
let bindGroup35 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout22,
  entries: [{binding: 79, resource: {buffer: buffer7, offset: 256}}],
});
let textureView80 = texture92.createView({});
let computePassEncoder51 = commandEncoder68.beginComputePass({});
let sampler40 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  compare: 'equal',
});
try {
computePassEncoder11.setBindGroup(3, bindGroup30);
} catch {}
try {
computePassEncoder17.setBindGroup(0, bindGroup5, new Uint32Array(897), 16, 0);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup3, new Uint32Array(2181), 108, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline5);
} catch {}
let bindGroup36 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout29,
  entries: [
    {binding: 79, resource: {buffer: buffer9, offset: 0, size: 259}},
    {binding: 125, resource: textureView7},
  ],
});
let buffer36 = device0.createBuffer({
  size: 6039,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder69 = device0.createCommandEncoder({});
let textureView81 = texture51.createView({dimension: '2d-array'});
let texture93 = device0.createTexture({
  size: [30, 1, 6],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder52 = commandEncoder69.beginComputePass({});
let sampler41 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 79.00,
  maxAnisotropy: 10,
});
try {
renderPassEncoder10.setIndexBuffer(buffer12, 'uint32', 752, 5_056);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let canvas3 = document.createElement('canvas');
let bindGroup37 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 79, resource: {buffer: buffer29, offset: 0, size: 4298}}],
});
let texture94 = device0.createTexture({
  size: [30, 1, 1],
  mipLevelCount: 1,
  sampleCount: 4,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture95 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 56},
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView82 = texture72.createView({dimension: '2d', baseArrayLayer: 5});
try {
renderPassEncoder6.setBindGroup(0, bindGroup24);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup1, new Uint32Array(4172), 215, 0);
} catch {}
try {
renderPassEncoder17.setBlendConstant({ r: -619.3, g: -251.3, b: 250.0, a: -71.74, });
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer23, 'uint16', 2, 58);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline5);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView83 = texture51.createView({dimension: '2d-array'});
try {
renderPassEncoder8.setVertexBuffer(6, buffer7, 16);
} catch {}
try {
  await promise11;
} catch {}
let commandEncoder70 = device0.createCommandEncoder({});
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 863});
let textureView84 = texture91.createView({});
let computePassEncoder53 = commandEncoder70.beginComputePass({});
let sampler42 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat'});
try {
renderPassEncoder17.setBindGroup(0, bindGroup14);
} catch {}
let pipeline8 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  constants: {},
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 80,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 8},
          {format: 'sint16x2', offset: 4, shaderLocation: 7},
          {format: 'snorm16x2', offset: 0, shaderLocation: 0},
          {format: 'float32x2', offset: 12, shaderLocation: 6},
          {format: 'float16x2', offset: 0, shaderLocation: 9},
          {format: 'sint32x3', offset: 4, shaderLocation: 12},
          {format: 'uint32x4', offset: 0, shaderLocation: 14},
        ],
      },
    ],
  },
});
let bindGroup38 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 36, resource: textureView2}]});
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout3]});
let buffer37 = device0.createBuffer({size: 6546, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder71 = device0.createCommandEncoder({});
let texture96 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture97 = device0.createTexture({size: [288, 1, 40], format: 'rg32float', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder54 = commandEncoder71.beginComputePass({});
try {
computePassEncoder52.setBindGroup(3, bindGroup19);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer37, 180, 3_736);
} catch {}
try {
device0.queue.writeBuffer(buffer6, 32, new Float32Array(6544), 2421, 60);
} catch {}
let autogeneratedBindGroupLayout32 = pipeline4.getBindGroupLayout(1);
let commandEncoder72 = device0.createCommandEncoder({});
let textureView85 = texture89.createView({dimension: '2d'});
let textureView86 = texture49.createView({mipLevelCount: 1, arrayLayerCount: 5});
let renderPassEncoder20 = commandEncoder72.beginRenderPass({
  colorAttachments: [{
  view: textureView74,
  depthSlice: 129,
  clearValue: { r: 543.9, g: -95.47, b: -406.3, a: -431.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet8,
  maxDrawCount: 95129426,
});
let sampler43 = device0.createSampler({
  label: '\u6585\ud7ab\u062d\u03c3\u0108\u{1fb13}\ue91c\u0093\u{1f652}',
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 68.06,
  lodMaxClamp: 96.40,
});
try {
computePassEncoder0.setBindGroup(0, bindGroup4, new Uint32Array(1818), 100, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer26, 2_252, 5_879);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let autogeneratedBindGroupLayout33 = pipeline1.getBindGroupLayout(0);
let textureView87 = texture89.createView({dimension: '2d', baseArrayLayer: 9});
let textureView88 = texture97.createView({mipLevelCount: 1, baseArrayLayer: 24, arrayLayerCount: 3});
let sampler44 = device0.createSampler({addressModeV: 'mirror-repeat', lodMaxClamp: 85.61});
try {
computePassEncoder13.setBindGroup(1, bindGroup24, new Uint32Array(4007), 95, 0);
} catch {}
try {
buffer21.unmap();
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas3);
await gc();
try {
canvas3.getContext('bitmaprenderer');
} catch {}
let commandEncoder73 = device0.createCommandEncoder({});
let textureView89 = texture96.createView({mipLevelCount: 1});
let textureView90 = texture49.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 11});
try {
computePassEncoder8.setBindGroup(1, bindGroup26, []);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup24, new Uint32Array(2213), 17, 0);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle3]);
} catch {}
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'unspecified', transfer: 'unspecified'} });
let videoFrame8 = new VideoFrame(canvas0, {timestamp: 0});
let textureView91 = texture94.createView({});
let texture98 = device0.createTexture({
  size: [240, 1, 38],
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder55 = commandEncoder73.beginComputePass({});
try {
renderPassEncoder9.setBindGroup(0, bindGroup20);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup14, new Uint32Array(726), 309, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(6, buffer8, 5_792, 7_676);
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(3, 297);
let bindGroup39 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 28, resource: textureView74}]});
try {
computePassEncoder4.setBindGroup(0, bindGroup34, new Uint32Array(984), 16, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 156, new DataView(new ArrayBuffer(9874)), 108, 616);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 23}
*/
{
  source: imageData6,
  origin: { x: 0, y: 13 },
  flipY: true,
}, {
  texture: texture79,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 4},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext1 = offscreenCanvas1.getContext('webgpu');
let buffer38 = device0.createBuffer({
  size: 5038,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder74 = device0.createCommandEncoder();
let commandBuffer1 = commandEncoder74.finish();
let sampler45 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 90.89,
  maxAnisotropy: 6,
});
try {
renderPassEncoder9.setViewport(9.934370545826681, 0.44468922701402624, 6.2672752262443225, 0.2501328932054025, 0.6851005351083859, 0.9180225807625684);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 240, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData11,
  origin: { x: 4, y: 7 },
  flipY: true,
}, {
  texture: texture63,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

requires pointer_composite_access;

enable f16;

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

@id(35636) override override9: u32;

struct S4 {
  @location(2) f0: vec2u,
  @location(0) @interpolate(perspective, centroid) f1: vec4h,
}

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

override override6 = true;

var<workgroup> vw10: atomic<i32>;

alias vec3b = vec3<bool>;

override override14: i32 = 327;

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

override override7: u32 = 149;

@id(2247) override override4: f16;

struct T0 {
  @size(16) f0: array<vec2i, 1>,
  f1: vec4u,
  @size(88) f2: mat3x3h,
}

struct S3 {
  @location(6) f0: vec2i,
  @location(8) @interpolate(flat, center) f1: i32,
  @location(10) f2: vec4h,
  @location(7) @interpolate(flat) f3: i32,
  @location(9) @interpolate(flat, centroid) f4: vec4u,
  @location(12) @interpolate(flat, sample) f5: vec2i,
  @location(3) @interpolate(flat) f6: f32,
  @location(14) @interpolate(flat, sample) f7: f32,
  @location(5) f8: vec4u,
}

override override16: i32 = 79;

override override15: u32 = 4;

@group(0) @binding(73) var<storage, read_write> buffer39: array<vec2f>;

var<private> vp0: vec2h = vec2h(7893.0, 27520.0);

struct S2 {
  @location(13) @interpolate(flat, sample) f0: vec2u,
  @location(15) @interpolate(flat) f1: vec4u,
  @location(1) @interpolate(flat, sample) f2: f16,
  @builtin(instance_index) f3: u32,
}

var<private> vp2: S4 = S4(vec2u(174, 127), vec4h(14844.7, 5642.6, 3420.1, 1851.0));

@id(29253) override override13: u32 = 31;

@id(53221) override override1: u32;

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

override override3 = 0.06155;

@id(13825) override override10: f32;

var<private> vp1 = array(modf(vec4h(2460.4, 9137.4, 27086.0, 16904.9)));

@id(23698) override override8 = 0.08399;

@id(37465) override override5 = true;

@id(21537) override override11: u32;

@id(9192) override override0 = 0.1575;

override override2: i32 = 350;

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

@id(59214) override override12: i32;

@vertex
fn vertex1(a0: S2, @builtin(vertex_index) a1: u32, a2: S3, a3: S4, @location(4) @interpolate(linear) a4: vec2f, @location(11) a5: f32) -> @builtin(position) vec4f {
  var out: vec4f;
  let vf19: u32 = override11;
  vp2 = S4(bitcast<vec2u>(a2.f2), a2.f2);
  return out;
  _ = override11;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
  atomicSub(&vw10, i32(unconst_i32(75)));
  let ptr15: ptr<storage, array<vec2f>, read_write> = &buffer39;
  let vf20: f32 = buffer39[arrayLength(&buffer39)][u32(unconst_u32(233))];
  let vf21: f16 = vp0[u32(unconst_u32(21))];
  var vf22: vec2i = countOneBits(vec2i(unconst_i32(323), unconst_i32(31)));
  let ptr16: ptr<private, vec4h> = &vp1[u32(unconst_u32(59))].whole;
  let vf23: u32 = override7;
  var vf24: i32 = override14;
  let vf25: bool = any(bool(unconst_bool(true)));
  var vf26: vec4h = fma(vec4h(unconst_f16(8431.2), unconst_f16(11395.0), unconst_f16(21975.9), unconst_f16(1063.3)), vec4h(unconst_f16(959.7), unconst_f16(5166.2), unconst_f16(2178.2), unconst_f16(11038.0)), vec4h(unconst_f16(6384.2), unconst_f16(56758.9), unconst_f16(10101.5), unconst_f16(6846.1)));
  let ptr17: ptr<storage, vec2f, read_write> = &(*ptr15)[u32(unconst_u32(0))];
  vp1[u32(unconst_u32(28))].whole += vec4h(f16(vf24));
  _ = override14;
  _ = override7;
  _ = buffer39;
}`,
});
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout8, veryExplicitBindGroupLayout9]});
let buffer40 = device0.createBuffer({
  size: 7839,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView92 = texture88.createView({baseMipLevel: 0});
try {
computePassEncoder3.setBindGroup(0, bindGroup2);
} catch {}
try {
computePassEncoder9.setBindGroup(1, bindGroup6, new Uint32Array(1927), 184, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
  await promise10;
} catch {}
let autogeneratedBindGroupLayout34 = pipeline5.getBindGroupLayout(1);
let sampler46 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 73.83,
  maxAnisotropy: 1,
});
try {
computePassEncoder38.setBindGroup(1, bindGroup15);
} catch {}
try {
computePassEncoder44.setBindGroup(0, bindGroup31, new Uint32Array(5777), 1_220, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup32);
} catch {}
try {
renderPassEncoder18.setBlendConstant({ r: 729.3, g: 996.2, b: -168.6, a: 302.1, });
} catch {}
try {
device0.queue.writeBuffer(buffer29, 4520, new Int16Array(21556), 20145, 544);
} catch {}
let imageBitmap1 = await createImageBitmap(imageData6);
let buffer41 = device0.createBuffer({size: 10173, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder75 = device0.createCommandEncoder({});
let computePassEncoder56 = commandEncoder75.beginComputePass({});
try {
computePassEncoder31.setBindGroup(2, bindGroup13, new Uint32Array(848), 59, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup1, new Uint32Array(322), 34, 0);
} catch {}
try {
renderPassEncoder4.setScissorRect(4, 0, 30, 0);
} catch {}
try {
renderPassEncoder14.setViewport(18.14209177150367, 0.8240244055161561, 8.703736107281715, 0.0025089689759068296, 0.913125363951738, 0.9620550871672223);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer18, 'uint32', 532, 282);
} catch {}
let texture99 = device0.createTexture({
  size: [72, 1, 621],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder16.setBindGroup(0, bindGroup36, new Uint32Array(307), 13, 0);
} catch {}
try {
renderPassEncoder10.setScissorRect(60, 7, 2, 4);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer29, 'uint32', 32, 690);
} catch {}
try {
texture28.destroy();
} catch {}
try {
buffer13.unmap();
} catch {}
let bindGroup40 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout26,
  entries: [{binding: 79, resource: {buffer: buffer21, offset: 512}}, {binding: 125, resource: textureView7}],
});
let texture100 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 54},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView93 = texture96.createView({aspect: 'all', mipLevelCount: 1});
try {
renderPassEncoder9.setIndexBuffer(buffer31, 'uint32', 56, 18);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, undefined, 0, 1_090_982_548);
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup36, new Uint32Array(1786), 107, 0);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle4, renderBundle1, renderBundle1, renderBundle4, renderBundle2, renderBundle3]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer16, 'uint16', 14, 119);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline2);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer21.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroup41 = device0.createBindGroup({
  label: '\ubde3\uf266\u2834\uc7cc\u6c65\u7442\u4e55\ub36a',
  layout: veryExplicitBindGroupLayout6,
  entries: [{binding: 36, resource: textureView49}],
});
try {
renderPassEncoder9.setBindGroup(1, bindGroup31, new Uint32Array(9917), 1_642, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer31, 'uint32', 156, 112);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer25, 1_120, 290);
} catch {}
document.body.prepend(canvas2);
let imageData12 = new ImageData(4, 20);
let buffer42 = device0.createBuffer({
  size: 2347,
  usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder76 = device0.createCommandEncoder();
let textureView94 = texture64.createView({aspect: 'all'});
let texture101 = gpuCanvasContext0.getCurrentTexture();
let textureView95 = texture13.createView({});
let computePassEncoder57 = commandEncoder76.beginComputePass({});
let sampler47 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 66.86,
  maxAnisotropy: 1,
});
try {
computePassEncoder13.setBindGroup(0, bindGroup25);
} catch {}
try {
computePassEncoder4.setBindGroup(3, bindGroup20, new Uint32Array(592), 102, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer6, 24, new BigUint64Array(1952), 65, 296);
} catch {}
let autogeneratedBindGroupLayout35 = pipeline4.getBindGroupLayout(0);
let bindGroup42 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout18,
  entries: [{binding: 125, resource: textureView49}, {binding: 79, resource: {buffer: buffer19, offset: 1024}}],
});
let buffer43 = device0.createBuffer({label: '\ub689\u7eac', size: 11125, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture102 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder57.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle2]);
} catch {}
document.body.prepend(img0);
let texture103 = gpuCanvasContext1.getCurrentTexture();
try {
computePassEncoder11.setBindGroup(2, bindGroup13);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer7, 0);
} catch {}
try {
buffer16.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture69,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(21).fill(225), /* required buffer size: 21 */
{offset: 21}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 57,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 277,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' },
    },
  ],
});
let autogeneratedBindGroupLayout36 = pipeline6.getBindGroupLayout(0);
let commandEncoder77 = device0.createCommandEncoder();
let texture104 = device0.createTexture({
  size: [128, 128, 13],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView96 = texture54.createView({mipLevelCount: 1});
try {
renderPassEncoder5.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer42, 0, 270);
} catch {}
try {
commandEncoder77.copyBufferToBuffer(buffer8, 7768, buffer15, 72, 304);
} catch {}
try {
commandEncoder77.copyTextureToTexture({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 19},
  aspect: 'all',
},
{
  texture: texture27,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
},
{width: 56, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer5, 684, new Float32Array(2260), 306, 8);
} catch {}
try {
  await promise15;
} catch {}
let commandBuffer2 = commandEncoder77.finish({});
let texture105 = device0.createTexture({size: [30, 1, 76], dimension: '3d', format: 'rgba8uint', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder20.setBindGroup(0, bindGroup32, new Uint32Array(1547), 276, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup36, new Uint32Array(1072), 114, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline7);
} catch {}
document.body.append(canvas0);
try {
computePassEncoder39.setBindGroup(1, bindGroup38, new Uint32Array(1792), 3, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
document.body.append(img0);
try {
globalThis.someLabel = device0.label;
} catch {}
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 8, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 12,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 13, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 14, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {
      binding: 17,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 23,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 27,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {binding: 28, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 29, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 32, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
    {binding: 34, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 35, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }},
    {
      binding: 36,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true },
    },
    {binding: 37, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 38, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 39,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 42,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 47,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 58, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 63, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 64,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 67,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 68, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }},
    {
      binding: 69,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {
      binding: 70,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 72, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 76,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 86, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 91, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }},
    {binding: 92, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 100,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 101,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 104, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {binding: 105, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 106,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 109,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 111,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 113, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 118, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 123,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 124,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 131,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 136,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {binding: 143, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 147,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 148,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 149,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 151,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 152,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 155,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 161, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 167, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 172,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {binding: 175, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {
      binding: 191,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 206,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 211, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 215, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 221,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 235,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 237,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 239, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 251,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 259, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 264, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 281,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', minBindingSize: 41, hasDynamicOffset: false },
    },
    {
      binding: 282,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {binding: 308, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 329,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {
      binding: 331,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 398, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 408,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 410,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 539, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 545, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 569, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 580,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 672, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 755,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
    {
      binding: 851,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup43 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout30,
  entries: [
    {binding: 79, resource: {buffer: buffer30, offset: 256, size: 1063}},
    {binding: 125, resource: textureView2},
  ],
});
let textureView97 = texture91.createView({dimension: '1d'});
let texture106 = device0.createTexture({
  size: {width: 128},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderPassEncoder20.setBindGroup(2, bindGroup34, new Uint32Array(286), 91, 0);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(2, buffer21, 1_948, 551);
} catch {}
let imageData13 = new ImageData(28, 12);
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 1466});
try {
computePassEncoder9.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder10.setScissorRect(1, 68, 12, 0);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(5, buffer42, 264);
} catch {}
try {
device0.queue.writeBuffer(buffer6, 3492, new Float32Array(9591), 2531, 4);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let autogeneratedBindGroupLayout37 = pipeline5.getBindGroupLayout(1);
let commandEncoder78 = device0.createCommandEncoder({});
let renderPassEncoder21 = commandEncoder78.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: -989.5, g: -221.1, b: -946.4, a: 797.0, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder12.setBindGroup(0, bindGroup14, new Uint32Array(94), 0, 0);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer7);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: imageData2,
  origin: { x: 0, y: 75 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 6},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let buffer44 = device0.createBuffer({
  size: 19112,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture107 = device0.createTexture({
  size: [288, 1, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture108 = gpuCanvasContext1.getCurrentTexture();
let textureView98 = texture59.createView({dimension: '2d-array', baseMipLevel: 0});
try {
computePassEncoder47.setBindGroup(1, bindGroup31, new Uint32Array(543), 104, 0);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(58);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer27, 'uint32', 1_000, 463);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline3);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
autogeneratedBindGroupLayout7.label = '\uacd9\u9b51\u{1ff5c}\u0588\u3068\u814a';
} catch {}
let autogeneratedBindGroupLayout38 = pipeline1.getBindGroupLayout(1);
let bindGroup44 = device0.createBindGroup({layout: veryExplicitBindGroupLayout9, entries: [{binding: 352, resource: textureView87}]});
let texture109 = device0.createTexture({
  size: [120, 1, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView99 = texture32.createView({baseArrayLayer: 8, arrayLayerCount: 1});
let sampler48 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
});
let externalTexture5 = device0.importExternalTexture({label: '\u182b\uc6ca\u06ba', source: videoFrame2});
try {
renderPassEncoder15.setVertexBuffer(5, buffer8);
} catch {}
let pipeline9 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute0'}});
let bindGroup45 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout25,
  entries: [{binding: 79, resource: {buffer: buffer42, offset: 512, size: 228}}],
});
try {
renderPassEncoder0.executeBundles([renderBundle2, renderBundle1, renderBundle2, renderBundle4, renderBundle2]);
} catch {}
let commandEncoder79 = device0.createCommandEncoder({});
let texture110 = device0.createTexture({
  size: {width: 240, height: 1, depthOrArrayLayers: 4},
  mipLevelCount: 1,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder58 = commandEncoder79.beginComputePass({});
try {
computePassEncoder10.setBindGroup(3, bindGroup45);
} catch {}
try {
computePassEncoder38.setPipeline(pipeline9);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup44);
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\ua4c2');
} catch {}
let commandEncoder80 = device0.createCommandEncoder({});
let computePassEncoder59 = commandEncoder80.beginComputePass({});
let sampler49 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 85.75,
});
try {
computePassEncoder57.setBindGroup(3, bindGroup14);
} catch {}
try {
computePassEncoder6.setBindGroup(1, bindGroup38, new Uint32Array(736), 62, 0);
} catch {}
try {
computePassEncoder49.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup37, new Uint32Array(628), 87, 0);
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(6);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 79,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 125,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 127,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup46 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout35,
  entries: [
    {binding: 125, resource: textureView49},
    {binding: 79, resource: {buffer: buffer37, offset: 0, size: 970}},
  ],
});
let commandEncoder81 = device0.createCommandEncoder({});
let textureView100 = texture88.createView({dimension: '2d', mipLevelCount: 1});
let textureView101 = texture57.createView({});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder22.setBindGroup(1, bindGroup13);
} catch {}
try {
computePassEncoder12.setBindGroup(0, bindGroup19, new Uint32Array(877), 348, 0);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup38);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup9, []);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'iec6196624'} });
let bindGroup47 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout20,
  entries: [{binding: 79, resource: {buffer: buffer35, offset: 768, size: 354}}],
});
let commandEncoder82 = device0.createCommandEncoder({});
let computePassEncoder60 = commandEncoder81.beginComputePass();
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg32float']});
let externalTexture6 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
computePassEncoder29.setBindGroup(0, bindGroup15, new Uint32Array(811), 55, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer19, 'uint32', 128, 7_218);
} catch {}
try {
commandEncoder82.copyBufferToBuffer(buffer23, 56, buffer13, 1152, 220);
} catch {}
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let bindGroup48 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout24,
  entries: [
    {binding: 125, resource: textureView49},
    {binding: 79, resource: {buffer: buffer37, offset: 1536, size: 294}},
  ],
});
let commandEncoder83 = device0.createCommandEncoder();
let texture111 = device0.createTexture({
  size: [288, 1, 13],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView102 = texture82.createView({baseArrayLayer: 13, arrayLayerCount: 5});
let renderPassEncoder22 = commandEncoder82.beginRenderPass({colorAttachments: [{view: textureView61, depthSlice: 40, loadOp: 'load', storeOp: 'store'}]});
let renderBundle7 = renderBundleEncoder8.finish({});
let sampler50 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 91.70});
try {
renderPassEncoder17.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder18.beginOcclusionQuery(6);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup9);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(0, buffer30, 1_488, 1_548);
} catch {}
try {
buffer38.unmap();
} catch {}
let pipeline10 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule0, entryPoint: 'fragment0', targets: [{format: 'rg32float'}]},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 116,
        attributes: [
          {format: 'unorm8x2', offset: 4, shaderLocation: 9},
          {format: 'sint32x2', offset: 0, shaderLocation: 12},
          {format: 'sint32x2', offset: 12, shaderLocation: 7},
          {format: 'uint32x2', offset: 28, shaderLocation: 14},
          {format: 'float16x4', offset: 20, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 24, shaderLocation: 0},
          {format: 'float32x3', offset: 8, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'back'},
});
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 313,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let computePassEncoder61 = commandEncoder83.beginComputePass({});
try {
computePassEncoder24.setBindGroup(2, bindGroup48);
} catch {}
try {
computePassEncoder55.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup15);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(2, undefined, 2_008_703_314, 496_483_457);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup20);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer21, 'uint32', 1_280, 2_501);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline2);
} catch {}
try {
  await promise12;
} catch {}
let buffer45 = device0.createBuffer({
  size: 35949,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView103 = texture48.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder1.setBindGroup(0, bindGroup37);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(5, buffer26);
} catch {}
document.body.append(img0);
let buffer46 = device0.createBuffer({size: 9028, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let sampler51 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 96.02});
try {
computePassEncoder20.setBindGroup(1, bindGroup41);
} catch {}
try {
renderPassEncoder18.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer36, 'uint32', 640, 866);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline1);
} catch {}
try {
buffer16.unmap();
} catch {}
let imageData14 = new ImageData(76, 100);
let commandEncoder84 = device0.createCommandEncoder({});
let textureView104 = texture58.createView({});
let computePassEncoder62 = commandEncoder84.beginComputePass({});
try {
computePassEncoder35.setBindGroup(2, bindGroup19);
} catch {}
try {
computePassEncoder40.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup33);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer27, 'uint16', 3_016, 773);
} 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',
  alphaMode: 'premultiplied',
});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let textureView105 = texture55.createView({label: '\ub4f9\u4409\u{1fe30}', dimension: 'cube-array', arrayLayerCount: 6});
try {
computePassEncoder28.setBindGroup(2, bindGroup24);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup9);
} catch {}
try {
renderPassEncoder16.end();
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(7, buffer38, 116, 53);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(65).fill(251), /* required buffer size: 65 */
{offset: 65}, {width: 210, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas2,
  origin: { x: 70, y: 5 },
  flipY: true,
}, {
  texture: texture63,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'jedecP22Phosphors', transfer: 'gamma22curve'} });
let buffer47 = device0.createBuffer({size: 16530, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder85 = device0.createCommandEncoder();
try {
renderPassEncoder5.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup33, new Uint32Array(2253), 179, 0);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(19);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer42, 0);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline3);
} catch {}
try {
commandEncoder85.copyBufferToBuffer(buffer27, 944, buffer20, 2144, 348);
} catch {}
try {
commandEncoder54.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2760 */
  offset: 2760,
  buffer: buffer30,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 193, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise14;
} catch {}
document.body.prepend(img0);
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt709', transfer: 'iec61966-2-1'} });
let autogeneratedBindGroupLayout39 = pipeline3.getBindGroupLayout(1);
let renderBundle8 = renderBundleEncoder7.finish({});
try {
computePassEncoder5.setBindGroup(1, bindGroup10);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(1, buffer45);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: imageData8,
  origin: { x: 21, y: 4 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 77, y: 24, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise13;
} catch {}
let buffer48 = device0.createBuffer({size: 949, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let textureView106 = texture78.createView({baseMipLevel: 0});
let computePassEncoder63 = commandEncoder54.beginComputePass({});
let renderPassEncoder23 = commandEncoder85.beginRenderPass({colorAttachments: [{view: textureView52, loadOp: 'clear', storeOp: 'discard'}]});
try {
computePassEncoder63.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
let buffer49 = device0.createBuffer({size: 32168, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder86 = device0.createCommandEncoder({});
let renderPassEncoder24 = commandEncoder86.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: 515.6, g: 752.1, b: -526.6, a: -527.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet1,
});
let sampler52 = device0.createSampler({addressModeV: 'mirror-repeat', lodMaxClamp: 66.52});
try {
computePassEncoder11.setBindGroup(3, bindGroup30);
} catch {}
try {
computePassEncoder10.setBindGroup(0, bindGroup19, new Uint32Array(231), 5, 0);
} catch {}
try {
computePassEncoder59.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup12, new Uint32Array(2699), 1_191, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 67}
*/
{
  source: imageData4,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture90,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture112 = device0.createTexture({
  size: [240, 1, 1],
  mipLevelCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView107 = texture11.createView({dimension: '1d'});
let sampler53 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat'});
try {
computePassEncoder10.setBindGroup(1, bindGroup28, new Uint32Array(4720), 742, 0);
} catch {}
try {
computePassEncoder26.setPipeline(pipeline9);
} catch {}
let autogeneratedBindGroupLayout40 = pipeline8.getBindGroupLayout(1);
let querySet10 = device0.createQuerySet({type: 'occlusion', count: 2823});
let texture113 = device0.createTexture({
  size: {width: 30},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture114 = gpuCanvasContext1.getCurrentTexture();
try {
computePassEncoder49.setBindGroup(3, bindGroup10);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder17.setVertexBuffer(6, buffer8, 3_912, 1_811);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas3);
let commandEncoder87 = device0.createCommandEncoder();
let renderPassEncoder25 = commandEncoder87.beginRenderPass({
  colorAttachments: [{
  view: textureView103,
  clearValue: { r: -169.6, g: -408.9, b: 687.6, a: 316.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 237830937,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup15, new Uint32Array(1788), 2, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup10);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 1, depthOrArrayLayers: 33}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture90,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 13},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let textureView108 = texture42.createView({aspect: 'all'});
try {
computePassEncoder17.setBindGroup(2, bindGroup1);
} catch {}
try {
computePassEncoder51.setBindGroup(0, bindGroup23, new Uint32Array(1247), 26, 0);
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer42);
} catch {}
let buffer50 = device0.createBuffer({size: 7293, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder88 = device0.createCommandEncoder({});
let querySet11 = device0.createQuerySet({type: 'occlusion', count: 836});
let computePassEncoder64 = commandEncoder88.beginComputePass({});
try {
computePassEncoder1.setBindGroup(2, bindGroup36);
} catch {}
try {
computePassEncoder58.setBindGroup(1, bindGroup11, new Uint32Array(2617), 891, 0);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
let bindGroup49 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout18,
  entries: [
    {binding: 79, resource: {buffer: buffer45, offset: 1280, size: 2648}},
    {binding: 125, resource: textureView7},
  ],
});
try {
computePassEncoder24.setBindGroup(0, bindGroup43);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline9);
} catch {}
let textureView109 = texture55.createView({dimension: 'cube-array', baseArrayLayer: 2, arrayLayerCount: 6});
let sampler54 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 70.65,
});
try {
computePassEncoder31.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer28, 'uint16', 2_620, 259);
} catch {}
let imageData15 = new ImageData(24, 8);
let buffer51 = device0.createBuffer({
  size: 7166,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView110 = texture90.createView({mipLevelCount: 1});
let videoFrame12 = new VideoFrame(offscreenCanvas1, {timestamp: 0});
let sampler55 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', minFilter: 'nearest', mipmapFilter: 'linear'});
try {
computePassEncoder60.setBindGroup(1, bindGroup6);
} catch {}
try {
computePassEncoder63.setBindGroup(0, bindGroup41, new Uint32Array(4149), 2_214, 0);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup32);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle8, renderBundle3]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 23}
*/
{
  source: imageData11,
  origin: { x: 28, y: 7 },
  flipY: false,
}, {
  texture: texture79,
  mipLevel: 1,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline11 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x2ae5f83},
  fragment: {
  module: shaderModule0,
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 280,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 24, shaderLocation: 9},
          {format: 'sint8x4', offset: 52, shaderLocation: 7},
          {format: 'float16x2', offset: 24, shaderLocation: 8},
          {format: 'float32x2', offset: 100, shaderLocation: 6},
          {format: 'snorm16x2', offset: 32, shaderLocation: 0},
          {format: 'uint32x4', offset: 12, shaderLocation: 14},
          {format: 'sint32x3', offset: 36, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
let bindGroup50 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout13,
  entries: [
    {binding: 79, resource: {buffer: buffer35, offset: 3840, size: 18}},
    {binding: 125, resource: textureView2},
  ],
});
let buffer52 = device0.createBuffer({
  size: 3197,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let externalTexture7 = device0.importExternalTexture({source: videoFrame9});
try {
computePassEncoder18.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup37, new Uint32Array(788), 1, 0);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer27, 'uint16', 3_908, 356);
} catch {}
try {
buffer52.unmap();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], stencilReadOnly: true});
try {
computePassEncoder36.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup19);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup2, new Uint32Array(57), 10, 0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup24);
} catch {}
let textureView111 = texture94.createView({format: 'rgba8uint'});
let texture115 = device0.createTexture({
  size: [672, 1, 46],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView112 = texture38.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder43.setPipeline(pipeline9);
} catch {}
try {
computePassEncoder42.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle7]);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer27, 'uint16', 932, 605);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup38, new Uint32Array(4750), 238, 0);
} catch {}
let bindGroup51 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout17,
  entries: [{binding: 79, resource: {buffer: buffer37, offset: 1792, size: 961}}],
});
let buffer53 = device0.createBuffer({
  size: 10420,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 89});
let texture116 = device0.createTexture({
  size: [576, 1, 104],
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView113 = texture47.createView({arrayLayerCount: 1});
let sampler56 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 76.43,
});
try {
renderBundleEncoder9.setBindGroup(3, bindGroup1, new Uint32Array(30), 4, 0);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer27, 'uint16', 540, 76);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(1, buffer1, 576, 9_736);
} catch {}
try {
device0.queue.writeBuffer(buffer50, 2220, new Float32Array(7403), 2749, 100);
} catch {}
try {
computePassEncoder62.setBindGroup(2, bindGroup1, new Uint32Array(4351), 515, 0);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder14.setVertexBuffer(3, buffer37, 1_000, 2_273);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let renderBundle9 = renderBundleEncoder9.finish();
let sampler57 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.74,
  compare: 'never',
});
try {
computePassEncoder18.setBindGroup(0, bindGroup15);
} catch {}
try {
computePassEncoder51.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(5, buffer35, 0, 1_680);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline12 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule0, constants: {}, targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALL}]},
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex1',
    constants: {21_537: 0},
    buffers: [
      {
        arrayStride: 164,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32x2', offset: 4, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 14},
          {format: 'sint8x4', offset: 20, shaderLocation: 8},
          {format: 'unorm16x4', offset: 104, shaderLocation: 11},
          {format: 'snorm8x4', offset: 64, shaderLocation: 4},
          {format: 'uint8x4', offset: 4, shaderLocation: 15},
          {format: 'sint32x4', offset: 0, shaderLocation: 12},
          {format: 'uint32x2', offset: 4, shaderLocation: 5},
          {format: 'sint32', offset: 32, shaderLocation: 7},
          {format: 'snorm8x2', offset: 30, shaderLocation: 1},
          {format: 'snorm16x4', offset: 20, shaderLocation: 3},
          {format: 'uint8x2', offset: 24, shaderLocation: 2},
          {format: 'uint16x4', offset: 0, shaderLocation: 13},
          {format: 'uint8x2', offset: 28, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint8x2', offset: 2, shaderLocation: 6},
          {format: 'float32x3', offset: 48, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'front', unclippedDepth: false},
});
let buffer54 = device0.createBuffer({size: 2058, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let textureView114 = texture93.createView({arrayLayerCount: 1});
try {
computePassEncoder41.setBindGroup(2, bindGroup28);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline9);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'unspecified', transfer: 'bt1361ExtendedColourGamut'} });
let autogeneratedBindGroupLayout41 = pipeline8.getBindGroupLayout(1);
let bindGroup52 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout19,
  entries: [
    {binding: 79, resource: {buffer: buffer51, offset: 512, size: 2587}},
    {binding: 125, resource: textureView49},
  ],
});
let buffer55 = device0.createBuffer({
  size: 13072,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder89 = device0.createCommandEncoder({});
let computePassEncoder65 = commandEncoder89.beginComputePass({});
try {
computePassEncoder33.setBindGroup(2, bindGroup46, new Uint32Array(1463), 142, 0);
} catch {}
try {
computePassEncoder61.setPipeline(pipeline9);
} catch {}
let texture117 = device0.createTexture({
  size: [60, 1, 13],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let sampler58 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', minFilter: 'nearest'});
try {
computePassEncoder60.setBindGroup(3, bindGroup32, new Uint32Array(502), 76, 0);
} catch {}
try {
computePassEncoder35.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder18.setBindGroup(2, bindGroup29, new Uint32Array(67), 5, 0);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(78);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer8, 'uint32', 272, 988);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 47, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(20).fill(72), /* required buffer size: 20 */
{offset: 20, bytesPerRow: 586}, {width: 140, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
await gc();
let imageData16 = new ImageData(100, 56);
let autogeneratedBindGroupLayout42 = pipeline6.getBindGroupLayout(0);
let externalTexture8 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder64.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline6);
} catch {}
document.body.append(img0);
try {
globalThis.someLabel = commandEncoder58.label;
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

enable f16;

@group(0) @binding(73) var<storage, read_write> buffer56: T0;

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

fn fn0(a0: FragmentOutput1) -> f16 {
  var out: f16;
  out = f16(atomicExchange(&(*&buffer56).f0[arrayLength(&(*&buffer56).f0)][0][u32(unconst_u32(343))], i32(unconst_i32(156))));
  atomicAdd(&buffer56.f0[u32(unconst_u32(126))][u32(unconst_u32(298))][u32(unconst_u32(38))], i32(unconst_i32(289)));
  let vf27: i32 = atomicLoad(&buffer56.f0[bitcast<u32>(atomicExchange(&(*&buffer56).f0[arrayLength(&(*&buffer56).f0)][0][0], i32(unconst_i32(278))))][0][u32(unconst_u32(210))]);
  var vf28: i32 = atomicLoad(&(*&buffer56).f0[arrayLength(&(*&buffer56).f0)][0][0]);
  let ptr18: ptr<function, i32> = &vf28;
  let ptr19: ptr<storage, atomic<i32>, read_write> = &buffer56.f0[u32(unconst_u32(11))][u32(unconst_u32(246))][u32(unconst_u32(34))];
  atomicOr(&buffer56.f0[u32(unconst_u32(194))][u32(unconst_u32(49))][u32(unconst_u32(159))], i32(unconst_i32(41)));
  vf28 -= atomicLoad(&buffer56.f0[arrayLength(&buffer56.f0)][0][0]);
  vf28 -= atomicLoad(&(*&buffer56).f0[arrayLength(&(*&buffer56).f0)][0][0]);
  out *= f16(atomicExchange(&(*ptr19), i32(unconst_i32(4))));
  let ptr20: ptr<storage, atomic<i32>, read_write> = &(*ptr19);
  atomicExchange(&buffer56.f0[u32(unconst_u32(175))][u32(unconst_u32(83))][0], i32(unconst_i32(85)));
  vf28 = atomicLoad(&(*&buffer56).f0[u32(atomicLoad(&buffer56.f0[arrayLength(&buffer56.f0)][bitcast<u32>(atomicLoad(&buffer56.f0[arrayLength(&buffer56.f0)][0][0]))][0]))][0][0]);
  vf28 += atomicLoad(&buffer56.f0[u32(unconst_u32(90))][u32(unconst_u32(45))][u32(unconst_u32(50))]);
  var vf29: i32 = atomicExchange(&(*&buffer56).f0[u32(unconst_u32(56))][u32(unconst_u32(124))][u32(unconst_u32(137))], i32(unconst_i32(201)));
  vf29 |= atomicLoad(&buffer56.f0[i32(unconst_i32(-113))][0][0]);
  atomicMax(&buffer56.f0[u32(unconst_u32(162))][arrayLength(&buffer56.f0)][u32(unconst_u32(74))], i32(unconst_i32(43)));
  atomicXor(&buffer56.f0[bitcast<u32>((*ptr18))][u32(unconst_u32(144))][u32(unconst_u32(217))], i32(unconst_i32(27)));
  let ptr21: ptr<storage, atomic<i32>, read_write> = &buffer56.f0[u32(round(vec3h(unconst_f16(11225.8), unconst_f16(3197.0), unconst_f16(60000.0))).r)][u32(unconst_u32(253))][u32(unconst_u32(329))];
  return out;
  _ = buffer56;
}

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

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

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

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

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

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

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

@fragment
fn fragment1() -> FragmentOutput1 {
  var out: FragmentOutput1;
  out.f0 |= unpack4xU8(bitcast<u32>(atomicLoad(&buffer56.f0[arrayLength(&buffer56.f0)][u32(unconst_u32(274))][0])));
  out.f0 ^= unpack4xU8(u32(atomicLoad(&buffer56.f0[arrayLength(&buffer56.f0)][u32(unconst_u32(272))][0])));
  let ptr22: ptr<storage, array<atomic<i32>, 1>, read_write> = &buffer56.f0[arrayLength(&buffer56.f0)][u32(unconst_u32(28))];
  let vf30: i32 = atomicExchange(&(*ptr22)[u32(unconst_u32(103))], i32(unconst_i32(59)));
  let vf31: i32 = atomicLoad(&(*ptr22)[0]);
  out = FragmentOutput1(vec4u(unpack4x8snorm(u32(unconst_u32(294)))), u32(unpack4x8snorm(u32(unconst_u32(294)))[2]));
  let ptr23: ptr<storage, array<array<atomic<i32>, 1>, 1>, read_write> = &buffer56.f0[u32(unconst_u32(116))];
  var vf32: vec3h = tanh(vec3h(f16(atomicExchange(&buffer56.f0[u32(unconst_u32(344))][0][0], i32(unconst_i32(144))))));
  let ptr24: ptr<storage, atomic<i32>, read_write> = &(*ptr23)[0][0];
  atomicOr(&buffer56.f0[bitcast<u32>(atomicLoad(&(*ptr23)[u32(unconst_u32(86))][0]))][u32(unconst_u32(355))][u32(unconst_u32(645))], i32(unconst_i32(125)));
  let ptr25: ptr<storage, atomic<i32>, read_write> = &(*ptr24);
  var vf33: i32 = atomicLoad(&(*ptr22)[0]);
  return out;
  _ = buffer56;
}

@compute @workgroup_size(2, 1, 1)
fn compute1() {
  var vf34 = fn0(FragmentOutput1());
  atomicCompareExchangeWeak(&buffer56.f0[u32(unconst_u32(12))][u32(unconst_u32(23))][u32(unconst_u32(57))], unconst_i32(48), unconst_i32(405));
  atomicCompareExchangeWeak(&buffer56.f0[u32(atomicExchange(&buffer56.f0[arrayLength(&buffer56.f0)][0][0], i32(unconst_i32(173))))][u32(unconst_u32(403))][u32(unconst_u32(82))], unconst_i32(138), unconst_i32(28));
  fn0(FragmentOutput1(unpack4xU8(bitcast<u32>(atomicExchange(&(*&buffer56).f0[arrayLength(&(*&buffer56).f0)][0][u32(unconst_u32(183))], i32(unconst_i32(9))))), bitcast<u32>(atomicExchange(&(*&buffer56).f0[arrayLength(&(*&buffer56).f0)][0][u32(unconst_u32(183))], i32(unconst_i32(9))))));
  let ptr26: ptr<storage, array<atomic<i32>, 1>, read_write> = &buffer56.f0[u32(unconst_u32(53))][u32(unconst_u32(39))];
  var vf35 = fn0(FragmentOutput1(unpack4xU8(u32(atomicExchange(&buffer56.f0[u32(unconst_u32(182))][0][0], i32(unconst_i32(378))))), bitcast<u32>(atomicExchange(&buffer56.f0[u32(unconst_u32(182))][0][0], i32(unconst_i32(378))))));
  var vf36: i32 = atomicExchange(&(*&buffer56).f0[arrayLength(&(*&buffer56).f0)][0][0], i32(unconst_i32(704)));
  _ = buffer56;
}`,
});
let textureView115 = texture77.createView({dimension: 'cube', baseArrayLayer: 4});
let textureView116 = texture40.createView({});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle10 = renderBundleEncoder10.finish({});
try {
computePassEncoder43.setBindGroup(3, bindGroup23);
} catch {}
try {
computePassEncoder60.setBindGroup(0, bindGroup9, new Uint32Array(419), 140, 0);
} catch {}
try {
computePassEncoder53.setPipeline(pipeline9);
} catch {}
document.body.append(img0);
let bindGroup53 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 36, resource: textureView49}]});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], stencilReadOnly: true});
try {
computePassEncoder21.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup31);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer55, 'uint32', 1_348, 844);
} catch {}
let pipeline13 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  targets: [{format: 'rgba8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex1',
    constants: {21_537: 0},
    buffers: [
      {
        arrayStride: 100,
        attributes: [
          {format: 'uint16x4', offset: 0, shaderLocation: 2},
          {format: 'float16x2', offset: 16, shaderLocation: 11},
          {format: 'sint8x2', offset: 2, shaderLocation: 12},
          {format: 'float16x4', offset: 12, shaderLocation: 1},
          {format: 'uint8x4', offset: 48, shaderLocation: 13},
          {format: 'uint16x2', offset: 8, shaderLocation: 15},
          {format: 'float32x4', offset: 8, shaderLocation: 10},
          {format: 'sint32x2', offset: 28, shaderLocation: 6},
          {format: 'unorm16x2', offset: 20, shaderLocation: 4},
          {format: 'uint32x2', offset: 40, shaderLocation: 9},
          {format: 'unorm16x4', offset: 4, shaderLocation: 14},
          {format: 'sint16x4', offset: 0, shaderLocation: 7},
          {format: 'unorm16x4', offset: 44, shaderLocation: 0},
          {format: 'sint32x2', offset: 0, shaderLocation: 8},
          {format: 'unorm16x2', offset: 0, shaderLocation: 3},
          {format: 'uint8x2', offset: 14, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', cullMode: 'front'},
});
let bindGroup54 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [
    {binding: 79, resource: {buffer: buffer45, offset: 1536, size: 9564}},
    {binding: 125, resource: textureView2},
  ],
});
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer0, 'uint32', 444, 61);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer15, 'uint32', 684, 28);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline1);
} catch {}
let commandEncoder90 = device0.createCommandEncoder();
let sampler59 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 77.17});
try {
computePassEncoder30.setBindGroup(0, bindGroup28);
} catch {}
try {
computePassEncoder46.setBindGroup(1, bindGroup16, new Uint32Array(980), 163, 0);
} catch {}
try {
computePassEncoder14.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup30);
} catch {}
try {
commandEncoder90.copyBufferToBuffer(buffer34, 280, buffer38, 1672, 160);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 136, new Float32Array(2730), 70, 128);
} catch {}
let buffer57 = device0.createBuffer({
  size: 11024,
  usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder91 = device0.createCommandEncoder();
let computePassEncoder66 = commandEncoder91.beginComputePass({});
try {
renderBundleEncoder11.setIndexBuffer(buffer8, 'uint16', 8_230, 647);
} catch {}
try {
device0.queue.writeBuffer(buffer55, 2604, new DataView(new ArrayBuffer(4954)), 815, 372);
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [
    {binding: 125, resource: textureView49},
    {binding: 79, resource: {buffer: buffer50, offset: 1536, size: 371}},
  ],
});
let computePassEncoder67 = commandEncoder90.beginComputePass({});
let renderBundle11 = renderBundleEncoder11.finish({});
try {
computePassEncoder3.setBindGroup(1, bindGroup49, []);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup47);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
adapter0.label = '\u{1fba2}\udc73\u{1fa4b}\u{1fabd}\uf0fc\u0704\u{1fcb5}\u{1f682}\u4256\u3e28\u0bde';
} catch {}
let buffer58 = device0.createBuffer({size: 34167, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder92 = device0.createCommandEncoder({});
let querySet13 = device0.createQuerySet({type: 'occlusion', count: 326});
try {
computePassEncoder9.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer29, 'uint16', 2_768, 1_445);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline3);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture60,
  mipLevel: 1,
  origin: {x: 143, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(47).fill(253), /* required buffer size: 47 */
{offset: 47, rowsPerImage: 94}, {width: 43, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
requires pointer_composite_access;

enable f16;

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

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

var<workgroup> vw13: array<f16, 102>;

struct VertexOutput1 {
  @location(4) @interpolate(perspective, centroid) f1: vec2h,
  @invariant @builtin(position) f2: vec4f,
}

@id(47134) override override17: bool;

var<workgroup> vw11: array<array<array<i32, 1>, 1>, 19>;

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

var<private> vp4 = modf(vec4h(4757.1, 10270.3, 2886.0, 8950.4));

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

@group(0) @binding(175) var<uniform> buffer59: array<array<array<vec4f, 1>, 1>, 15>;

var<workgroup> vw15: mat3x2f;

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

var<private> vp3: u32 = u32(56);

var<workgroup> vw14: mat3x2f;

var<private> vp5: array<VertexOutput1, 1> = array(VertexOutput1());

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

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

struct T0 {
  @size(80) f0: array<mat3x3f, 1>,
  @size(16) f1: vec2i,
  @size(152) f2: array<array<array<mat2x3h, 1>, 3>, 3>,
}

var<private> vp7 = modf(vec3h(1533.7, 932.4, 60000.0));

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

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

alias vec3b = vec3<bool>;

var<workgroup> vw12: vec2h;

var<private> vp6 = modf(f16(1770.1));

@id(7825) override override18 = false;

fn fn0(a0: ptr<uniform, vec2h>, a1: ptr<storage, vec2f, read>, a2: array<array<array<vec2f, 1>, 1>, 12>, a3: ptr<private, VertexOutput1>, a4: ptr<function, array<i32, 11>>, a5: ptr<uniform, VertexOutput1>, a6: ptr<workgroup, atomic<i32>>, a7: array<array<mat2x2f, 1>, 1>, a8: ptr<function, array<u32, 53>>, a9: vec4i, a10: array<VertexOutput1, 1>, a11: array<mat4x4h, 2>, a12: vec2h) -> VertexOutput1 {
  var out: VertexOutput1;
  vp8 = VertexOutput1(vec2h((*&buffer59)[u32(unconst_u32(330))][0][u32(unconst_u32(58))].yx), (*&buffer59)[u32(unconst_u32(330))][0][u32(unconst_u32(58))]);
  vp5[u32(unconst_u32(87))] = VertexOutput1(vec2h(a2[11][u32(unconst_u32(120))][0]), a2[11][u32(unconst_u32(120))][0].grrr);
  (*a3) = VertexOutput1(bitcast<vec2h>(trunc(a7[u32(unconst_u32(498))][0][u32(unconst_u32(85))][u32(unconst_u32(123))])), vec4f(trunc(a7[u32(unconst_u32(498))][0][u32(unconst_u32(85))][u32(unconst_u32(123))])));
  let ptr27: ptr<uniform, array<vec4f, 1>> = &buffer59[u32(unconst_u32(88))][u32(unconst_u32(199))];
  let ptr28: ptr<private, vec4f> = &vp5[0].f2;
  let ptr29: ptr<uniform, array<vec4f, 1>> = &buffer59[14][u32(unconst_u32(145))];
  return out;
  _ = buffer59;
}

@vertex
fn vertex2(@location(7) a0: vec4h, @location(4) @interpolate(flat) a1: vec4h, @location(12) @interpolate(flat, sample) a2: vec4i) -> VertexOutput1 {
  var out: VertexOutput1;
  vp7 = modf(vec3h(f16(radians(f32(unconst_f32(0.04826))))));
  let vf37: i32 = extractBits(i32(unconst_i32(-104)), u32(unconst_u32(96)), u32(unconst_u32(172)));
  return out;
}

@fragment
fn fragment2() -> @location(200) vec4u {
  var out: vec4u;
  let ptr30 = &vp4;
  vp3 = vec4u((*ptr30).whole)[2];
  let ptr31: ptr<private, f16> = &vp6.fract;
  var vf38: vec4f = exp(vec4f(unconst_f32(0.09257), unconst_f32(0.09442), unconst_f32(0.3160), unconst_f32(0.4502)));
  vp6.fract = f16(quantizeToF16(f32(unconst_f32(0.02837))));
  let ptr32: ptr<private, vec3h> = &vp7.fract;
  let ptr33: ptr<private, f16> = &vp6.whole;
  let ptr34: ptr<private, vec3h> = &(*ptr32);
  discard;
  let ptr35: ptr<private, vec3h> = &vp7.fract;
  vp4 = modf(vec4h(f16(vp8.f2[u32(unconst_u32(81))])));
  vp4 = modf(vec4h(f16(dot4I8Packed(u32(unconst_u32(39)), u32(unconst_u32(129))))));
  let ptr36: ptr<private, vec4h> = &(*ptr30).fract;
  var vf39: f32 = vp5[0].f2[u32(unconst_u32(28))];
  let ptr37: ptr<private, VertexOutput1> = &vp8;
  vp5[u32(unconst_u32(83))] = VertexOutput1(vec2h(textureDimensions(et0)), bitcast<vec4f>(textureDimensions(et0).yyyy));
  return out;
  _ = et0;
}`,
});
let commandEncoder93 = device0.createCommandEncoder();
let computePassEncoder68 = commandEncoder93.beginComputePass();
let sampler60 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
computePassEncoder4.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup47);
} catch {}
try {
commandEncoder92.copyBufferToBuffer(buffer55, 3756, buffer15, 84, 732);
} catch {}
try {
  await promise16;
} catch {}
offscreenCanvas1.width = 489;
let bindGroup56 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout16,
  entries: [{binding: 79, resource: {buffer: buffer40, offset: 512, size: 332}}],
});
let commandEncoder94 = device0.createCommandEncoder({});
let computePassEncoder69 = commandEncoder92.beginComputePass({});
let externalTexture9 = device0.importExternalTexture({source: videoFrame11});
try {
computePassEncoder67.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer8, 'uint32', 16_120, 479);
} catch {}
document.body.append(canvas2);
let img1 = await imageWithData(36, 124, '#10101010', '#20202020');
let imageData17 = new ImageData(4, 4);
let autogeneratedBindGroupLayout43 = pipeline7.getBindGroupLayout(0);
let bindGroup57 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout41,
  entries: [{binding: 79, resource: {buffer: buffer55, offset: 768}}],
});
let commandEncoder95 = device0.createCommandEncoder({});
let texture118 = device0.createTexture({
  size: {width: 1344},
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView117 = texture6.createView({format: 'r16uint', arrayLayerCount: 2});
let sampler61 = device0.createSampler({
  label: '\u{1fa6b}\u7020\uc228\u8b9f\u91bf\u39d4\u6aa0\u4aaa\u3e6a',
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 54.42,
  lodMaxClamp: 93.80,
  compare: 'never',
  maxAnisotropy: 16,
});
try {
computePassEncoder4.setBindGroup(0, bindGroup26, []);
} catch {}
try {
computePassEncoder44.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup44, new Uint32Array(1685), 181, 0);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle3]);
} catch {}
try {
buffer32.unmap();
} catch {}
try {
commandEncoder95.copyTextureToBuffer({
  texture: texture110,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 268 widthInBlocks: 67 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 200 */
  offset: 200,
  bytesPerRow: 14592,
  buffer: buffer16,
}, {width: 67, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder95.copyTextureToTexture({
  texture: texture82,
  mipLevel: 0,
  origin: {x: 85, y: 0, z: 31},
  aspect: 'all',
},
{
  texture: texture46,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 111, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture91,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(233).fill(186), /* required buffer size: 233 */
{offset: 233}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout44 = pipeline8.getBindGroupLayout(1);
let bindGroup58 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 28, resource: textureView110}]});
let commandEncoder96 = device0.createCommandEncoder({});
let textureView118 = texture89.createView({dimension: '2d', format: 'r32sint', baseMipLevel: 0});
let texture119 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder12.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup25, new Uint32Array(264), 1, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer28, 'uint16', 3_138, 3_996);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline13);
} catch {}
let buffer60 = device0.createBuffer({size: 9130, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView119 = texture18.createView({dimension: '2d', baseArrayLayer: 4});
let computePassEncoder70 = commandEncoder95.beginComputePass({});
let renderPassEncoder26 = commandEncoder96.beginRenderPass({
  colorAttachments: [{
  view: textureView74,
  depthSlice: 30,
  clearValue: { r: -106.1, g: 209.2, b: 944.0, a: 390.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet5,
});
try {
computePassEncoder30.setBindGroup(0, bindGroup14, new Uint32Array(1429), 624, 0);
} catch {}
await gc();
let texture120 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 12},
  mipLevelCount: 3,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder71 = commandEncoder94.beginComputePass({});
try {
computePassEncoder22.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(4, buffer38, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture49,
  mipLevel: 2,
  origin: {x: 3, y: 0, z: 5},
  aspect: 'all',
}, new Uint8Array(40_008).fill(78), /* required buffer size: 40_008 */
{offset: 462, bytesPerRow: 169, rowsPerImage: 18}, {width: 35, height: 0, depthOrArrayLayers: 14});
} catch {}
let commandEncoder97 = device0.createCommandEncoder({});
let textureView120 = texture95.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5});
let computePassEncoder72 = commandEncoder97.beginComputePass({});
try {
computePassEncoder58.setBindGroup(2, bindGroup5, new Uint32Array(344), 4, 0);
} catch {}
let buffer61 = device0.createBuffer({size: 28225, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let texture121 = device0.createTexture({
  size: [288, 1, 1],
  mipLevelCount: 3,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler62 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'linear',
  lodMinClamp: 91.01,
  lodMaxClamp: 96.21,
});
try {
computePassEncoder23.setBindGroup(0, bindGroup55, new Uint32Array(2236), 384, 0);
} catch {}
try {
computePassEncoder37.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(1, buffer26, 0, 4_638);
} catch {}
let buffer62 = device0.createBuffer({
  size: 19274,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture122 = device0.createTexture({
  size: [128],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder57.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline13);
} catch {}
let bindGroup59 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 28, resource: textureView1}]});
let sampler63 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'greater-equal',
  maxAnisotropy: 20,
});
try {
renderPassEncoder20.setIndexBuffer(buffer28, 'uint16', 248, 1_466);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
document.body.prepend(img1);
let commandEncoder98 = device0.createCommandEncoder({});
let textureView121 = texture25.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 6});
let computePassEncoder73 = commandEncoder98.beginComputePass({});
try {
computePassEncoder35.setBindGroup(2, bindGroup47, new Uint32Array(2589), 443, 0);
} catch {}
try {
renderPassEncoder22.setBlendConstant({ r: -908.5, g: 484.7, b: -822.2, a: -935.8, });
} catch {}
let textureView122 = texture92.createView({});
let sampler64 = device0.createSampler({addressModeW: 'repeat', magFilter: 'linear', mipmapFilter: 'nearest'});
let externalTexture10 = device0.importExternalTexture({source: videoFrame11});
try {
computePassEncoder7.setBindGroup(3, bindGroup37, new Uint32Array(2690), 273, 0);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer18, 'uint16', 384, 209);
} catch {}
document.body.append(img0);
let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 36,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let buffer63 = device0.createBuffer({
  size: 13068,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder59.setBindGroup(2, bindGroup1);
} catch {}
try {
computePassEncoder11.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup36, []);
} catch {}
try {
buffer55.unmap();
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout42]});
try {
computePassEncoder48.setBindGroup(1, bindGroup11);
} catch {}
try {
computePassEncoder65.setBindGroup(2, bindGroup47, new Uint32Array(825), 318, 0);
} catch {}
try {
computePassEncoder47.pushDebugGroup('\u4e05');
} catch {}
let autogeneratedBindGroupLayout45 = pipeline12.getBindGroupLayout(0);
let buffer64 = device0.createBuffer({size: 2124, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder99 = device0.createCommandEncoder({});
let texture123 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 89},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let texture124 = gpuCanvasContext1.getCurrentTexture();
let textureView123 = texture35.createView({label: '\u0662\u0a31', aspect: 'all'});
let computePassEncoder74 = commandEncoder99.beginComputePass({});
let externalTexture11 = device0.importExternalTexture({source: videoFrame10, colorSpace: 'display-p3'});
try {
computePassEncoder54.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(7, buffer57, 2_484, 511);
} catch {}
document.body.append(canvas3);
let bindGroup60 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [
    {binding: 79, resource: {buffer: buffer51, offset: 768, size: 950}},
    {binding: 125, resource: textureView2},
  ],
});
let textureView124 = texture43.createView({baseMipLevel: 0});
try {
computePassEncoder65.setBindGroup(2, bindGroup59, new Uint32Array(1639), 20, 0);
} catch {}
try {
renderPassEncoder17.setScissorRect(260, 0, 65, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer41, 'uint32', 1_564, 116);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline3);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 352,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder100 = device0.createCommandEncoder();
let texture125 = device0.createTexture({
  size: [128],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder27 = commandEncoder100.beginRenderPass({
  colorAttachments: [{
  view: textureView112,
  depthSlice: 29,
  clearValue: { r: -380.3, g: -266.6, b: 826.1, a: 518.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet6,
});
try {
computePassEncoder29.setBindGroup(1, bindGroup5, new Uint32Array(2071), 63, 0);
} catch {}
try {
computePassEncoder47.popDebugGroup();
} catch {}
let buffer65 = device0.createBuffer({size: 22266, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder101 = device0.createCommandEncoder({});
let renderPassEncoder28 = commandEncoder101.beginRenderPass({
  colorAttachments: [{
  view: textureView41,
  clearValue: { r: 644.0, g: 279.2, b: 761.8, a: -869.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder16.setBindGroup(1, bindGroup2, new Uint32Array(3095), 319, 0);
} catch {}
let autogeneratedBindGroupLayout46 = pipeline1.getBindGroupLayout(0);
let commandEncoder102 = device0.createCommandEncoder({});
let texture126 = device0.createTexture({
  size: [72, 1, 54],
  mipLevelCount: 4,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder75 = commandEncoder102.beginComputePass({});
try {
computePassEncoder13.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer42);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let autogeneratedBindGroupLayout47 = pipeline4.getBindGroupLayout(1);
let buffer66 = device0.createBuffer({
  size: 9471,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder103 = device0.createCommandEncoder({});
let texture127 = device0.createTexture({
  size: [30],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView125 = texture66.createView({mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 2});
let computePassEncoder76 = commandEncoder103.beginComputePass({});
try {
renderPassEncoder19.setBindGroup(1, bindGroup50, new Uint32Array(612), 106, 0);
} catch {}
canvas3.width = 123;
let bindGroup61 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [
    {binding: 79, resource: {buffer: buffer34, offset: 0, size: 550}},
    {binding: 125, resource: textureView7},
  ],
});
let buffer67 = device0.createBuffer({
  size: 2846,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder104 = device0.createCommandEncoder({});
let querySet14 = device0.createQuerySet({type: 'occlusion', count: 717});
let texture128 = device0.createTexture({
  size: [120, 1, 72],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView126 = texture36.createView({format: 'rgba8uint', mipLevelCount: 1});
let computePassEncoder77 = commandEncoder104.beginComputePass({});
let sampler65 = device0.createSampler({});
let externalTexture12 = device0.importExternalTexture({source: videoFrame1});
try {
renderPassEncoder21.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder13.setScissorRect(0, 0, 1, 0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline0);
} catch {}
try {
buffer30.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer29, 2768, new DataView(new ArrayBuffer(636)), 256, 104);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 253, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(140).fill(144), /* required buffer size: 140 */
{offset: 140}, {width: 37, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup62 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout44,
  entries: [{binding: 79, resource: {buffer: buffer45, offset: 2304, size: 2941}}],
});
let commandEncoder105 = device0.createCommandEncoder({});
let computePassEncoder78 = commandEncoder105.beginComputePass();
let sampler66 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 90.57,
});
try {
computePassEncoder8.setBindGroup(0, bindGroup41);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup31, new Uint32Array(376), 45, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle5]);
} catch {}
document.body.prepend(canvas2);
let imageBitmap2 = await createImageBitmap(imageData1);
let bindGroup63 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [
    {binding: 125, resource: textureView7},
    {binding: 79, resource: {buffer: buffer12, offset: 2048, size: 1186}},
  ],
});
let commandEncoder106 = device0.createCommandEncoder({});
let texture129 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 7},
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView127 = texture87.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 2});
let sampler67 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 50.49,
  lodMaxClamp: 54.60,
});
try {
computePassEncoder41.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup32, new Uint32Array(1885), 212, 0);
} catch {}
await gc();
let autogeneratedBindGroupLayout48 = pipeline4.getBindGroupLayout(1);
let commandEncoder107 = device0.createCommandEncoder({});
let textureView128 = texture97.createView({dimension: '2d', aspect: 'all', format: 'rg32float', baseMipLevel: 0, baseArrayLayer: 5});
let computePassEncoder79 = commandEncoder106.beginComputePass({});
try {
computePassEncoder70.setPipeline(pipeline9);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap2,
  origin: { x: 0, y: 45 },
  flipY: false,
}, {
  texture: texture107,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup64 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout4,
  entries: [
    {binding: 79, resource: {buffer: buffer7, offset: 0, size: 20}},
    {binding: 125, resource: textureView7},
  ],
});
try {
computePassEncoder20.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder18.beginOcclusionQuery(4);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer21, 1_696, 635);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.writeBuffer(buffer47, 760, new Float32Array(4285), 613, 36);
} catch {}
let commandEncoder108 = device0.createCommandEncoder({});
let textureView129 = texture66.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 1});
let texture130 = device0.createTexture({
  size: [1344, 1, 23],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder51.setBindGroup(2, bindGroup16);
} catch {}
try {
renderPassEncoder18.endOcclusionQuery();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 1},
  aspect: 'all',
}, new Uint8Array(102).fill(207), /* required buffer size: 102 */
{offset: 102, bytesPerRow: 208, rowsPerImage: 314}, {width: 10, height: 55, depthOrArrayLayers: 0});
} catch {}
let buffer68 = device0.createBuffer({size: 28018, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let computePassEncoder80 = commandEncoder107.beginComputePass({});
let renderPassEncoder29 = commandEncoder108.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  depthSlice: 16,
  clearValue: { r: -158.3, g: 843.2, b: 2.732, a: -300.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder33.setBindGroup(1, bindGroup12, []);
} catch {}
try {
computePassEncoder42.setBindGroup(0, bindGroup4, new Uint32Array(1195), 219, 0);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup12);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let autogeneratedBindGroupLayout49 = pipeline11.getBindGroupLayout(0);
let bindGroup65 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout44,
  entries: [{binding: 79, resource: {buffer: buffer42, offset: 0, size: 481}}],
});
let buffer69 = device0.createBuffer({
  size: 1301,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder55.setBindGroup(3, bindGroup59, new Uint32Array(1735), 118, 0);
} catch {}
let imageData18 = new ImageData(8, 60);
let texture131 = device0.createTexture({
  size: [288, 1, 17],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler68 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 95.08});
try {
computePassEncoder78.setBindGroup(0, bindGroup10);
} catch {}
let bindGroup66 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout14,
  entries: [
    {binding: 125, resource: textureView2},
    {binding: 79, resource: {buffer: buffer1, offset: 512, size: 927}},
  ],
});
let textureView130 = texture117.createView({arrayLayerCount: 1});
try {
computePassEncoder70.setBindGroup(3, bindGroup52, new Uint32Array(157), 0, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup3);
} catch {}
let commandEncoder109 = device0.createCommandEncoder({});
let computePassEncoder81 = commandEncoder109.beginComputePass({});
try {
renderPassEncoder23.setBlendConstant({ r: -503.0, g: -696.9, b: 63.60, a: -284.8, });
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer27, 'uint32', 2_012, 669);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer23, 0);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
let imageData19 = new ImageData(4, 32);
let videoFrame14 = videoFrame12.clone();
let bindGroup67 = device0.createBindGroup({layout: veryExplicitBindGroupLayout9, entries: [{binding: 352, resource: textureView85}]});
try {
computePassEncoder45.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup47, new Uint32Array(1567), 61, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let commandEncoder110 = device0.createCommandEncoder();
let texture132 = device0.createTexture({
  size: [240, 1, 124],
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder82 = commandEncoder110.beginComputePass({});
try {
computePassEncoder25.setBindGroup(1, bindGroup3);
} catch {}
try {
computePassEncoder62.setPipeline(pipeline9);
} catch {}
let pipeline14 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute1', constants: {}}});
let bindGroup68 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout35,
  entries: [
    {binding: 79, resource: {buffer: buffer1, offset: 1792, size: 145}},
    {binding: 125, resource: textureView49},
  ],
});
let buffer70 = device0.createBuffer({
  size: 14085,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture133 = device0.createTexture({
  size: [672],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView131 = texture104.createView({baseArrayLayer: 5, arrayLayerCount: 1});
let sampler69 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 71.64,
  lodMaxClamp: 72.02,
  compare: 'less',
});
try {
computePassEncoder69.setBindGroup(0, bindGroup16);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer32, 3_264, 1_220);
} catch {}
try {
computePassEncoder9.insertDebugMarker('\ufc4b');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let autogeneratedBindGroupLayout50 = pipeline12.getBindGroupLayout(0);
let commandEncoder111 = device0.createCommandEncoder({});
let computePassEncoder83 = commandEncoder111.beginComputePass({});
let sampler70 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 96.90,
  compare: 'greater',
});
try {
computePassEncoder58.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup54, new Uint32Array(3265), 84, 0);
} catch {}
try {
  await buffer49.mapAsync(GPUMapMode.WRITE, 232);
} catch {}
try {
device0.queue.writeBuffer(buffer70, 3796, new BigUint64Array(29766), 2213, 356);
} catch {}
let bindGroup69 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout28,
  entries: [
    {binding: 125, resource: textureView7},
    {binding: 79, resource: {buffer: buffer54, offset: 0, size: 314}},
  ],
});
let texture134 = device0.createTexture({
  size: [60, 1, 1],
  mipLevelCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder10.setBindGroup(2, bindGroup1);
} catch {}
try {
computePassEncoder81.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(5, buffer7, 468);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 60, height: 1, depthOrArrayLayers: 31}
*/
{
  source: imageData6,
  origin: { x: 5, y: 0 },
  flipY: false,
}, {
  texture: texture132,
  mipLevel: 2,
  origin: {x: 8, y: 0, z: 7},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup70 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout46,
  entries: [
    {binding: 125, resource: textureView49},
    {binding: 79, resource: {buffer: buffer52, offset: 0, size: 737}},
  ],
});
let texture135 = device0.createTexture({
  size: [288],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder18.setBindGroup(2, bindGroup30);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup53);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup70, new Uint32Array(1785), 785, 0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline8);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
canvas3.width = 214;
let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 313,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
try {
computePassEncoder11.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer15, 'uint32', 328, 120);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer62, 2_788, 1_917);
} catch {}
try {
buffer48.unmap();
} catch {}
let commandEncoder112 = device0.createCommandEncoder({});
let sampler71 = device0.createSampler({addressModeU: 'repeat'});
try {
computePassEncoder38.setBindGroup(3, bindGroup32, []);
} catch {}
try {
renderPassEncoder19.setBindGroup(3, bindGroup34, new Uint32Array(1384), 154, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer12, 'uint16', 204, 593);
} catch {}
try {
commandEncoder112.copyTextureToTexture({
  texture: texture96,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture96,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 288, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise17;
} catch {}
document.body.append(canvas3);
let buffer71 = device0.createBuffer({
  size: 9416,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder113 = device0.createCommandEncoder({});
let texture136 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder84 = commandEncoder112.beginComputePass({});
let renderPassEncoder30 = commandEncoder113.beginRenderPass({
  label: '\uf1fc\u01d2\ue4b4\uaf2a',
  colorAttachments: [{view: textureView37, depthSlice: 150, loadOp: 'load', storeOp: 'store'}],
});
let sampler72 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 91.51,
  compare: 'never',
});
try {
computePassEncoder76.setBindGroup(3, bindGroup15);
} catch {}
try {
computePassEncoder74.setBindGroup(0, bindGroup3, new Uint32Array(68), 1, 0);
} catch {}
try {
computePassEncoder23.setBindGroup(0, bindGroup39);
} catch {}
try {
computePassEncoder80.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(2, buffer67);
} catch {}
let imageData20 = new ImageData(4, 28);
let autogeneratedBindGroupLayout51 = pipeline6.getBindGroupLayout(0);
let textureView132 = texture22.createView({baseArrayLayer: 59, arrayLayerCount: 12});
let sampler73 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.82,
  maxAnisotropy: 19,
});
try {
computePassEncoder36.setBindGroup(1, bindGroup61, new Uint32Array(5986), 158, 0);
} catch {}
try {
renderPassEncoder13.setViewport(17.15068277356738, 0.29225850760562744, 0.8800019102438124, 0.1047593290985158, 0.8407945272746967, 0.9220941700409464);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline12);
} catch {}
try {
computePassEncoder53.insertDebugMarker('\u488e');
} catch {}
let commandEncoder114 = device0.createCommandEncoder({});
let texture137 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 44},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture138 = device0.createTexture({
  size: [144, 1, 86],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView133 = texture106.createView({});
try {
computePassEncoder66.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(5, buffer8, 5_584);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder114.copyBufferToBuffer(buffer31, 8, buffer13, 9464, 124);
} catch {}
try {
renderPassEncoder28.insertDebugMarker('\u{1fc9e}');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer72 = device0.createBuffer({
  size: 2108,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let renderPassEncoder31 = commandEncoder114.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  depthSlice: 29,
  clearValue: { r: -157.4, g: 895.5, b: 374.1, a: 250.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder83.setBindGroup(1, bindGroup10, new Uint32Array(8104), 1_031, 0);
} catch {}
let arrayBuffer0 = buffer49.getMappedRange(464, 304);
let bindGroup71 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout34,
  entries: [{binding: 79, resource: {buffer: buffer37, offset: 256, size: 388}}],
});
let buffer73 = device0.createBuffer({
  size: 10136,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder115 = device0.createCommandEncoder();
let texture139 = gpuCanvasContext1.getCurrentTexture();
let sampler74 = device0.createSampler({
  label: '\u8cee\u6774\u9cb6',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  maxAnisotropy: 1,
});
try {
renderPassEncoder26.executeBundles([renderBundle9, renderBundle3]);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let autogeneratedBindGroupLayout52 = pipeline11.getBindGroupLayout(0);
let texture140 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder32 = commandEncoder115.beginRenderPass({
  label: '\u06d7\u0e23\u5dc4\u0bb9\uf180\u775b\ue064\u0a3d\u{1fb07}',
  colorAttachments: [{view: textureView21, loadOp: 'load', storeOp: 'store'}],
  maxDrawCount: 168679595,
});
try {
renderPassEncoder6.setBindGroup(3, bindGroup24);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(3, buffer21, 1_128, 233);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let buffer74 = device0.createBuffer({
  size: 1079,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let commandEncoder116 = device0.createCommandEncoder({});
let texture141 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 80},
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder85 = commandEncoder116.beginComputePass({});
try {
renderPassEncoder30.executeBundles([renderBundle6, renderBundle6]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer0, 'uint32', 2_216, 574);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(1, buffer69, 0, 154);
} catch {}
try {
buffer40.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 60, height: 1, depthOrArrayLayers: 12}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture120,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder117 = device0.createCommandEncoder({});
let textureView134 = texture126.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 14});
let computePassEncoder86 = commandEncoder117.beginComputePass({});
try {
computePassEncoder73.setBindGroup(1, bindGroup29);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder27.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder27.setViewport(57.87829525304937, 0.259227304218531, 2.972185131063253, 0.7362187277992114, 0.7249106569980066, 0.7502380766684495);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(5, buffer30);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let texture142 = device0.createTexture({
  size: {width: 60},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
renderPassEncoder2.setBindGroup(3, bindGroup54, new Uint32Array(4568), 546, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let imageData21 = new ImageData(48, 76);
let textureView135 = texture82.createView({dimension: '2d', baseArrayLayer: 33});
try {
computePassEncoder20.setBindGroup(2, bindGroup68);
} catch {}
try {
computePassEncoder39.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer48, 'uint16', 24, 169);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline13);
} catch {}
try {
computePassEncoder10.pushDebugGroup('\u6bca');
} catch {}
let commandEncoder118 = device0.createCommandEncoder({});
let textureView136 = texture95.createView({baseArrayLayer: 18, arrayLayerCount: 5});
let renderPassEncoder33 = commandEncoder118.beginRenderPass({
  colorAttachments: [{
  view: textureView36,
  clearValue: { r: -601.1, g: 223.8, b: -93.69, a: 522.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 70391310,
});
try {
computePassEncoder17.setBindGroup(3, bindGroup64);
} catch {}
try {
computePassEncoder75.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer40, 'uint16', 538, 988);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(7, buffer42, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer67, 80, new Int16Array(10967), 735, 404);
} catch {}
document.body.prepend(img0);
let texture143 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 13},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler75 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder46.setBindGroup(3, bindGroup60);
} catch {}
try {
computePassEncoder62.setBindGroup(1, bindGroup51, new Uint32Array(1927), 289, 0);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline9);
} catch {}
let autogeneratedBindGroupLayout53 = pipeline5.getBindGroupLayout(0);
let bindGroup72 = device0.createBindGroup({layout: veryExplicitBindGroupLayout5, entries: [{binding: 28, resource: textureView110}]});
let commandEncoder119 = device0.createCommandEncoder({});
try {
computePassEncoder42.setBindGroup(0, bindGroup24);
} catch {}
try {
commandEncoder119.copyBufferToTexture({
  /* bytesInLastRow: 776 widthInBlocks: 194 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 280 */
  offset: 280,
  bytesPerRow: 32000,
  buffer: buffer67,
}, {
  texture: texture35,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {width: 194, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder119.clearBuffer(buffer70, 240, 1352);
} catch {}
try {
computePassEncoder31.insertDebugMarker('\u{1fd02}');
} catch {}
try {
device0.queue.writeBuffer(buffer74, 212, new Int16Array(8808), 799, 112);
} catch {}
let buffer75 = device0.createBuffer({
  size: 15407,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder120 = device0.createCommandEncoder({});
let textureView137 = texture5.createView({mipLevelCount: 1, baseArrayLayer: 8, arrayLayerCount: 5});
let sampler76 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 98.33});
try {
computePassEncoder11.setBindGroup(1, bindGroup47, []);
} catch {}
try {
computePassEncoder81.setBindGroup(3, bindGroup49, new Uint32Array(1564), 627, 0);
} catch {}
try {
renderPassEncoder32.setScissorRect(52, 0, 6, 0);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline0);
} catch {}
try {
commandEncoder120.copyBufferToTexture({
  /* bytesInLastRow: 728 widthInBlocks: 91 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2960 */
  offset: 2960,
  bytesPerRow: 43520,
  buffer: buffer24,
}, {
  texture: texture107,
  mipLevel: 0,
  origin: {x: 78, y: 0, z: 0},
  aspect: 'all',
}, {width: 91, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline15 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0x228da9fc},
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{format: 'rgba8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule1,
    constants: {21_537: 0},
    buffers: [
      {
        arrayStride: 396,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 22, shaderLocation: 7},
          {format: 'float16x4', offset: 112, shaderLocation: 11},
          {format: 'float16x4', offset: 136, shaderLocation: 0},
          {format: 'unorm8x4', offset: 28, shaderLocation: 1},
          {format: 'uint16x2', offset: 196, shaderLocation: 15},
          {format: 'snorm16x4', offset: 8, shaderLocation: 14},
          {format: 'sint32x3', offset: 128, shaderLocation: 8},
          {format: 'uint32x3', offset: 72, shaderLocation: 2},
          {format: 'float32x2', offset: 12, shaderLocation: 3},
          {format: 'uint32x4', offset: 192, shaderLocation: 9},
          {format: 'uint8x4', offset: 20, shaderLocation: 5},
          {format: 'uint32x3', offset: 36, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 196, shaderLocation: 4},
          {format: 'sint8x4', offset: 128, shaderLocation: 6},
          {format: 'sint32', offset: 216, shaderLocation: 12},
          {format: 'float16x2', offset: 60, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true},
});
let sampler77 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMinClamp: 74.24, lodMaxClamp: 80.59});
try {
computePassEncoder47.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder10.setScissorRect(0, 8, 13, 4);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline7);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
buffer60.unmap();
} catch {}
let promise18 = device0.queue.onSubmittedWorkDone();
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt709', transfer: 'pq'} });
let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 35,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 67,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 91, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let bindGroup73 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 125, resource: textureView49},
    {binding: 127, resource: {buffer: buffer60, offset: 1536, size: 2662}},
    {binding: 79, resource: {buffer: buffer70, offset: 4096, size: 260}},
  ],
});
let commandEncoder121 = device0.createCommandEncoder({});
let textureView138 = texture71.createView({dimension: '2d-array', format: 'r8unorm', baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder87 = commandEncoder120.beginComputePass();
let renderPassEncoder34 = commandEncoder119.beginRenderPass({
  colorAttachments: [{
  view: textureView52,
  clearValue: { r: -723.2, g: 170.0, b: 642.7, a: 683.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder85.setPipeline(pipeline9);
} catch {}
let pipeline16 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule0, entryPoint: 'fragment0', constants: {}, targets: [{format: 'rg32float'}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 1172,
        attributes: [
          {format: 'uint8x2', offset: 4, shaderLocation: 14},
          {format: 'sint32x3', offset: 288, shaderLocation: 7},
          {format: 'unorm16x4', offset: 144, shaderLocation: 6},
          {format: 'unorm8x2', offset: 274, shaderLocation: 9},
          {format: 'snorm16x4', offset: 52, shaderLocation: 0},
          {format: 'sint32', offset: 196, shaderLocation: 12},
        ],
      },
      {arrayStride: 0, attributes: [{format: 'unorm16x2', offset: 800, shaderLocation: 8}]},
    ],
  },
  primitive: {cullMode: 'back'},
});
let textureView139 = texture134.createView({aspect: 'all'});
let renderPassEncoder35 = commandEncoder121.beginRenderPass({
  colorAttachments: [{
  view: textureView44,
  clearValue: { r: -921.7, g: -907.1, b: -876.0, a: 485.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 160634456,
});
try {
computePassEncoder18.setBindGroup(2, bindGroup52);
} catch {}
try {
computePassEncoder22.setBindGroup(0, bindGroup53, new Uint32Array(677), 94, 0);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(5, buffer58);
} catch {}
document.body.append(canvas2);
let commandEncoder122 = device0.createCommandEncoder({});
let textureView140 = texture46.createView({format: 'rg32float', baseMipLevel: 0, arrayLayerCount: 6});
let renderPassEncoder36 = commandEncoder122.beginRenderPass({
  colorAttachments: [{
  view: textureView6,
  depthSlice: 42,
  clearValue: { r: 427.0, g: -427.8, b: -757.8, a: 600.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder12.setIndexBuffer(buffer52, 'uint32', 40, 523);
} catch {}
let arrayBuffer1 = buffer49.getMappedRange(232, 20);
document.body.prepend(img0);
let autogeneratedBindGroupLayout54 = pipeline0.getBindGroupLayout(1);
try {
computePassEncoder48.setBindGroup(0, bindGroup60, []);
} catch {}
try {
computePassEncoder33.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup1, new Uint32Array(3764), 284, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer8, 'uint32', 796, 1_419);
} catch {}
let texture144 = device0.createTexture({
  size: {width: 2688, height: 1, depthOrArrayLayers: 37},
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder56.setBindGroup(3, bindGroup14, new Uint32Array(367), 28, 0);
} catch {}
try {
computePassEncoder52.setPipeline(pipeline9);
} catch {}
try {
device0.queue.writeBuffer(buffer53, 5672, new BigUint64Array(18403), 3319, 44);
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout31,
  entries: [
    {binding: 125, resource: textureView7},
    {binding: 79, resource: {buffer: buffer75, offset: 5120, size: 65}},
  ],
});
let texture145 = device0.createTexture({
  size: [120, 1, 1],
  dimension: '2d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView141 = texture68.createView({arrayLayerCount: 1});
try {
computePassEncoder64.setBindGroup(2, bindGroup26);
} catch {}
try {
computePassEncoder78.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder13.setViewport(12.415148451986406, 0.018272400156651436, 10.541452001050596, 0.37402220223305943, 0.21501138353886073, 0.2883409434360866);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer0, 'uint16', 350, 737);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline13);
} catch {}
try {
buffer7.unmap();
} catch {}
let autogeneratedBindGroupLayout55 = pipeline8.getBindGroupLayout(0);
let buffer76 = device0.createBuffer({
  size: 38305,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView142 = texture145.createView({});
let textureView143 = texture16.createView({dimension: '2d-array'});
let sampler78 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 99.96});
try {
renderPassEncoder9.setStencilReference(1278);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let textureView144 = texture57.createView({dimension: '1d', format: 'rgba8uint'});
let sampler79 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', lodMaxClamp: 88.25});
try {
computePassEncoder14.setBindGroup(3, bindGroup10, new Uint32Array(348), 29, 0);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup29, new Uint32Array(161), 88, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle3]);
} catch {}
let textureView145 = texture133.createView({});
let sampler80 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.77,
  maxAnisotropy: 18,
});
try {
computePassEncoder31.setBindGroup(3, bindGroup10);
} catch {}
try {
computePassEncoder65.setBindGroup(0, bindGroup33, new Uint32Array(518), 87, 0);
} catch {}
try {
renderPassEncoder35.setVertexBuffer(7, buffer8, 0, 1_217);
} catch {}
await gc();
let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 52,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder123 = device0.createCommandEncoder({});
let renderPassEncoder37 = commandEncoder123.beginRenderPass({
  colorAttachments: [{view: textureView61, depthSlice: 71, loadOp: 'clear', storeOp: 'discard'}],
  maxDrawCount: 224125036,
});
try {
renderPassEncoder1.setIndexBuffer(buffer31, 'uint16', 28, 7);
} catch {}
let arrayBuffer2 = buffer49.getMappedRange(768, 28);
await gc();
let commandEncoder124 = device0.createCommandEncoder({});
let computePassEncoder88 = commandEncoder124.beginComputePass({});
try {
computePassEncoder66.setBindGroup(1, bindGroup50);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup31, new Uint32Array(1842), 58, 0);
} catch {}
try {
renderPassEncoder26.beginOcclusionQuery(74);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture118,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(141).fill(27), /* required buffer size: 141 */
{offset: 141}, {width: 224, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup75 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout11,
  entries: [{binding: 79, resource: {buffer: buffer5, offset: 4608, size: 605}}],
});
let buffer77 = device0.createBuffer({size: 3830, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView146 = texture59.createView({baseArrayLayer: 0, arrayLayerCount: 1});
try {
computePassEncoder14.setBindGroup(0, bindGroup43, new Uint32Array(164), 118, 0);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(139);
} catch {}
try {
renderPassEncoder14.executeBundles([]);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline3);
} catch {}
let buffer78 = device0.createBuffer({
  size: 2362,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView147 = texture145.createView({arrayLayerCount: 1});
let texture146 = device0.createTexture({
  size: {width: 30},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler81 = device0.createSampler({addressModeW: 'repeat'});
let externalTexture13 = device0.importExternalTexture({source: videoFrame15});
try {
computePassEncoder14.setBindGroup(2, bindGroup37);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer72, 'uint32', 536, 501);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let imageData22 = new ImageData(20, 112);
let commandEncoder125 = device0.createCommandEncoder({});
let texture147 = device0.createTexture({size: [30, 1, 1], format: 'rgba8unorm-srgb', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
let texture148 = device0.createTexture({
  size: [60],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView148 = texture45.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 8, arrayLayerCount: 13});
let computePassEncoder89 = commandEncoder125.beginComputePass({});
try {
computePassEncoder54.setBindGroup(1, bindGroup58, new Uint32Array(6936), 1_121, 0);
} catch {}
try {
computePassEncoder77.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup3, []);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture118,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(777).fill(120), /* required buffer size: 777 */
{offset: 777}, {width: 191, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 13}
*/
{
  source: imageData19,
  origin: { x: 0, y: 6 },
  flipY: false,
}, {
  texture: texture143,
  mipLevel: 1,
  origin: {x: 1, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await promise18;
} catch {}
let buffer79 = device0.createBuffer({size: 30368, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder126 = device0.createCommandEncoder();
let computePassEncoder90 = commandEncoder126.beginComputePass();
try {
computePassEncoder46.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(5, buffer57);
} catch {}
try {
device0.queue.writeBuffer(buffer70, 716, new BigUint64Array(10773), 462, 8);
} catch {}
await gc();
let texture149 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 57},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler82 = device0.createSampler({
  label: '\u0065\u{1fee0}\u8a24',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 97.52,
});
try {
computePassEncoder6.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder31.setPipeline(pipeline15);
} catch {}
let imageData23 = new ImageData(40, 80);
let commandEncoder127 = device0.createCommandEncoder({});
let texture150 = device0.createTexture({
  label: '\u18eb\uf42f',
  size: [128, 128, 13],
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView149 = texture135.createView({format: 'rg32float'});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle12 = renderBundleEncoder12.finish({});
let sampler83 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 72.19, compare: 'not-equal'});
try {
computePassEncoder74.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder21.setScissorRect(37, 0, 25, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer41, 'uint32', 1_652, 1_883);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let autogeneratedBindGroupLayout56 = pipeline5.getBindGroupLayout(1);
let buffer80 = device0.createBuffer({size: 1850, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let renderPassEncoder38 = commandEncoder127.beginRenderPass({
  colorAttachments: [{
  view: textureView52,
  clearValue: { r: 718.6, g: -409.4, b: -128.7, a: -996.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], depthReadOnly: true});
try {
computePassEncoder38.setBindGroup(3, bindGroup9);
} catch {}
try {
computePassEncoder89.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer16, 'uint16', 200, 1_531);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer41, 'uint16', 258, 1_415);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture89,
  mipLevel: 0,
  origin: {x: 97, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(67_064).fill(99), /* required buffer size: 67_064 */
{offset: 32, bytesPerRow: 342, rowsPerImage: 28}, {width: 46, height: 0, depthOrArrayLayers: 8});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder128 = device0.createCommandEncoder({});
let renderPassEncoder39 = commandEncoder128.beginRenderPass({
  colorAttachments: [{
  view: textureView112,
  depthSlice: 3,
  clearValue: { r: 523.3, g: 724.7, b: -136.4, a: -865.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 349718869,
});
let renderBundle13 = renderBundleEncoder13.finish({});
try {
computePassEncoder86.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer31, 'uint32', 168, 54);
} catch {}
let arrayBuffer3 = buffer49.getMappedRange(976, 156);
await gc();
let bindGroup76 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 79, resource: {buffer: buffer45, offset: 512, size: 7551}}],
});
let commandEncoder129 = device0.createCommandEncoder({});
let querySet15 = device0.createQuerySet({type: 'occlusion', count: 302});
try {
computePassEncoder31.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(2, buffer55);
} catch {}
try {
computePassEncoder10.popDebugGroup();
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\u87f7');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 240, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture63,
  mipLevel: 0,
  origin: {x: 60, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let autogeneratedBindGroupLayout57 = pipeline4.getBindGroupLayout(0);
let texture151 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView150 = texture38.createView({label: '\u08a4\u00e7\u4fd1\u{1fdff}\u07c1', mipLevelCount: 1});
let sampler84 = device0.createSampler({addressModeU: 'mirror-repeat'});
try {
computePassEncoder22.end();
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle5]);
} catch {}
let imageData24 = new ImageData(24, 20);
let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 23,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let autogeneratedBindGroupLayout58 = pipeline7.getBindGroupLayout(0);
let commandBuffer3 = commandEncoder30.finish();
try {
computePassEncoder85.setBindGroup(1, bindGroup52);
} catch {}
try {
computePassEncoder72.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder33.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(1, buffer7, 0, 68);
} catch {}
try {
buffer28.unmap();
} catch {}
try {
commandEncoder129.resolveQuerySet(querySet15, 56, 56, buffer9, 512);
} catch {}
try {
computePassEncoder49.setBindGroup(3, bindGroup47, new Uint32Array(569), 84, 0);
} catch {}
try {
computePassEncoder74.setPipeline(pipeline14);
} catch {}
try {
commandEncoder129.resolveQuerySet(querySet9, 203, 122, buffer29, 0);
} catch {}
try {
adapter0.label = '\u7907\ueb79\u{1f61f}\ua7a9';
} catch {}
let renderPassEncoder40 = commandEncoder129.beginRenderPass({
  colorAttachments: [{
  view: textureView110,
  depthSlice: 2,
  clearValue: { r: -623.7, g: 1.277, b: -819.4, a: -268.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder39.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer51, 0, 480);
} catch {}
let offscreenCanvas2 = new OffscreenCanvas(427, 389);
let bindGroup77 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout18,
  entries: [{binding: 79, resource: {buffer: buffer79, offset: 9216}}, {binding: 125, resource: textureView2}],
});
let texture152 = device0.createTexture({size: [336, 1, 1], mipLevelCount: 5, format: 'rg32float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView151 = texture94.createView({baseMipLevel: 0});
try {
computePassEncoder79.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup23);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(49);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, buffer25, 0, 211);
} catch {}
let bindGroup78 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout57,
  entries: [
    {binding: 125, resource: textureView2},
    {binding: 79, resource: {buffer: buffer12, offset: 4352, size: 1818}},
  ],
});
let buffer81 = device0.createBuffer({
  size: 9905,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let textureView152 = texture145.createView({dimension: '2d-array'});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rg32float']});
try {
computePassEncoder19.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup25, new Uint32Array(3062), 43, 0);
} catch {}
try {
renderPassEncoder38.end();
} catch {}
try {
renderPassEncoder20.beginOcclusionQuery(125);
} catch {}
try {
renderPassEncoder5.setBlendConstant({ r: 645.3, g: 686.4, b: 457.4, a: 772.2, });
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer12, 'uint32', 976, 1_219);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup25);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup14, new Uint32Array(3158), 198, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline0);
} catch {}
try {
commandEncoder127.copyBufferToTexture({
  /* bytesInLastRow: 1828 widthInBlocks: 457 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1472 */
  offset: 1472,
  buffer: buffer65,
}, {
  texture: texture118,
  mipLevel: 0,
  origin: {x: 245, y: 0, z: 0},
  aspect: 'all',
}, {width: 457, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let autogeneratedBindGroupLayout59 = pipeline13.getBindGroupLayout(0);
let commandEncoder130 = device0.createCommandEncoder({});
let texture153 = device0.createTexture({
  size: [120, 1, 1],
  sampleCount: 4,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder91 = commandEncoder127.beginComputePass({});
let renderPassEncoder41 = commandEncoder130.beginRenderPass({
  colorAttachments: [{
  view: textureView95,
  depthSlice: 257,
  clearValue: { r: 833.4, g: -72.60, b: 609.9, a: 203.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 287919952,
});
let renderBundle14 = renderBundleEncoder14.finish({});
try {
computePassEncoder57.setBindGroup(0, bindGroup68);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
buffer29.unmap();
} catch {}
let commandEncoder131 = device0.createCommandEncoder({});
let texture154 = device0.createTexture({
  size: {width: 336, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView153 = texture121.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder92 = commandEncoder131.beginComputePass();
try {
renderPassEncoder1.setPipeline(pipeline0);
} catch {}
let autogeneratedBindGroupLayout60 = pipeline8.getBindGroupLayout(1);
let texture155 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder57.setBindGroup(1, bindGroup50);
} catch {}
try {
computePassEncoder66.setBindGroup(0, bindGroup28, new Uint32Array(8), 0, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer71, 'uint16', 1_070, 116);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline3);
} catch {}
try {
buffer25.unmap();
} catch {}
let commandEncoder132 = device0.createCommandEncoder({});
let querySet16 = device0.createQuerySet({type: 'occlusion', count: 268});
let textureView154 = texture155.createView({});
let sampler85 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 95.20});
try {
commandEncoder132.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 0 */
  offset: 0,
  bytesPerRow: 29952,
  buffer: buffer26,
}, {
  texture: texture28,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder93 = commandEncoder132.beginComputePass({});
let sampler86 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 68.06,
});
try {
computePassEncoder19.setBindGroup(1, bindGroup4, new Uint32Array(705), 13, 0);
} catch {}
try {
computePassEncoder92.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder20.endOcclusionQuery();
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer80, 'uint32', 604, 45);
} catch {}
try {
renderPassEncoder37.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(2, buffer38, 0, 570);
} catch {}
document.body.prepend(canvas0);
let buffer82 = device0.createBuffer({
  size: 2608,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder60.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder41.setPipeline(pipeline13);
} catch {}
let texture156 = device0.createTexture({size: [30, 1, 12], format: 'rgba8uint', usage: GPUTextureUsage.COPY_SRC, viewFormats: []});
try {
computePassEncoder65.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder25.setBindGroup(1, bindGroup56, new Uint32Array(511), 0, 0);
} catch {}
try {
renderPassEncoder26.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setStencilReference(248);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 1540, new Float32Array(10837), 978, 1848);
} catch {}
let imageData25 = new ImageData(96, 60);
try {
commandEncoder47.label = '\ub008\u330d\u0aed\u3f31\u{1f6ad}';
} catch {}
let texture157 = device0.createTexture({
  size: [672, 1, 300],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView155 = texture122.createView({baseMipLevel: 0});
let sampler87 = device0.createSampler({addressModeW: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 70.27, maxAnisotropy: 1});
try {
renderPassEncoder8.setBindGroup(1, bindGroup52, new Uint32Array(909), 22, 0);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline13);
} catch {}
document.body.append(img1);
let buffer83 = device0.createBuffer({size: 22256, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder133 = device0.createCommandEncoder({});
let texture158 = device0.createTexture({
  size: [128, 128, 13],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder94 = commandEncoder133.beginComputePass({});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true});
try {
renderPassEncoder19.setVertexBuffer(6, buffer66, 460);
} 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,
  colorSpace: 'display-p3',
});
} catch {}
let pipeline17 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1}});
let autogeneratedBindGroupLayout61 = pipeline2.getBindGroupLayout(0);
try {
computePassEncoder73.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup75);
} catch {}
try {
renderPassEncoder34.setViewport(64.47170709762158, 0.557859403130881, 395.54836586013937, 0.25130381443580135, 0.6330603133715412, 0.9612061553578906);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer76, 16_668, 1_963);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(6, buffer63, 0, 658);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let sampler88 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 17,
});
try {
computePassEncoder32.setBindGroup(1, bindGroup56);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup59);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup7);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup12, new Uint32Array(134), 15, 0);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(2, undefined, 150_115_051);
} catch {}
try {
computePassEncoder30.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder27.setBindGroup(0, bindGroup60, []);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer63, 3_172);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup52);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(6, buffer37, 0, 650);
} catch {}
await gc();
let autogeneratedBindGroupLayout62 = pipeline4.getBindGroupLayout(0);
let bindGroup79 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout58,
  entries: [
    {binding: 79, resource: {buffer: buffer60, offset: 768, size: 1139}},
    {binding: 125, resource: textureView7},
  ],
});
let textureView156 = texture128.createView({baseArrayLayer: 0});
try {
computePassEncoder1.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder23.setBindGroup(0, bindGroup25);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup37, new Uint32Array(289), 73, 0);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer70, 'uint16', 5_324, 3_162);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(4, buffer30, 404);
} catch {}
try {
device0.queue.writeBuffer(buffer58, 20272, new Int16Array(28447), 9657, 1480);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture117,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(239).fill(131), /* required buffer size: 239 */
{offset: 239}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt470bg', transfer: 'iec61966-2-1'} });
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

@group(0) @binding(175) var<uniform> buffer84: vec4i;

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

struct FragmentOutput2 {
  @location(7) @interpolate(flat, center) f0: i32,
  @location(4) @interpolate(flat, centroid) f1: i32,
  @location(0) @interpolate(flat) f2: vec2i,
}

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

struct VertexOutput2 {
  @location(4) @interpolate(flat, centroid) f3: i32,
  @builtin(position) f4: vec4f,
}

struct VertexOutput3 {
  @builtin(position) f5: vec4f,
}

@group(0) @binding(75) var st7: texture_storage_2d<r32float, read_write>;

var<workgroup> vw18: atomic<i32>;

@group(0) @binding(19) var tex3: texture_cube<f32>;

@group(0) @binding(112) var sam1: sampler;

var<workgroup> vw17: mat4x2h;

var<workgroup> vw16: VertexOutput4;

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

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

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

var<workgroup> vw19: mat2x4h;

var<private> vp10: VertexOutput4 = VertexOutput4(vec4f(0.08265, 0.7424, 0.05720, 0.00360));

struct S5 {
  @location(9) @interpolate(perspective) f0: vec2f,
  @location(1) f1: i32,
}

var<private> vp11 = modf(vec3f(0.2524, 0.3680, 0.1514));

var<private> vp12 = array(modf(vec2h(5078.3, 35826.1)));

override override19: u32;

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

struct T0 {
  f0: vec2f,
  @align(8) @size(240) f1: mat4x2h,
}

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

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

var<private> vp9 = modf(vec4f(-0.1277, 0.1547, 0.2993, 0.3876));

@vertex
fn vertex3(@location(12) @interpolate(flat, center) a0: vec2i) -> VertexOutput2 {
  var out: VertexOutput2;
  vp12[u32(unconst_u32(98))].whole *= vp12[0].whole;
  vp12[u32(textureSampleGrad(tex3, sam1, vp9.whole.abr, vec3f(unconst_f32(-0.1185), unconst_f32(0.03789), unconst_f32(0.00144)), vec3f(unconst_f32(0.08746), unconst_f32(0.1449), unconst_f32(0.01385)))[1])] = modf(bitcast<vec2h>(textureNumLevels(tex3)));
  var vf40: vec2i = a0;
  out.f3 = vf40[u32(unconst_u32(254))];
  var vf41: i32 = a0[u32(unconst_u32(81))];
  let ptr38 = &vp11;
  vp12[u32(unconst_u32(94))] = modf(vec2h(textureSampleGrad(tex3, sam1, textureSampleLevel(tex3, sam1, vec3f(unconst_f32(-0.01620), unconst_f32(0.1743), unconst_f32(0.2235)), f32(unconst_f32(0.07446))).zzy, vec3f(unconst_f32(0.05194), unconst_f32(0.09049), unconst_f32(0.07972)), vec3f(unconst_f32(0.1549), unconst_f32(0.01036), unconst_f32(0.2042))).yy));
  let vf42: vec2u = textureDimensions(tex3);
  let vf43: u32 = vf42[u32(unconst_u32(196))];
  let ptr39: ptr<private, vec4f> = &vp9.fract;
  let ptr40: ptr<uniform, vec4i> = &buffer84;
  out.f4 -= vec4f(vp12[0].fract.rgrg);
  var vf44: vec4f = textureSampleGrad(tex3, sam1, vec3f(unconst_f32(0.1224), unconst_f32(0.3203), unconst_f32(0.01339)), vec3f(unconst_f32(0.4645), unconst_f32(0.08643), unconst_f32(-0.2004)), vec3f(unconst_f32(-0.09008), unconst_f32(0.05546), unconst_f32(0.3568)));
  let vf45: vec4u = unpack4xU8(u32(unconst_u32(71)));
  let vf46: f32 = vp10.f6[u32(unconst_u32(66))];
  let ptr41: ptr<uniform, vec4i> = &(*ptr40);
  out.f3 = i32((*ptr38).whole[2]);
  out = VertexOutput2(bitcast<vec4i>(unpack4x8unorm(u32(unconst_u32(23)))).g, unpack4x8unorm(u32(unconst_u32(23))));
  var vf47: vec4f = unpack4x8unorm(u32(unconst_u32(181)));
  let vf48: i32 = (*ptr40)[u32(unconst_u32(164))];
  vf41 &= vf48;
  let ptr42: ptr<uniform, vec4i> = &(*ptr40);
  let ptr43: ptr<uniform, vec4i> = &(*ptr41);
  var vf49: u32 = textureNumLevels(tex3);
  return out;
  _ = buffer84;
  _ = sam1;
  _ = tex3;
}

@vertex @must_use
fn vertex4(a0: S5, @location(11) @interpolate(flat, center) a1: f16, @location(15) a2: vec2f) -> VertexOutput3 {
  var out: VertexOutput3;
  vp9 = modf(vec4f(a0.f0[u32(unconst_u32(121))]));
  var vf50: f32 = abs(f32(unconst_f32(0.06485)));
  out.f5 += vec4f(vp12[0].fract.rggg);
  out.f5 -= bitcast<vec4f>(textureDimensions(tex3, i32(fract(vec2f(unconst_f32(0.1456), unconst_f32(-0.2436))).y)).xxyx);
  let ptr44: ptr<private, vec2h> = &vp12[pack4x8unorm(vp9.whole)].fract;
  var vf51: vec2f = a0.f0;
  out.f5 -= unpack4x8snorm(textureNumLevels(tex3));
  vp10.f6 = vec4f(a0.f0[u32(unconst_u32(39))]);
  let ptr45: ptr<uniform, vec4i> = &buffer84;
  var vf52: vec4f = textureGather(306 % 4, tex3, sam1, vec3f(unconst_f32(0.2062), unconst_f32(0.3429), unconst_f32(0.04731)));
  out.f5 = vec4f(vp10.f6[u32(unconst_u32(121))]);
  return out;
  _ = tex3;
  _ = sam1;
  _ = buffer84;
}

@vertex
fn vertex5(@location(10) @interpolate(perspective) a0: vec4h, @location(9) @interpolate(linear, center) a1: vec4h) -> VertexOutput4 {
  var out: VertexOutput4;
  let vf53: vec3h = atanh(vec3h(unconst_f16(19361.1), unconst_f16(1259.7), unconst_f16(1975.4)));
  vp9.fract = refract(vec4f(unconst_f32(0.04387), unconst_f32(0.1910), unconst_f32(-0.01275), unconst_f32(0.09991)), vec4f(unconst_f32(0.01378), unconst_f32(0.2726), unconst_f32(0.1549), unconst_f32(0.08146)), f32(unconst_f32(0.2626)));
  out = VertexOutput4(vec4f(fract(vec2h(unconst_f16(14563.1), unconst_f16(2017.8))).yxxy));
  vp10.f6 = vec4f(f32(vf53[u32(unconst_u32(47))]));
  var vf54: vec3f = tanh(vec3f(extractBits(vec3u(unconst_u32(264), unconst_u32(163), unconst_u32(551)), u32(unconst_u32(371)), u32(unconst_u32(117)))));
  out.f6 -= vec4f(vp12[u32(unconst_u32(48))].fract.rrgr);
  let ptr46: ptr<uniform, vec4i> = &buffer84;
  vf54 *= vec3f(f32(a0[u32(unconst_u32(118))]));
  return out;
  _ = buffer84;
}

@fragment
fn fragment3() -> FragmentOutput2 {
  var out: FragmentOutput2;
  let vf55: vec2f = faceForward(vec2f(unconst_f32(-0.04812), unconst_f32(0.2551)), vec2f(unconst_f32(0.00171), unconst_f32(0.08065)), vec2f(unconst_f32(0.07328), unconst_f32(0.4741)));
  vp10.f6 = vec4f(vp12[0].fract.rrrg);
  vp9.fract *= vec4f(vp12[0].fract.ggrr);
  vp12[u32(unconst_u32(134))] = modf(vec2h(vp10.f6.ww));
  var vf56: vec2f = vf55;
  var vf57: vec4f = reflect(vec4f(unconst_f32(0.00439), unconst_f32(-0.1063), unconst_f32(0.03872), unconst_f32(0.06135)), vec4f(unconst_f32(0.06087), unconst_f32(0.4852), unconst_f32(-0.00068), unconst_f32(0.08482)));
  let ptr47: ptr<private, vec4f> = &vp9.fract;
  out.f2 ^= vec2i(vp12[u32(unconst_u32(351))].fract);
  discard;
  discard;
  vp12[u32(unconst_u32(14))].whole -= vec2h(vp10.f6.rb);
  let ptr48: ptr<private, VertexOutput4> = &vp10;
  var vf58: vec2f = faceForward(vec2f(vf56[u32(unconst_u32(451))]), vec2f(unconst_f32(0.4649), unconst_f32(0.07502)), vec2f(unconst_f32(0.01949), unconst_f32(0.1417)));
  let vf59: f32 = (*ptr47)[u32(unconst_u32(143))];
  out.f0 -= bitcast<i32>((*ptr48).f6[u32(unconst_u32(304))]);
  let ptr49 = &vp12[0];
  let ptr50 = &vp12[u32(unconst_u32(40))];
  vp9.fract += vec4f((*ptr50).whole.ggrr);
  let ptr51: ptr<private, vec2h> = &(*ptr49).fract;
  return out;
}

@compute @workgroup_size(2, 1, 1)
fn compute2() {
  var vf60: f16 = cosh(f16(unconst_f16(2012.5)));
  let ptr52 = &vp12[0];
  var vf61: vec2f = acos(vec2f(unconst_f32(-0.2040), unconst_f32(0.2535)));
  let ptr53: ptr<private, vec2h> = &(*ptr52).fract;
  var vf62: u32 = atomicLoad(&(*&vw20)[u32(unconst_u32(310))]);
  let vf63: u32 = atomicExchange(&vw20[0], u32(unconst_u32(169)));
  let ptr54: ptr<workgroup, atomic<u32>> = &(*&vw20)[0];
  var vf64: vec3i = reverseBits(vec3i(unconst_i32(227), unconst_i32(58), unconst_i32(30)));
  vp11 = modf(vec3f(vp12[0].fract.grr));
  var vf65: vec4h = (*&vw19)[u32(unconst_u32(47))];
  vw19 -= mat2x4h(bitcast<vec4h>(textureDimensions(st7)), bitcast<vec4h>(textureDimensions(st7)));
  let vf66: mat4x2h = workgroupUniformLoad(&vw17);
  let vf67: vec3h = fma(vec3h(unconst_f16(954.5), unconst_f16(6002.8), unconst_f16(1012.3)), vec3h(unconst_f16(10507.7), unconst_f16(3334.7), unconst_f16(5760.0)), vec3h(unconst_f16(14231.5), unconst_f16(12644.9), unconst_f16(40891.2)));
  let ptr55: ptr<private, vec3f> = &vp11.fract;
  var vf68: f32 = log(f32(unconst_f32(0.07633)));
  vp10.f6 *= vec4f(f32(atomicExchange(&vw18, i32(unconst_i32(32)))));
  let vf69: u32 = atomicLoad(&(*&vw20)[u32(unconst_u32(193))]);
  vw17 = mat4x2h(vec2h(vp10.f6.gg), vec2h(vp10.f6.ba), vec2h(vp10.f6.wz), vec2h(vp10.f6.xx));
  let ptr56: ptr<private, vec3f> = &vp11.fract;
  _ = st7;
}`,
});
let autogeneratedBindGroupLayout63 = pipeline15.getBindGroupLayout(0);
let bindGroup80 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout36,
  entries: [
    {binding: 79, resource: {buffer: buffer63, offset: 4096, size: 1921}},
    {binding: 125, resource: textureView2},
  ],
});
let textureView157 = texture145.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder16.setBindGroup(3, bindGroup12);
} catch {}
try {
computePassEncoder87.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer15, 'uint32', 64, 267);
} catch {}
try {
renderBundleEncoder15.setBindGroup(1, bindGroup33);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup75, new Uint32Array(3927), 1_050, 0);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(0, undefined, 11_024_870, 109_634_161);
} catch {}
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpteRp431', transfer: 'unspecified'} });
let bindGroup81 = device0.createBindGroup({
  label: '\u0720\u98e2\u9ed7',
  layout: veryExplicitBindGroupLayout2,
  entries: [{binding: 28, resource: textureView1}],
});
let renderBundle15 = renderBundleEncoder15.finish();
try {
renderPassEncoder5.setBindGroup(1, bindGroup56);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer66, 3_192);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
globalThis.someLabel = bindGroup42.label;
} catch {}
let autogeneratedBindGroupLayout64 = pipeline7.getBindGroupLayout(1);
let texture159 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 40},
  mipLevelCount: 2,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder50.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(22);
} catch {}
let commandEncoder134 = device0.createCommandEncoder({});
let computePassEncoder95 = commandEncoder134.beginComputePass({});
try {
renderPassEncoder36.setPipeline(pipeline7);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture107,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(58).fill(37), /* required buffer size: 58 */
{offset: 58, bytesPerRow: 566}, {width: 64, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup82 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout14,
  entries: [
    {binding: 125, resource: textureView49},
    {binding: 79, resource: {buffer: buffer5, offset: 2816, size: 276}},
  ],
});
let sampler89 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 75.59});
let externalTexture14 = device0.importExternalTexture({source: videoFrame10});
try {
renderPassEncoder34.setBindGroup(0, bindGroup73);
} catch {}
try {
renderPassEncoder32.setBindGroup(2, bindGroup24, new Uint32Array(133), 51, 0);
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer63, 'uint32', 4_832, 425);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer83, 2_488);
} catch {}
let pipeline18 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute1'}});
await gc();
let commandEncoder135 = device0.createCommandEncoder({});
let textureView158 = texture115.createView({mipLevelCount: 1});
let computePassEncoder96 = commandEncoder135.beginComputePass();
try {
computePassEncoder87.setBindGroup(3, bindGroup80);
} catch {}
try {
renderPassEncoder33.setBindGroup(2, bindGroup64);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline13);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.append(canvas0);
let autogeneratedBindGroupLayout65 = pipeline1.getBindGroupLayout(1);
let bindGroup83 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout44,
  entries: [{binding: 79, resource: {buffer: buffer19, offset: 5888, size: 9504}}],
});
let commandEncoder136 = device0.createCommandEncoder({});
let computePassEncoder97 = commandEncoder136.beginComputePass({});
try {
computePassEncoder43.setBindGroup(2, bindGroup41, new Uint32Array(37), 6, 0);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline9);
} catch {}
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'bt1361ExtendedColourGamut'} });
try {
computePassEncoder90.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder34.setBindGroup(3, bindGroup47);
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
canvas3.height = 1979;
let buffer85 = device0.createBuffer({size: 11981, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let querySet17 = device0.createQuerySet({type: 'occlusion', count: 275});
try {
computePassEncoder86.setBindGroup(3, bindGroup37);
} catch {}
try {
computePassEncoder94.setBindGroup(1, bindGroup50, new Uint32Array(839), 232, 0);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle6, renderBundle13]);
} catch {}
let autogeneratedBindGroupLayout66 = pipeline7.getBindGroupLayout(0);
let bindGroup84 = device0.createBindGroup({layout: veryExplicitBindGroupLayout9, entries: [{binding: 352, resource: textureView90}]});
let buffer86 = device0.createBuffer({size: 28545, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
computePassEncoder92.setBindGroup(2, bindGroup32);
} catch {}
try {
computePassEncoder96.setPipeline(pipeline9);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
offscreenCanvas2.getContext('webgl2');
} catch {}
let bindGroup85 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout50,
  entries: [{binding: 79, resource: {buffer: buffer63, offset: 3328}}],
});
let texture160 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 303},
  mipLevelCount: 8,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder69.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(1, buffer1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture89,
  mipLevel: 0,
  origin: {x: 24, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(251_450).fill(224), /* required buffer size: 251_450 */
{offset: 386, bytesPerRow: 951, rowsPerImage: 132}, {width: 235, height: 0, depthOrArrayLayers: 3});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas1);
let imageBitmap3 = await createImageBitmap(imageData17);
try {
adapter0.label = '\u18ba\u1c1b';
} catch {}
let bindGroup86 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 79, resource: {buffer: buffer45, offset: 2816, size: 2242}}],
});
let textureView159 = texture56.createView({});
let texture161 = device0.createTexture({
  label: '\u2ea0\u0564\u310f\u06f6',
  size: [576],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder26.setIndexBuffer(buffer63, 'uint16', 2_234, 540);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(5, buffer8, 4_160);
} catch {}
try {
device0.queue.writeBuffer(buffer44, 1096, new BigUint64Array(11));
} catch {}
let commandEncoder137 = device0.createCommandEncoder({});
let textureView160 = texture155.createView({});
let textureView161 = texture133.createView({});
try {
renderPassEncoder13.setBindGroup(0, bindGroup55, new Uint32Array(40), 2, 0);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(1);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder33.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer66, 0, 727);
} catch {}
try {
commandEncoder137.copyBufferToBuffer(buffer11, 1328, buffer6, 5500, 240);
} catch {}
try {
commandEncoder137.copyTextureToBuffer({
  texture: texture58,
  mipLevel: 0,
  origin: {x: 35, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 104 widthInBlocks: 26 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5532 */
  offset: 5532,
  rowsPerImage: 272,
  buffer: buffer47,
}, {width: 26, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder138 = device0.createCommandEncoder({});
let textureView162 = texture60.createView({mipLevelCount: 1});
let computePassEncoder98 = commandEncoder138.beginComputePass({});
let renderPassEncoder42 = commandEncoder137.beginRenderPass({
  colorAttachments: [{
  view: textureView36,
  clearValue: { r: 877.6, g: -420.8, b: 430.1, a: -414.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet5,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup78, new Uint32Array(540), 227, 0);
} catch {}
try {
computePassEncoder83.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer8, 'uint32', 10_800, 2_550);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture141,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(231_552).fill(48), /* required buffer size: 231_552 */
{offset: 27, bytesPerRow: 525, rowsPerImage: 9}, {width: 96, height: 0, depthOrArrayLayers: 50});
} catch {}
let imageData26 = new ImageData(20, 52);
let commandEncoder139 = device0.createCommandEncoder({});
let computePassEncoder99 = commandEncoder139.beginComputePass({});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true});
try {
computePassEncoder69.setBindGroup(0, bindGroup9);
} catch {}
let commandEncoder140 = device0.createCommandEncoder();
let renderBundle16 = renderBundleEncoder16.finish({});
try {
computePassEncoder67.setBindGroup(0, bindGroup45);
} catch {}
try {
computePassEncoder91.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder32.setBindGroup(1, bindGroup12);
} catch {}
try {
renderPassEncoder22.setViewport(100.03888064151997, 0.2679214945289504, 94.95904864927863, 0.05689805521498851, 0.2348589460189523, 0.3795046150189143);
} catch {}
try {
commandEncoder140.insertDebugMarker('\u07a0');
} catch {}
let buffer87 = device0.createBuffer({
  label: '\u{1fbd7}\uc54c\uc633\u{1f8a2}\u055f\u42da\u1d6e\u00eb\u5255\uac37',
  size: 29861,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
});
let externalTexture15 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder71.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(13);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer87, 'uint16', 4_988, 1_141);
} catch {}
try {
commandEncoder140.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 9416 */
  offset: 9416,
  bytesPerRow: 7680,
  buffer: buffer75,
}, {
  texture: texture7,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 1},
  aspect: 'all',
}, {width: 0, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder22.insertDebugMarker('\u{1fde9}');
} catch {}
try {
device0.queue.submit([]);
} catch {}
let computePassEncoder100 = commandEncoder140.beginComputePass({});
try {
computePassEncoder38.setBindGroup(0, bindGroup67, new Uint32Array(1285), 170, 0);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle13, renderBundle5, renderBundle6]);
} catch {}
try {
renderPassEncoder2.setScissorRect(21, 0, 180, 0);
} catch {}
let arrayBuffer4 = buffer49.getMappedRange(1136, 152);
try {
buffer65.unmap();
} catch {}
try {
computePassEncoder87.setBindGroup(3, bindGroup14);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(1, buffer57, 632, 452);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let sampler90 = device0.createSampler({addressModeU: 'mirror-repeat', compare: 'always'});
try {
computePassEncoder38.setBindGroup(1, bindGroup5);
} catch {}
try {
computePassEncoder68.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(7, buffer57);
} catch {}
try {
device0.queue.writeBuffer(buffer26, 1620, new DataView(new ArrayBuffer(1110)), 205, 428);
} catch {}
let commandEncoder141 = device0.createCommandEncoder({});
let renderPassEncoder43 = commandEncoder141.beginRenderPass({
  colorAttachments: [{
  view: textureView150,
  depthSlice: 22,
  clearValue: { r: 676.0, g: 592.5, b: -644.0, a: -396.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle17 = renderBundleEncoder17.finish({});
try {
computePassEncoder7.setBindGroup(2, bindGroup31);
} catch {}
try {
computePassEncoder37.setBindGroup(2, bindGroup71, new Uint32Array(2086), 188, 0);
} catch {}
try {
computePassEncoder95.setPipeline(pipeline9);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData5,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 1,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture162 = device0.createTexture({
  size: {width: 672, height: 1, depthOrArrayLayers: 69},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let sampler91 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 85.10});
try {
renderPassEncoder26.executeBundles([renderBundle7]);
} catch {}
try {
computePassEncoder84.setBindGroup(1, bindGroup56);
} catch {}
try {
computePassEncoder95.setBindGroup(1, bindGroup49, new Uint32Array(2794), 106, 0);
} catch {}
try {
renderPassEncoder41.executeBundles([renderBundle6, renderBundle6]);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer35, 'uint32', 420, 139);
} catch {}
try {
renderPassEncoder18.insertDebugMarker('\u{1feff}');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let buffer88 = device0.createBuffer({
  size: 914,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder142 = device0.createCommandEncoder({});
let texture163 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 380},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder101 = commandEncoder142.beginComputePass({});
try {
computePassEncoder68.setBindGroup(3, bindGroup30);
} catch {}
try {
computePassEncoder47.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup46);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup19, new Uint32Array(1345), 251, 0);
} catch {}
try {
renderPassEncoder0.setViewport(5.514738317068108, 0.7874171581251046, 10.028588144575192, 0.06489058788811729, 0.9354198779731311, 0.9567396174634041);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(3, buffer82, 248, 570);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'film', transfer: 'smpteSt4281'} });
try {
renderPassEncoder25.setPipeline(pipeline13);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture107,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline19 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute0', constants: {override14: 0}}});
try {
bindGroup43.label = '\u0d3b\u6d11\u01eb\u{1f7e9}\uae1a\u{1fdba}\u0c98\u68b1\u{1f78e}\u{1f889}';
} catch {}
try {
computePassEncoder100.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup30, new Uint32Array(4854), 709, 0);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer15, 'uint16', 246, 281);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 9, y: 4 },
  flipY: true,
}, {
  texture: texture140,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup87 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 28, resource: textureView1}]});
try {
computePassEncoder82.setBindGroup(0, bindGroup43);
} catch {}
try {
computePassEncoder47.setBindGroup(3, bindGroup31, new Uint32Array(2681), 603, 0);
} catch {}
try {
computePassEncoder84.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup16, new Uint32Array(278), 0, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer12, 'uint32', 1_592, 1_735);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
let img2 = await imageWithData(83, 14, '#10101010', '#20202020');
let autogeneratedBindGroupLayout67 = pipeline4.getBindGroupLayout(1);
let bindGroup88 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout64,
  entries: [{binding: 79, resource: {buffer: buffer69, offset: 256, size: 38}}],
});
let buffer89 = device0.createBuffer({
  size: 16984,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder143 = device0.createCommandEncoder({});
let renderPassEncoder44 = commandEncoder143.beginRenderPass({
  colorAttachments: [{
  view: textureView156,
  depthSlice: 48,
  clearValue: { r: -917.0, g: 620.2, b: -452.9, a: -803.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 210802162,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup61);
} catch {}
try {
computePassEncoder101.setBindGroup(0, bindGroup24, new Uint32Array(1579), 40, 0);
} catch {}
try {
renderPassEncoder32.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(3, buffer37, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 23}
*/
{
  source: imageData4,
  origin: { x: 0, y: 3 },
  flipY: true,
}, {
  texture: texture79,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline20 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule2,
  constants: {},
  targets: [{format: 'rgba8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule1,
    constants: {21_537: 0},
    buffers: [
      {
        arrayStride: 496,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 64, shaderLocation: 4},
          {format: 'sint32', offset: 268, shaderLocation: 8},
          {format: 'uint16x4', offset: 156, shaderLocation: 5},
          {format: 'uint32', offset: 128, shaderLocation: 2},
          {format: 'sint32x3', offset: 44, shaderLocation: 6},
          {format: 'sint8x4', offset: 72, shaderLocation: 12},
          {format: 'uint16x4', offset: 4, shaderLocation: 13},
          {format: 'sint32', offset: 16, shaderLocation: 7},
          {format: 'unorm16x4', offset: 16, shaderLocation: 14},
          {format: 'float32x4', offset: 128, shaderLocation: 10},
          {format: 'snorm8x2', offset: 192, shaderLocation: 1},
          {format: 'float32x2', offset: 0, shaderLocation: 0},
          {format: 'uint16x4', offset: 268, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 472,
        attributes: [
          {format: 'float16x4', offset: 28, shaderLocation: 11},
          {format: 'unorm16x4', offset: 152, shaderLocation: 3},
          {format: 'uint32x3', offset: 12, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', cullMode: 'front', unclippedDepth: true},
});
let sampler92 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', mipmapFilter: 'linear'});
try {
renderPassEncoder10.setBindGroup(0, bindGroup47, new Uint32Array(2253), 326, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup89 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout23,
  entries: [{binding: 79, resource: {buffer: buffer55, offset: 3328}}],
});
let commandEncoder144 = device0.createCommandEncoder({});
let computePassEncoder102 = commandEncoder144.beginComputePass({});
try {
computePassEncoder88.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder31.setBindGroup(3, bindGroup2, new Uint32Array(2772), 170, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer87, 'uint32', 2_872, 21_420);
} catch {}
try {
renderPassEncoder41.setPipeline(pipeline13);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let pipeline21 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute0'}});
try {
  await promise19;
} catch {}
let autogeneratedBindGroupLayout68 = pipeline7.getBindGroupLayout(0);
let sampler93 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 2.521,
});
try {
computePassEncoder56.setBindGroup(2, bindGroup48, new Uint32Array(38), 4, 0);
} catch {}
try {
computePassEncoder101.setPipeline(pipeline18);
} catch {}
let bindGroup90 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout18,
  entries: [
    {binding: 79, resource: {buffer: buffer60, offset: 512, size: 2175}},
    {binding: 125, resource: textureView2},
  ],
});
let buffer90 = device0.createBuffer({
  size: 6004,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder145 = device0.createCommandEncoder({});
let computePassEncoder103 = commandEncoder145.beginComputePass({});
let sampler94 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 75.00,
  maxAnisotropy: 20,
});
let buffer91 = device0.createBuffer({
  size: 42788,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder146 = device0.createCommandEncoder({});
let textureView163 = texture134.createView({dimension: '2d-array', aspect: 'all'});
let computePassEncoder104 = commandEncoder146.beginComputePass({});
try {
computePassEncoder98.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder23.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder42.setBlendConstant({ r: -235.8, g: -807.7, b: -746.2, a: -949.0, });
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer55, 'uint32', 2_672, 1_254);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline11);
} catch {}
let autogeneratedBindGroupLayout69 = pipeline19.getBindGroupLayout(0);
let commandEncoder147 = device0.createCommandEncoder({});
let textureView164 = texture105.createView({aspect: 'all', baseMipLevel: 0});
let computePassEncoder105 = commandEncoder147.beginComputePass();
try {
computePassEncoder21.setBindGroup(2, bindGroup47);
} catch {}
try {
computePassEncoder105.setPipeline(pipeline18);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let buffer92 = device0.createBuffer({size: 6141, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let commandEncoder148 = device0.createCommandEncoder({});
let texture164 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder106 = commandEncoder148.beginComputePass({});
try {
computePassEncoder104.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle5]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 288, height: 1, depthOrArrayLayers: 80}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture141,
  mipLevel: 0,
  origin: {x: 105, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout70 = pipeline9.getBindGroupLayout(0);
let buffer93 = device0.createBuffer({size: 9583, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder149 = device0.createCommandEncoder({});
let textureView165 = texture149.createView({aspect: 'all', arrayLayerCount: 1});
let computePassEncoder107 = commandEncoder149.beginComputePass({});
let externalTexture16 = device0.importExternalTexture({source: videoFrame14, colorSpace: 'srgb'});
try {
computePassEncoder107.setBindGroup(1, bindGroup0);
} catch {}
try {
computePassEncoder104.setBindGroup(3, bindGroup87, new Uint32Array(4279), 2_274, 0);
} catch {}
try {
computePassEncoder99.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer75, 'uint16', 1_544, 502);
} catch {}
try {
renderPassEncoder41.setPipeline(pipeline13);
} catch {}
let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout62]});
let texture165 = device0.createTexture({
  size: {width: 240},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView166 = texture163.createView({dimension: '3d', mipLevelCount: 1});
try {
renderPassEncoder22.executeBundles([renderBundle5, renderBundle13, renderBundle5]);
} catch {}
try {
renderPassEncoder27.setBlendConstant({ r: 581.0, g: -91.67, b: -218.4, a: -753.7, });
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer9, 'uint16', 2_132, 625);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer55, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let pipeline22 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule2, entryPoint: 'fragment1', constants: {}, targets: [{format: 'rgba8uint'}]},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 0, shaderLocation: 9},
          {format: 'uint32x2', offset: 0, shaderLocation: 14},
          {format: 'snorm8x4', offset: 0, shaderLocation: 0},
          {format: 'snorm8x2', offset: 0, shaderLocation: 8},
          {format: 'snorm16x2', offset: 0, shaderLocation: 6},
          {format: 'sint32', offset: 0, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 752,
        stepMode: 'instance',
        attributes: [{format: 'sint8x2', offset: 46, shaderLocation: 12}],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
document.body.prepend(canvas2);
let bindGroup91 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout69,
  entries: [{binding: 73, resource: {buffer: buffer87, offset: 1280, size: 5788}}],
});
let textureView167 = texture153.createView({});
let sampler95 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
computePassEncoder45.setBindGroup(3, bindGroup71, []);
} catch {}
try {
computePassEncoder92.setBindGroup(2, bindGroup25, new Uint32Array(81), 9, 0);
} catch {}
try {
computePassEncoder82.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup11, new Uint32Array(3558), 1_385, 0);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer31, 'uint16', 84, 103);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(3, buffer76, 2_240);
} catch {}
try {
buffer76.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup92 = device0.createBindGroup({layout: veryExplicitBindGroupLayout15, entries: [{binding: 28, resource: textureView28}]});
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout29]});
let buffer94 = device0.createBuffer({size: 10786, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder150 = device0.createCommandEncoder({});
let computePassEncoder108 = commandEncoder150.beginComputePass();
try {
renderPassEncoder41.setPipeline(pipeline22);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture143,
  mipLevel: 1,
  origin: {x: 19, y: 11, z: 0},
  aspect: 'all',
}, new Uint8Array(32_451).fill(155), /* required buffer size: 32_451 */
{offset: 37, bytesPerRow: 143, rowsPerImage: 28}, {width: 12, height: 3, depthOrArrayLayers: 9});
} catch {}
let textureView168 = texture126.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 26});
let sampler96 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.51,
  compare: 'always',
  maxAnisotropy: 4,
});
try {
computePassEncoder106.setBindGroup(0, bindGroup58);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup9);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle1, renderBundle3]);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(3, undefined);
} catch {}
let commandEncoder151 = device0.createCommandEncoder();
let texture166 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder109 = commandEncoder151.beginComputePass({});
try {
computePassEncoder13.setBindGroup(0, bindGroup66, new Uint32Array(590), 28, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup70);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup43, new Uint32Array(10000), 2_614, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer62);
} catch {}
let autogeneratedBindGroupLayout71 = pipeline4.getBindGroupLayout(0);
let bindGroup93 = device0.createBindGroup({
  label: '\u067f\uc3f3\u0242\u6a6a\u8df9\u{1fa0a}\u0298',
  layout: autogeneratedBindGroupLayout44,
  entries: [{binding: 79, resource: {buffer: buffer15, offset: 0, size: 39}}],
});
let buffer95 = device0.createBuffer({
  size: 8837,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder152 = device0.createCommandEncoder({});
try {
computePassEncoder108.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder44.setIndexBuffer(buffer79, 'uint16', 2_854, 4_227);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(6, buffer90, 0, 346);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
texture21.label = '\u{1fd2e}\u5866\u9fc6\ue5aa\u5df0\u0442\u0cae';
} catch {}
let texture167 = device0.createTexture({size: [1344], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let computePassEncoder110 = commandEncoder152.beginComputePass({});
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup94 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 28, resource: textureView166}]});
try {
computePassEncoder82.setBindGroup(3, bindGroup38);
} catch {}
try {
computePassEncoder11.setBindGroup(0, bindGroup29, new Uint32Array(3431), 575, 0);
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u5a5f');
} catch {}
try {
device0.queue.writeBuffer(buffer26, 736, new Float32Array(21803), 619, 296);
} catch {}
let bindGroup95 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout30,
  entries: [{binding: 125, resource: textureView7}, {binding: 79, resource: {buffer: buffer79, offset: 1024}}],
});
let buffer96 = device0.createBuffer({
  size: 23273,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let externalTexture17 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'srgb'});
try {
renderPassEncoder25.setBindGroup(3, bindGroup81, new Uint32Array(2097), 248, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle11, renderBundle3, renderBundle9, renderBundle8, renderBundle1]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture88,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(242).fill(255), /* required buffer size: 242 */
{offset: 242}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture168 = device0.createTexture({
  size: [1344, 1, 22],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8uint'],
});
let textureView169 = texture82.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 188, arrayLayerCount: 13});
try {
computePassEncoder13.setBindGroup(0, bindGroup92);
} catch {}
try {
renderPassEncoder43.setStencilReference(65);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer28, 'uint16', 6_318, 247);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer83, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
document.body.append(canvas1);
let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 36,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let bindGroup96 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 28, resource: textureView0}]});
let buffer97 = device0.createBuffer({
  size: 14309,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let commandEncoder153 = device0.createCommandEncoder();
let computePassEncoder111 = commandEncoder153.beginComputePass();
try {
renderPassEncoder42.setIndexBuffer(buffer15, 'uint16', 138, 74);
} catch {}
let pipeline23 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2}});
let autogeneratedBindGroupLayout72 = pipeline1.getBindGroupLayout(1);
let commandEncoder154 = device0.createCommandEncoder({});
let computePassEncoder112 = commandEncoder154.beginComputePass();
let promise20 = shaderModule3.getCompilationInfo();
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder155 = device0.createCommandEncoder({});
let textureView170 = texture105.createView({});
let computePassEncoder113 = commandEncoder155.beginComputePass({});
try {
computePassEncoder89.setBindGroup(0, bindGroup10);
} catch {}
try {
computePassEncoder106.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(7, buffer67, 0, 56);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let pipeline24 = device0.createRenderPipeline({
  layout: pipelineLayout9,
  fragment: {module: shaderModule4, constants: {}, targets: [{format: 'rg8sint', writeMask: GPUColorWrite.RED}]},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 752,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 92, shaderLocation: 12},
          {format: 'snorm8x4', offset: 12, shaderLocation: 4},
          {format: 'unorm10-10-10-2', offset: 168, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {cullMode: 'front', unclippedDepth: true},
});
let img3 = await imageWithData(6, 4, '#10101010', '#20202020');
let imageBitmap4 = await createImageBitmap(imageData25);
let autogeneratedBindGroupLayout73 = pipeline5.getBindGroupLayout(1);
let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout21]});
let commandEncoder156 = device0.createCommandEncoder({});
let textureView171 = texture21.createView({dimension: '3d'});
let computePassEncoder114 = commandEncoder156.beginComputePass({});
try {
computePassEncoder107.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup29);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup3, new Uint32Array(1237), 148, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(3, buffer37, 564);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 1, depthOrArrayLayers: 12}
*/
{
  source: img3,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture120,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture169 = device0.createTexture({
  label: '\u9017\u{1fd46}\u{1f7a2}\u{1fea4}\uf4c9\u6c15\u283b\u3ad0',
  size: {width: 336, height: 1, depthOrArrayLayers: 43},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder112.setBindGroup(3, bindGroup83);
} catch {}
try {
computePassEncoder14.setBindGroup(3, bindGroup73, new Uint32Array(1111), 251, 0);
} catch {}
try {
computePassEncoder40.end();
} catch {}
try {
computePassEncoder94.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder35.setBindGroup(1, bindGroup93);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle13, renderBundle6, renderBundle5]);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let commandEncoder157 = device0.createCommandEncoder({});
let texture170 = device0.createTexture({
  size: {width: 2688},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView172 = texture132.createView({mipLevelCount: 1});
let computePassEncoder115 = commandEncoder157.beginComputePass({});
try {
computePassEncoder92.setBindGroup(2, bindGroup16, new Uint32Array(2220), 1_031, 0);
} catch {}
try {
renderPassEncoder18.beginOcclusionQuery(1);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(4, buffer62, 0);
} catch {}
try {
  await shaderModule3.getCompilationInfo();
} catch {}
try {
commandEncoder55.copyTextureToBuffer({
  texture: texture46,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 5},
  aspect: 'all',
}, {
  /* bytesInLastRow: 104 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 872 */
  offset: 872,
  buffer: buffer65,
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer98 = device0.createBuffer({size: 3543, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder158 = device0.createCommandEncoder({});
let texture171 = gpuCanvasContext1.getCurrentTexture();
let computePassEncoder116 = commandEncoder55.beginComputePass();
let renderPassEncoder45 = commandEncoder158.beginRenderPass({
  colorAttachments: [{
  view: textureView150,
  depthSlice: 13,
  clearValue: { r: -720.1, g: -487.2, b: -224.4, a: 971.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 22709663,
});
try {
computePassEncoder110.setBindGroup(2, bindGroup43, []);
} catch {}
try {
computePassEncoder102.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer31, 'uint32', 12, 530);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
document.body.prepend(img1);
let buffer99 = device0.createBuffer({size: 3316, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder159 = device0.createCommandEncoder({});
let texture172 = device0.createTexture({
  size: [128, 128, 13],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder117 = commandEncoder159.beginComputePass({});
try {
computePassEncoder18.setBindGroup(1, bindGroup47);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline22);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 60, height: 1, depthOrArrayLayers: 13}
*/
{
  source: imageData0,
  origin: { x: 12, y: 2 },
  flipY: true,
}, {
  texture: texture117,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder160 = device0.createCommandEncoder({});
let textureView173 = texture24.createView({});
let computePassEncoder118 = commandEncoder160.beginComputePass({});
try {
renderPassEncoder24.setBindGroup(3, bindGroup78, new Uint32Array(574), 58, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(7, buffer67);
} catch {}
let buffer100 = device0.createBuffer({
  size: 870,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView174 = texture133.createView({});
try {
computePassEncoder25.setBindGroup(3, bindGroup13);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 240, height: 1, depthOrArrayLayers: 124}
*/
{
  source: imageBitmap4,
  origin: { x: 24, y: 4 },
  flipY: false,
}, {
  texture: texture132,
  mipLevel: 0,
  origin: {x: 53, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer101 = device0.createBuffer({
  size: 218,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture173 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView175 = texture99.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder25.end();
} catch {}
try {
computePassEncoder103.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline13);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture25,
  mipLevel: 1,
  origin: {x: 35, y: 18, z: 3},
  aspect: 'all',
},
{
  texture: texture81,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 6},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture105,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(3_428).fill(154), /* required buffer size: 3_428 */
{offset: 68, bytesPerRow: 4, rowsPerImage: 70}, {width: 0, height: 0, depthOrArrayLayers: 13});
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'unspecified', transfer: 'iec61966-2-1'} });
let autogeneratedBindGroupLayout74 = pipeline21.getBindGroupLayout(0);
let buffer102 = device0.createBuffer({
  size: 8045,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder161 = device0.createCommandEncoder({});
let texture174 = device0.createTexture({
  size: [72, 1, 53],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder119 = commandEncoder161.beginComputePass({});
try {
renderPassEncoder9.executeBundles([renderBundle12]);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer26, 'uint16', 470, 2_541);
} catch {}
try {
renderPassEncoder35.setPipeline(pipeline2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let pipelineLayout12 = device0.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout11, autogeneratedBindGroupLayout39, autogeneratedBindGroupLayout74],
});
let texture175 = device0.createTexture({
  size: {width: 2688, height: 1, depthOrArrayLayers: 48},
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder120 = commandEncoder34.beginComputePass({});
let sampler97 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', compare: 'always'});
try {
computePassEncoder4.setBindGroup(2, bindGroup2, new Uint32Array(2232), 82, 0);
} catch {}
try {
computePassEncoder114.setPipeline(pipeline19);
} catch {}
try {
buffer43.unmap();
} catch {}
try {
  await promise20;
} catch {}
document.body.prepend(canvas2);
let textureView176 = texture4.createView({dimension: '2d', mipLevelCount: 1});
try {
computePassEncoder111.setBindGroup(1, bindGroup9);
} catch {}
try {
computePassEncoder85.setBindGroup(3, bindGroup84, new Uint32Array(230), 149, 0);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder37.setPipeline(pipeline13);
} catch {}
document.body.prepend(img3);
let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte240m', transfer: 'smpteSt4281'} });
let buffer103 = device0.createBuffer({size: 18122, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX, mappedAtCreation: false});
let textureView177 = texture36.createView({mipLevelCount: 1});
let sampler98 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 85.67,
});
try {
renderPassEncoder18.setBlendConstant({ r: -725.5, g: -676.1, b: -105.6, a: -312.8, });
} catch {}
let promise21 = device0.createComputePipelineAsync({layout: pipelineLayout12, compute: {module: shaderModule1, entryPoint: 'compute0'}});
try {
adapter0.label = '\u082a\u0029\u{1fc5e}\u06f0\u033e\u07e6\u05a9\u{1fb96}';
} catch {}
let autogeneratedBindGroupLayout75 = pipeline0.getBindGroupLayout(0);
let commandEncoder162 = device0.createCommandEncoder();
let computePassEncoder121 = commandEncoder162.beginComputePass({});
try {
computePassEncoder1.setBindGroup(1, bindGroup75, new Uint32Array(974), 126, 0);
} catch {}
try {
computePassEncoder93.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(2, buffer51);
} catch {}
let bindGroup97 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout43,
  entries: [{binding: 79, resource: {buffer: buffer19, offset: 2560}}, {binding: 125, resource: textureView176}],
});
let pipelineLayout13 = device0.createPipelineLayout({
  bindGroupLayouts: [autogeneratedBindGroupLayout12, autogeneratedBindGroupLayout72, veryExplicitBindGroupLayout2],
});
let buffer104 = device0.createBuffer({size: 216, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder163 = device0.createCommandEncoder({});
let textureView178 = texture150.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 3, arrayLayerCount: 6});
let textureView179 = texture94.createView({baseMipLevel: 0});
try {
renderPassEncoder22.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder29.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer72, 'uint32', 484, 498);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer80, 128, new BigUint64Array(3319), 108, 28);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
globalThis.someLabel = externalTexture0.label;
} catch {}
let buffer105 = device0.createBuffer({
  size: 2375,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture176 = device0.createTexture({
  size: [336, 1, 14],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder122 = commandEncoder163.beginComputePass();
let sampler99 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 33.94,
  compare: 'greater',
});
try {
computePassEncoder121.setBindGroup(3, bindGroup80, new Uint32Array(1733), 88, 0);
} catch {}
try {
computePassEncoder28.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer31, 'uint32', 96, 17);
} catch {}
try {
renderPassEncoder31.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer42, 0, 543);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 240, height: 1, depthOrArrayLayers: 124}
*/
{
  source: videoFrame8,
  origin: { x: 23, y: 470 },
  flipY: true,
}, {
  texture: texture132,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 8},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 197, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder164 = device0.createCommandEncoder({});
try {
computePassEncoder83.setBindGroup(1, bindGroup1);
} catch {}
try {
renderPassEncoder18.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline1);
} catch {}
try {
commandEncoder164.clearBuffer(buffer58, 11252, 132);
} catch {}
let autogeneratedBindGroupLayout76 = pipeline14.getBindGroupLayout(0);
try {
renderPassEncoder23.setPipeline(pipeline12);
} catch {}
try {
buffer98.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  alphaMode: 'opaque',
});
} catch {}
let promise22 = device0.queue.onSubmittedWorkDone();
let bindGroup98 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout14,
  entries: [
    {binding: 125, resource: textureView2},
    {binding: 79, resource: {buffer: buffer12, offset: 1280, size: 11469}},
  ],
});
let computePassEncoder123 = commandEncoder164.beginComputePass();
try {
computePassEncoder27.setBindGroup(3, bindGroup82);
} catch {}
try {
renderPassEncoder28.setBindGroup(1, bindGroup7, new Uint32Array(3998), 316, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer97, 'uint16', 214, 2_226);
} catch {}
try {
externalTexture14.label = '\u0a60\u00f6\u50bf\uc668\uda6e';
} catch {}
let autogeneratedBindGroupLayout77 = pipeline6.getBindGroupLayout(1);
let commandEncoder165 = device0.createCommandEncoder({});
let computePassEncoder124 = commandEncoder165.beginComputePass({});
try {
computePassEncoder124.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer92, 'uint16', 420, 1_443);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline4);
} catch {}
try {
buffer18.unmap();
} catch {}
let bindGroup99 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: [{binding: 121, resource: sampler89}]});
let textureView180 = texture18.createView({dimension: '2d-array', arrayLayerCount: 3});
try {
renderPassEncoder30.setBindGroup(1, bindGroup70, new Uint32Array(1415), 327, 0);
} catch {}
try {
renderPassEncoder26.executeBundles([renderBundle11, renderBundle7, renderBundle7]);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(5, buffer67, 304, 468);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer17, 76, new DataView(new ArrayBuffer(3104)), 428, 364);
} catch {}
try {
  await promise22;
} catch {}
try {
globalThis.someLabel = externalTexture16.label;
} catch {}
let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 52,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder166 = device0.createCommandEncoder({});
let sampler100 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 89.76,
  compare: 'never',
  maxAnisotropy: 1,
});
try {
computePassEncoder80.setBindGroup(3, bindGroup36);
} catch {}
try {
computePassEncoder97.setBindGroup(1, bindGroup48, new Uint32Array(87), 4, 0);
} catch {}
try {
computePassEncoder118.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup53, []);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer88, 'uint32', 228, 112);
} catch {}
let buffer106 = device0.createBuffer({
  size: 7065,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView181 = texture54.createView({dimension: '2d-array', mipLevelCount: 1});
let renderPassEncoder46 = commandEncoder166.beginRenderPass({
  colorAttachments: [{
  view: textureView12,
  depthSlice: 11,
  clearValue: { r: 817.8, g: 24.79, b: -332.2, a: -320.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 84611342,
});
let sampler101 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.42,
  maxAnisotropy: 14,
});
try {
computePassEncoder121.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup32, new Uint32Array(1008), 41, 0);
} catch {}
let arrayBuffer5 = buffer49.getMappedRange(800, 24);
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let buffer107 = device0.createBuffer({
  size: 1716,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let querySet18 = device0.createQuerySet({type: 'occlusion', count: 1378});
let externalTexture18 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'display-p3'});
try {
computePassEncoder54.setBindGroup(2, bindGroup50);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer91, 'uint32', 704, 3_106);
} catch {}
try {
computePassEncoder56.pushDebugGroup('\u{1febe}');
} catch {}
document.body.append(canvas0);
let buffer108 = device0.createBuffer({size: 4289, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture177 = device0.createTexture({
  size: [240],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder119.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(1, buffer69);
} catch {}
let autogeneratedBindGroupLayout78 = pipeline5.getBindGroupLayout(1);
let texture178 = device0.createTexture({
  size: [336, 1, 185],
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler102 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 68.86,
  maxAnisotropy: 20,
});
try {
computePassEncoder113.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder45.setIndexBuffer(buffer41, 'uint16', 998, 5_258);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(1, buffer62, 1_860, 1_919);
} catch {}
let autogeneratedBindGroupLayout79 = pipeline21.getBindGroupLayout(0);
try {
computePassEncoder3.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup65);
} catch {}
try {
renderPassEncoder41.setIndexBuffer(buffer70, 'uint32', 304, 1_046);
} catch {}
let promise23 = device0.queue.onSubmittedWorkDone();
let bindGroup100 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout62,
  entries: [
    {binding: 125, resource: textureView2},
    {binding: 79, resource: {buffer: buffer29, offset: 1024, size: 48}},
  ],
});
try {
computePassEncoder61.setBindGroup(3, bindGroup74);
} catch {}
try {
computePassEncoder1.setBindGroup(2, bindGroup83, new Uint32Array(2159), 129, 0);
} catch {}
try {
computePassEncoder112.setPipeline(pipeline19);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
  await promise23;
} catch {}
try {
computePassEncoder65.setBindGroup(3, bindGroup33);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer48, 'uint32', 16, 48);
} catch {}
let promise24 = shaderModule1.getCompilationInfo();
let bindGroup101 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout0,
  entries: [{binding: 79, resource: {buffer: buffer55, offset: 2304, size: 662}}],
});
let commandEncoder167 = device0.createCommandEncoder();
let texture179 = device0.createTexture({
  size: {width: 336},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder47 = commandEncoder167.beginRenderPass({
  colorAttachments: [{
  view: textureView36,
  clearValue: { r: -1.508, g: -108.0, b: 130.8, a: 248.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let sampler103 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.30,
  compare: 'always',
  maxAnisotropy: 15,
});
try {
computePassEncoder117.setBindGroup(0, bindGroup81);
} catch {}
try {
renderPassEncoder31.setBindGroup(0, bindGroup31);
} catch {}
try {
renderPassEncoder35.setBlendConstant({ r: 241.3, g: 450.3, b: 965.0, a: 749.1, });
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer40, 'uint32', 6_076, 54);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(4, buffer89, 2_636, 6_018);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 8504, new DataView(new ArrayBuffer(3686)), 934, 216);
} catch {}
let querySet19 = device0.createQuerySet({type: 'occlusion', count: 93});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rg32float']});
try {
computePassEncoder110.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder46.setBindGroup(2, bindGroup2);
} catch {}
try {
renderBundleEncoder18.setBindGroup(1, bindGroup74, new Uint32Array(311), 38, 0);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(5, buffer62, 1_436, 2_437);
} catch {}
try {
device0.queue.writeBuffer(buffer36, 1132, new BigUint64Array(5648), 330, 80);
} catch {}
let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 23,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let autogeneratedBindGroupLayout80 = pipeline8.getBindGroupLayout(0);
let commandEncoder168 = device0.createCommandEncoder({});
let computePassEncoder125 = commandEncoder168.beginComputePass({});
try {
computePassEncoder10.setBindGroup(3, bindGroup54);
} catch {}
try {
computePassEncoder123.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder41.setViewport(21.354593483118506, 109.99347996788386, 46.1893373712616, 5.690923724846741, 0.013621075144809258, 0.5738092374972712);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer15, 'uint32', 112, 390);
} catch {}
try {
  await shaderModule4.getCompilationInfo();
} catch {}
let buffer109 = device0.createBuffer({
  size: 2904,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder111.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer21, 'uint32', 1_100, 87);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(2, undefined);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture133,
  mipLevel: 0,
  origin: {x: 125, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(286).fill(148), /* required buffer size: 286 */
{offset: 286, rowsPerImage: 11}, {width: 122, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas1);
let bindGroup102 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout36,
  entries: [
    {binding: 125, resource: textureView2},
    {binding: 79, resource: {buffer: buffer36, offset: 0, size: 1202}},
  ],
});
let texture180 = device0.createTexture({
  label: '\ub7ef\u08ee\u0269\u05ea',
  size: {width: 672, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundle18 = renderBundleEncoder18.finish({});
let sampler104 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMaxClamp: 78.19,
  compare: 'greater',
});
try {
computePassEncoder19.setBindGroup(3, bindGroup28, []);
} catch {}
try {
computePassEncoder89.setPipeline(pipeline17);
} catch {}
try {
computePassEncoder125.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(4, buffer62, 0, 4_316);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 19 },
  flipY: true,
}, {
  texture: texture63,
  mipLevel: 1,
  origin: {x: 38, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas4 = document.createElement('canvas');
let buffer110 = device0.createBuffer({size: 1637, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder169 = device0.createCommandEncoder({});
let sampler105 = device0.createSampler({addressModeV: 'mirror-repeat'});
try {
computePassEncoder91.setBindGroup(1, bindGroup55);
} catch {}
try {
commandEncoder169.copyBufferToTexture({
  /* bytesInLastRow: 128 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4480 */
  offset: 4480,
  bytesPerRow: 40448,
  buffer: buffer27,
}, {
  texture: texture121,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout81 = pipeline12.getBindGroupLayout(1);
let bindGroup103 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [
    {binding: 79, resource: {buffer: buffer78, offset: 256, size: 434}},
    {binding: 125, resource: textureView176},
  ],
});
let buffer111 = device0.createBuffer({
  size: 134,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder170 = device0.createCommandEncoder({});
let computePassEncoder126 = commandEncoder169.beginComputePass({});
try {
computePassEncoder126.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup10, new Uint32Array(209), 18, 0);
} catch {}
let arrayBuffer6 = buffer49.getMappedRange(1288, 64);
try {
  await promise24;
} catch {}
let bindGroup104 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout11,
  entries: [{binding: 79, resource: {buffer: buffer100, offset: 0, size: 306}}],
});
let commandEncoder171 = device0.createCommandEncoder({});
let texture181 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 109},
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView182 = texture46.createView({dimension: '2d', baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder122.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer111, 'uint16', 4, 36);
} catch {}
await gc();
let texture182 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 107},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder94.setBindGroup(1, bindGroup23);
} catch {}
try {
computePassEncoder99.setBindGroup(1, bindGroup38, new Uint32Array(1447), 0, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
let imageData27 = new ImageData(4, 80);
let commandEncoder172 = device0.createCommandEncoder({});
let texture183 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let sampler106 = device0.createSampler({magFilter: 'linear'});
try {
computePassEncoder97.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer0, 'uint32', 88, 698);
} catch {}
try {
renderPassEncoder32.setPipeline(pipeline20);
} catch {}
try {
commandEncoder172.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 284 */
  offset: 284,
  buffer: buffer89,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder170.copyTextureToTexture({
  texture: texture174,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture181,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 3},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap2,
  origin: { x: 21, y: 18 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext2 = canvas4.getContext('webgpu');
let querySet20 = device0.createQuerySet({type: 'occlusion', count: 273});
let commandBuffer4 = commandEncoder172.finish();
let renderPassEncoder48 = commandEncoder170.beginRenderPass({
  colorAttachments: [{
  view: textureView34,
  clearValue: { r: 142.9, g: -436.7, b: 657.7, a: 741.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder23.setVertexBuffer(2, buffer23, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 72, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame18,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder173 = device0.createCommandEncoder();
let computePassEncoder127 = commandEncoder171.beginComputePass({});
let renderPassEncoder49 = commandEncoder173.beginRenderPass({
  colorAttachments: [{
  view: textureView95,
  depthSlice: 198,
  clearValue: { r: -886.6, g: -685.2, b: 458.9, a: -954.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let sampler107 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 99.67});
try {
computePassEncoder38.setBindGroup(3, bindGroup78, new Uint32Array(2526), 94, 0);
} catch {}
try {
renderPassEncoder35.setIndexBuffer(buffer26, 'uint32', 8_060, 106);
} catch {}
try {
renderPassEncoder41.setVertexBuffer(1, buffer37, 0, 1_517);
} catch {}
let autogeneratedBindGroupLayout82 = pipeline21.getBindGroupLayout(0);
let bindGroup105 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 28, resource: textureView1}]});
let buffer112 = device0.createBuffer({
  size: 1257,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder174 = device0.createCommandEncoder();
let textureView183 = texture4.createView({dimension: '2d', aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 2});
let renderPassEncoder50 = commandEncoder174.beginRenderPass({
  colorAttachments: [{
  view: textureView17,
  clearValue: { r: 736.4, g: 248.3, b: 522.3, a: -802.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet11,
});
let externalTexture19 = device0.importExternalTexture({source: videoFrame2});
try {
buffer24.unmap();
} catch {}
try {
computePassEncoder19.pushDebugGroup('\u0516');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 105, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(15).fill(215), /* required buffer size: 15 */
{offset: 15, rowsPerImage: 23}, {width: 32, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView184 = texture126.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder120.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup54, new Uint32Array(1004), 176, 0);
} catch {}
let texture184 = device0.createTexture({
  size: {width: 2688},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder116.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder15.setViewport(127.29221912734099, 0.9507498310910333, 22.857255657561723, 0.027315486120870123, 0.8255495236937952, 0.9277947108156062);
} catch {}
let imageData28 = new ImageData(16, 16);
let autogeneratedBindGroupLayout83 = pipeline1.getBindGroupLayout(0);
let buffer113 = device0.createBuffer({size: 16448, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture185 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 694},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder66.setBindGroup(1, bindGroup12);
} catch {}
try {
computePassEncoder51.setBindGroup(0, bindGroup98, new Uint32Array(446), 170, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup8, new Uint32Array(2149), 124, 0);
} catch {}
try {
renderPassEncoder9.setBlendConstant({ r: 107.1, g: -804.8, b: 854.2, a: -325.1, });
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline15);
} catch {}
let commandEncoder175 = device0.createCommandEncoder({});
let renderPassEncoder51 = commandEncoder175.beginRenderPass({
  label: '\u097c\ubb75\uf0fc\u0767\u{1fa6f}\u011d\u{1feb8}\u7bef\ue54e\u79cf',
  colorAttachments: [{
  view: textureView177,
  depthSlice: 63,
  clearValue: { r: 777.6, g: -725.8, b: -56.30, a: -598.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder14.beginOcclusionQuery(18);
} catch {}
let bindGroup106 = device0.createBindGroup({layout: veryExplicitBindGroupLayout15, entries: [{binding: 28, resource: textureView12}]});
let commandEncoder176 = device0.createCommandEncoder({});
let texture186 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 41},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder7.setViewport(21.521341455226143, 0.03412703729971811, 3.2765129824436916, 0.8360909768299485, 0.33556118745605357, 0.7586577575467923);
} catch {}
try {
renderPassEncoder46.setVertexBuffer(3, buffer1, 0, 389);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture187 = device0.createTexture({
  size: {width: 2688, height: 1, depthOrArrayLayers: 12},
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder128 = commandEncoder176.beginComputePass({});
try {
computePassEncoder60.setBindGroup(2, bindGroup76);
} catch {}
try {
computePassEncoder114.setBindGroup(3, bindGroup92, new Uint32Array(4453), 876, 0);
} catch {}
try {
renderPassEncoder26.setBindGroup(2, bindGroup92);
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
document.body.prepend(img2);
let querySet21 = device0.createQuerySet({type: 'occlusion', count: 6});
let sampler108 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 96.00});
try {
computePassEncoder109.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer100, 'uint16', 168, 565);
} catch {}
try {
computePassEncoder56.popDebugGroup();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let imageData29 = new ImageData(24, 12);
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt709', transfer: 'smpte170m'} });
let shaderModule5 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

enable f16;

requires unrestricted_pointer_parameters;

var<workgroup> vw21: mat2x4h;

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

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

struct VertexOutput5 {
  @location(15) @interpolate(flat, sample) f7: i32,
  @builtin(position) f8: vec4f,
}

var<workgroup> vw25: VertexOutput6;

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

var<workgroup> vw24: atomic<u32>;

var<private> vp13 = modf(f32(0.2078));

struct VertexOutput6 {
  @location(9) f9: vec4f,
  @location(11) f10: f16,
  @builtin(position) f11: vec4f,
}

struct FragmentOutput3 {
  @location(4) f0: vec4i,
  @location(0) f1: vec4i,
}

var<workgroup> vw22: array<array<atomic<u32>, 16>, 1>;

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

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

var<workgroup> vw23: f32;

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

@vertex
fn vertex6() -> VertexOutput5 {
  var out: VertexOutput5;
  var vf70: vec4f = acosh(vec4f(unconst_f32(0.1966), unconst_f32(0.1578), unconst_f32(-0.2069), unconst_f32(0.1050)));
  vf70 = vec4f(cosh(vec3h(f16(pack4xU8(vec4u(unconst_u32(251), unconst_u32(219), unconst_u32(271), unconst_u32(99)))))).xyzx);
  out = VertexOutput5(vec3i(ldexp(vec3f(unconst_f32(0.02787), unconst_f32(0.06122), unconst_f32(0.1157)), vec3i(unconst_i32(-742), unconst_i32(93), unconst_i32(537)))).b, ldexp(vec3f(unconst_f32(0.02787), unconst_f32(0.06122), unconst_f32(0.1157)), vec3i(unconst_i32(-742), unconst_i32(93), unconst_i32(537))).zzyy);
  var vf71: vec3u = countOneBits(countLeadingZeros(vec2u(unconst_u32(95), unconst_u32(316))).yxy);
  out.f7 &= bitcast<i32>(vp13.fract);
  let ptr57: ptr<private, f32> = &vp13.fract;
  var vf72: f16 = ceil(f16(unconst_f16(2466.9)));
  let ptr58: ptr<function, vec4f> = &vf70;
  vf70 *= acosh(vec4f(unconst_f32(0.01426), unconst_f32(0.1076), unconst_f32(0.2379), unconst_f32(0.04373)));
  vf70 = vec4f(f32(all(bool(unconst_bool(true)))));
  let vf73: u32 = pack4xU8(vec4u(unconst_u32(599), unconst_u32(87), unconst_u32(38), unconst_u32(62)));
  vf71 = vec3u(pack4xU8(vec4u(unconst_u32(116), unconst_u32(127), unconst_u32(707), unconst_u32(66))));
  var vf74: vec2u = countLeadingZeros(vec2u(unconst_u32(318), unconst_u32(32)));
  var vf75: f32 = radians(f32(unconst_f32(0.06185)));
  var vf76: f16 = ceil(f16(unconst_f16(939.0)));
  var vf77: u32 = pack4xI8Clamp(vec4i(unconst_i32(37), unconst_i32(112), unconst_i32(-204), unconst_i32(538)));
  var vf78: vec2f = acosh(vec2f(unconst_f32(0.06724), unconst_f32(0.1356)));
  vf74 &= vec2u(bitcast<u32>(sqrt(bitcast<f32>(countLeadingZeros(vec2u(unconst_u32(824), unconst_u32(347))).y))));
  vf74 *= vec2u(u32(vp13.whole));
  vf71 >>= vec3u(pow(vec2f(unconst_f32(0.1455), unconst_f32(-0.2262)), vec2f(unconst_f32(0.1831), unconst_f32(0.3400))).rgg);
  let ptr59: ptr<function, vec2f> = &vf78;
  return out;
}

@vertex
fn vertex7(@location(9) a0: f32, @builtin(vertex_index) a1: u32) -> VertexOutput6 {
  var out: VertexOutput6;
  out.f10 = vec2h(countLeadingZeros(vec2i(unconst_i32(70), unconst_i32(122))))[0];
  return out;
}

@fragment
fn fragment4() -> FragmentOutput3 {
  var out: FragmentOutput3;
  let vf79: vec4h = atanh(vec4h(unconst_f16(16735.6), unconst_f16(18074.3), unconst_f16(17554.8), unconst_f16(-17334.5)));
  let vf80: vec3h = asin(vec3h(unconst_f16(6654.8), unconst_f16(1982.8), unconst_f16(11389.2)));
  var vf81: u32 = pack4xI8Clamp(vec4i(unconst_i32(52), unconst_i32(165), unconst_i32(153), unconst_i32(39)));
  out = FragmentOutput3(vec4i(bitcast<i32>(vf81)), unpack4xI8(vf81));
  vp13 = modf(tanh(vec4f(unconst_f32(0.1915), unconst_f32(0.1194), unconst_f32(0.01170), unconst_f32(0.1370)))[3]);
  let ptr60: ptr<function, u32> = &vf81;
  return out;
}

@compute @workgroup_size(1, 2, 1)
fn compute3() {
  atomicMin(&vw22[u32(unconst_u32(10))][u32(unconst_u32(37))], u32(unconst_u32(83)));
  vp13 = modf(f32(atomicExchange(&vw24, u32(unconst_u32(118)))));
  vp13.whole = bitcast<f32>(atomicLoad(&(*&vw22)[u32(unconst_u32(47))][15]));
  let ptr61: ptr<private, f32> = &vp13.fract;
  let vf82: f32 = acos(f32(unconst_f32(0.5609)));
  vw21 = mat2x4h(f16(atomicLoad(&vw22[u32(unconst_u32(98))][15])), f16(atomicLoad(&vw22[u32(unconst_u32(98))][15])), f16(atomicLoad(&vw22[u32(unconst_u32(98))][15])), f16(atomicLoad(&vw22[u32(unconst_u32(98))][15])), f16(atomicLoad(&vw22[u32(unconst_u32(98))][15])), f16(atomicLoad(&vw22[u32(unconst_u32(98))][15])), f16(atomicLoad(&vw22[u32(unconst_u32(98))][15])), f16(atomicLoad(&vw22[u32(unconst_u32(98))][15])));
  var vf83: f32 = vw25.f9[u32(unconst_u32(206))];
  let ptr62: ptr<workgroup, atomic<u32>> = &(*&vw22)[0][u32(unconst_u32(196))];
  vw23 -= workgroupUniformLoad(&vw23);
  let ptr63: ptr<workgroup, array<atomic<u32>, 16>> = &vw22[0];
  let vf84: u32 = atomicLoad(&vw22[0][15]);
  atomicSub(&vw22[u32(unconst_u32(16))][u32(unconst_u32(285))], vf84);
  let vf85: u32 = atomicExchange(&vw22[u32(unconst_u32(256))][u32(unconst_u32(71))], u32(unconst_u32(650)));
}`,
});
let autogeneratedBindGroupLayout84 = pipeline1.getBindGroupLayout(1);
let commandEncoder177 = device0.createCommandEncoder();
let textureView185 = texture77.createView({dimension: 'cube-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 6});
let texture188 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 61},
  mipLevelCount: 5,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView186 = texture34.createView({mipLevelCount: 1});
let computePassEncoder129 = commandEncoder177.beginComputePass({});
let sampler109 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 99.18});
try {
computePassEncoder29.setBindGroup(1, bindGroup1);
} catch {}
try {
computePassEncoder128.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer19, 'uint32', 2_340, 5_114);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline5);
} catch {}
let arrayBuffer7 = buffer49.getMappedRange(256, 0);
try {
computePassEncoder19.popDebugGroup();
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline25 = device0.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 88,
        attributes: [
          {format: 'sint16x2', offset: 8, shaderLocation: 12},
          {format: 'float32', offset: 20, shaderLocation: 4},
        ],
      },
      {arrayStride: 656, attributes: [{format: 'float32', offset: 132, shaderLocation: 7}]},
    ],
  },
  primitive: {topology: 'triangle-strip', cullMode: 'back', unclippedDepth: false},
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let imageBitmap5 = await createImageBitmap(imageData27);
let autogeneratedBindGroupLayout85 = pipeline14.getBindGroupLayout(0);
let commandEncoder178 = device0.createCommandEncoder({});
let texture189 = device0.createTexture({
  size: [288, 1, 1],
  sampleCount: 4,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView187 = texture75.createView({});
let sampler110 = device0.createSampler({addressModeU: 'mirror-repeat', lodMinClamp: 38.12, lodMaxClamp: 59.89});
try {
renderPassEncoder33.setViewport(45.688393896118136, 0.7237810721200777, 18.461570330037556, 0.06399525561045863, 0.005369967832161038, 0.9999480554759764);
} catch {}
try {
renderPassEncoder43.setPipeline(pipeline15);
} catch {}
try {
commandEncoder178.copyBufferToTexture({
  /* bytesInLastRow: 128 widthInBlocks: 32 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 236 */
  offset: 236,
  rowsPerImage: 22,
  buffer: buffer48,
}, {
  texture: texture59,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 0},
  aspect: 'all',
}, {width: 32, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout86 = pipeline22.getBindGroupLayout(0);
let texture190 = device0.createTexture({
  size: [288],
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture191 = device0.createTexture({
  size: [60, 1, 1],
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder130 = commandEncoder178.beginComputePass({});
try {
renderPassEncoder4.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder11.setBindGroup(3, bindGroup29, new Uint32Array(860), 28, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 12}
*/
{
  source: imageData25,
  origin: { x: 5, y: 9 },
  flipY: false,
}, {
  texture: texture120,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup107 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 36, resource: textureView2}]});
let texture192 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture193 = device0.createTexture({
  size: [144, 1, 1],
  mipLevelCount: 2,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture194 = gpuCanvasContext1.getCurrentTexture();
try {
computePassEncoder45.setBindGroup(3, bindGroup86);
} catch {}
try {
computePassEncoder121.setBindGroup(3, bindGroup98, new Uint32Array(272), 30, 0);
} catch {}
try {
renderPassEncoder49.executeBundles([renderBundle13, renderBundle6, renderBundle13, renderBundle13, renderBundle13]);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer80, 'uint16', 4, 31);
} catch {}
try {
renderPassEncoder48.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder9.insertDebugMarker('\u{1f689}');
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 30, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 42 },
  flipY: true,
}, {
  texture: texture140,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer115 = device0.createBuffer({size: 9901, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let commandEncoder179 = device0.createCommandEncoder({});
let texture195 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture196 = device0.createTexture({
  size: [240, 1, 47],
  mipLevelCount: 3,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg16float'],
});
let renderPassEncoder52 = commandEncoder179.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: 59.33, g: 145.0, b: -474.5, a: -72.20, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet21,
  maxDrawCount: 611697079,
});
let sampler111 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 73.93,
  lodMaxClamp: 78.78,
});
try {
computePassEncoder118.setBindGroup(0, bindGroup68, new Uint32Array(2596), 62, 0);
} catch {}
try {
computePassEncoder127.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let commandEncoder180 = device0.createCommandEncoder({});
let texture197 = device0.createTexture({
  size: {width: 72, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture198 = device0.createTexture({
  size: [1344, 1, 1],
  mipLevelCount: 2,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder53 = commandEncoder180.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  depthSlice: 36,
  clearValue: { r: 218.4, g: 189.8, b: 939.0, a: -667.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder101.setBindGroup(0, bindGroup14, new Uint32Array(224), 44, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup102, new Uint32Array(4533), 1_956, 0);
} catch {}
try {
renderPassEncoder46.setVertexBuffer(4, buffer67, 52, 333);
} catch {}
let texture199 = device0.createTexture({
  size: [672, 1, 1],
  mipLevelCount: 1,
  sampleCount: 4,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture200 = device0.createTexture({
  size: [120, 1, 1],
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder3.setBindGroup(2, bindGroup100);
} catch {}
try {
computePassEncoder21.setBindGroup(2, bindGroup52, new Uint32Array(833), 13, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let texture201 = device0.createTexture({
  size: [240, 1, 13],
  dimension: '2d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView188 = texture89.createView({dimension: '2d', baseArrayLayer: 4});
try {
computePassEncoder115.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder37.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder44.setBindGroup(1, bindGroup82, new Uint32Array(1252), 66, 0);
} catch {}
try {
renderPassEncoder28.setViewport(236.01934037188235, 0.30933366649947236, 0.47373724394013517, 0.18318869670029309, 0.1309075878888245, 0.735896142556804);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer92, 'uint16', 242, 700);
} catch {}
try {
renderPassEncoder43.setVertexBuffer(6, buffer42, 588, 84);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder181 = device0.createCommandEncoder({});
let textureView189 = texture201.createView({dimension: '2d', baseArrayLayer: 2});
let renderPassEncoder54 = commandEncoder181.beginRenderPass({
  colorAttachments: [{
  view: textureView41,
  clearValue: { r: 466.1, g: -133.9, b: -851.8, a: 630.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder93.setBindGroup(3, bindGroup76, new Uint32Array(24), 1, 0);
} catch {}
try {
computePassEncoder76.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder28.setViewport(5.8734718571596165, 0.704236957047689, 130.03655836210345, 0.22202034239148052, 0.8397925015798477, 0.8487694726040481);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer69, 'uint16', 36, 50);
} catch {}
try {
renderPassEncoder40.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder50.setVertexBuffer(1, buffer58, 0, 5_833);
} catch {}
try {
buffer76.unmap();
} catch {}
let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt709', transfer: 'iec6196624'} });
let textureView190 = texture190.createView({});
let texture202 = device0.createTexture({
  size: [288],
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder35.setBindGroup(1, bindGroup84);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup68, new Uint32Array(4094), 233, 0);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder54.setVertexBuffer(0, buffer69, 0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder182 = device0.createCommandEncoder();
let texture203 = device0.createTexture({
  size: [672, 1, 1],
  mipLevelCount: 5,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture204 = device0.createTexture({
  size: [240],
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder131 = commandEncoder182.beginComputePass({});
try {
computePassEncoder113.setBindGroup(1, bindGroup103);
} catch {}
try {
renderPassEncoder51.setBindGroup(1, bindGroup104, new Uint32Array(923), 24, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 86, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(19).fill(34), /* required buffer size: 19 */
{offset: 19}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let bindGroup108 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout8,
  entries: [{binding: 79, resource: {buffer: buffer78, offset: 0, size: 354}}],
});
let texture205 = device0.createTexture({
  size: [144, 1, 122],
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer67, 512, new Int16Array(2312), 45, 248);
} catch {}
document.body.append(canvas1);
let commandEncoder183 = device0.createCommandEncoder({});
let texture206 = device0.createTexture({
  size: [1344, 1, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView191 = texture106.createView({aspect: 'all', mipLevelCount: 1});
let renderPassEncoder55 = commandEncoder183.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: 864.2, g: 217.6, b: 765.4, a: 133.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder1.setBindGroup(3, bindGroup67, new Uint32Array(3920), 237, 0);
} catch {}
try {
computePassEncoder130.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder41.end();
} catch {}
let imageBitmap6 = await createImageBitmap(imageData0);
let autogeneratedBindGroupLayout87 = pipeline25.getBindGroupLayout(0);
let bindGroup109 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout43,
  entries: [
    {binding: 79, resource: {buffer: buffer78, offset: 0, size: 85}},
    {binding: 125, resource: textureView176},
  ],
});
let texture207 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 13},
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder11.setBindGroup(0, bindGroup62, new Uint32Array(2526), 470, 0);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline15);
} catch {}
let buffer116 = device0.createBuffer({
  size: 15789,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let texture208 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  sampleCount: 4,
  dimension: '2d',
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture209 = device0.createTexture({
  size: [60, 1, 41],
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder132 = commandEncoder130.beginComputePass();
let sampler112 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 63.46});
try {
computePassEncoder8.setBindGroup(0, bindGroup87, []);
} catch {}
try {
computePassEncoder82.setBindGroup(3, bindGroup92, new Uint32Array(1051), 41, 0);
} catch {}
try {
computePassEncoder117.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup49, new Uint32Array(1311), 133, 0);
} catch {}
try {
renderPassEncoder20.setBlendConstant({ r: 260.3, g: -137.4, b: 460.9, a: -368.2, });
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer63, 'uint16', 720, 3_033);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(6, buffer90, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: videoFrame20,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup110 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout44,
  entries: [{binding: 79, resource: {buffer: buffer53, offset: 3072}}],
});
let querySet22 = device0.createQuerySet({type: 'occlusion', count: 55});
let textureView192 = texture207.createView({dimension: 'cube', baseArrayLayer: 1});
try {
computePassEncoder90.setBindGroup(0, bindGroup103);
} catch {}
try {
computePassEncoder129.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder26.setBindGroup(1, bindGroup75);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer90, 'uint16', 5_766, 17);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(1, buffer107, 0, 225);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let bindGroup111 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout10,
  entries: [
    {binding: 79, resource: {buffer: buffer111, offset: 0, size: 16}},
    {binding: 125, resource: textureView7},
  ],
});
let querySet23 = device0.createQuerySet({type: 'occlusion', count: 374});
let texture210 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder11.setBlendConstant({ r: 642.5, g: -64.53, b: 802.2, a: 857.8, });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 80, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(33).fill(55), /* required buffer size: 33 */
{offset: 33}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer117 = device0.createBuffer({size: 9511, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder184 = device0.createCommandEncoder({});
let texture211 = device0.createTexture({
  size: {width: 60},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder133 = commandEncoder184.beginComputePass({});
try {
computePassEncoder67.setBindGroup(1, bindGroup44, []);
} catch {}
try {
computePassEncoder98.setBindGroup(3, bindGroup101, new Uint32Array(2377), 205, 0);
} catch {}
try {
computePassEncoder131.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup43);
} catch {}
try {
renderPassEncoder53.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer8, 'uint32', 19_020, 231);
} catch {}
let autogeneratedBindGroupLayout88 = pipeline23.getBindGroupLayout(0);
let buffer118 = device0.createBuffer({size: 3522, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandEncoder185 = device0.createCommandEncoder({});
let textureView193 = texture197.createView({});
let sampler113 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  lodMinClamp: 6.541,
  lodMaxClamp: 19.88,
});
try {
computePassEncoder32.setBindGroup(3, bindGroup23, new Uint32Array(1201), 22, 0);
} catch {}
let texture212 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  dimension: '2d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder134 = commandEncoder185.beginComputePass({});
try {
renderPassEncoder28.setIndexBuffer(buffer70, 'uint16', 818, 1_575);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline25);
} catch {}
let commandEncoder186 = device0.createCommandEncoder({});
let querySet24 = device0.createQuerySet({type: 'occlusion', count: 110});
let texture213 = device0.createTexture({
  size: [336, 1, 26],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture214 = device0.createTexture({
  size: [144, 1, 13],
  mipLevelCount: 2,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder42.setBindGroup(3, bindGroup74);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer61, 'uint32', 7_052, 1_227);
} catch {}
try {
renderPassEncoder37.setPipeline(pipeline22);
} catch {}
try {
commandEncoder186.copyBufferToTexture({
  /* bytesInLastRow: 1096 widthInBlocks: 548 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 410 */
  offset: 410,
  bytesPerRow: 13056,
  buffer: buffer99,
}, {
  texture: texture206,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {width: 548, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let commandEncoder187 = device0.createCommandEncoder();
let texture215 = device0.createTexture({
  size: [72, 1, 55],
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder20.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(7, buffer8, 6_928, 237);
} catch {}
try {
commandEncoder187.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 328 */
  offset: 328,
  bytesPerRow: 10752,
  buffer: buffer8,
}, {
  texture: texture127,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder57.insertDebugMarker('\ufaf0');
} catch {}
try {
device0.queue.writeBuffer(buffer117, 3024, new Float32Array(14137), 510, 140);
} catch {}
let texture216 = device0.createTexture({
  size: {width: 72, height: 1, depthOrArrayLayers: 35},
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView194 = texture135.createView({aspect: 'all', baseMipLevel: 0});
let computePassEncoder135 = commandEncoder187.beginComputePass({});
try {
computePassEncoder8.setBindGroup(0, bindGroup99, []);
} catch {}
try {
computePassEncoder134.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup41);
} catch {}
try {
renderPassEncoder4.end();
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline20);
} catch {}
let promise25 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, constants: {}}});
let texture217 = device0.createTexture({
  size: [672, 1, 1],
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView195 = texture55.createView({arrayLayerCount: 1});
let sampler114 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', minFilter: 'linear', lodMaxClamp: 99.93});
try {
renderPassEncoder52.setVertexBuffer(7, buffer30);
} catch {}
try {
commandEncoder22.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2168 */
  offset: 2168,
  buffer: buffer116,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline26 = device0.createRenderPipeline({
  layout: pipelineLayout12,
  fragment: {module: shaderModule2, constants: {}, targets: [{format: 'rgba8uint', writeMask: 0}]},
  vertex: {
    module: shaderModule1,
    constants: {21_537: 0},
    buffers: [
      {
        arrayStride: 12,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 2, shaderLocation: 12},
          {format: 'uint8x4', offset: 0, shaderLocation: 9},
          {format: 'snorm8x4', offset: 0, shaderLocation: 10},
          {format: 'sint8x4', offset: 0, shaderLocation: 8},
          {format: 'uint8x4', offset: 0, shaderLocation: 15},
          {format: 'float32', offset: 0, shaderLocation: 1},
          {format: 'uint8x4', offset: 0, shaderLocation: 5},
          {format: 'float32', offset: 0, shaderLocation: 0},
          {format: 'sint8x2', offset: 2, shaderLocation: 7},
          {format: 'snorm8x2', offset: 0, shaderLocation: 14},
          {format: 'uint32x2', offset: 0, shaderLocation: 2},
          {format: 'sint16x2', offset: 0, shaderLocation: 6},
          {format: 'float16x4', offset: 0, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 508,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 152, shaderLocation: 4},
          {format: 'uint8x4', offset: 172, shaderLocation: 13},
        ],
      },
      {arrayStride: 500, attributes: [{format: 'unorm8x2', offset: 76, shaderLocation: 3}]},
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
let commandEncoder188 = device0.createCommandEncoder({});
let texture218 = device0.createTexture({
  size: {width: 336, height: 1, depthOrArrayLayers: 26},
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder136 = commandEncoder186.beginComputePass();
try {
computePassEncoder108.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer101, 'uint16', 48, 14);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); };
} catch {}
let texture219 = device0.createTexture({
  size: [60, 1, 6],
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder137 = commandEncoder22.beginComputePass({});
try {
computePassEncoder57.setPipeline(pipeline21);
} catch {}
try {
computePassEncoder137.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle5, renderBundle5]);
} catch {}
try {
commandEncoder188.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2020 */
  offset: 2020,
  bytesPerRow: 9728,
  rowsPerImage: 1243,
  buffer: buffer81,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder188.clearBuffer(buffer26);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture145,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(261).fill(199), /* required buffer size: 261 */
{offset: 261}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
canvas2.width = 742;
let buffer119 = device0.createBuffer({
  size: 7270,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture220 = device0.createTexture({
  size: [30, 1, 1],
  mipLevelCount: 2,
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture221 = gpuCanvasContext2.getCurrentTexture();
let computePassEncoder138 = commandEncoder188.beginComputePass();
let sampler115 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 90.72,
});
try {
computePassEncoder37.setBindGroup(3, bindGroup15);
} catch {}
try {
computePassEncoder135.setBindGroup(3, bindGroup55, new Uint32Array(241), 25, 0);
} catch {}
try {
renderPassEncoder7.setScissorRect(1, 0, 4, 0);
} catch {}
try {
renderPassEncoder43.setIndexBuffer(buffer88, 'uint16', 300, 38);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture200,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture222 = device0.createTexture({
  size: [672, 1, 19],
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder97.setBindGroup(1, bindGroup90);
} catch {}
try {
computePassEncoder135.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder54.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder52.setVertexBuffer(1, undefined, 125_871_368);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let querySet25 = device0.createQuerySet({type: 'occlusion', count: 1867});
let texture223 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 1},
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture224 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 13},
  mipLevelCount: 4,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView196 = texture117.createView({dimension: '2d', baseArrayLayer: 8, arrayLayerCount: 1});
try {
renderPassEncoder52.end();
} catch {}
try {
renderPassEncoder46.setIndexBuffer(buffer70, 'uint16', 944, 1_634);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(2, buffer83);
} catch {}
try {
buffer45.unmap();
} catch {}
try {
commandEncoder179.copyTextureToTexture({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 9, y: 15, z: 4},
  aspect: 'all',
},
{
  texture: texture35,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
},
{width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture225 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 204},
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture226 = device0.createTexture({
  size: {width: 576},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder131.setBindGroup(0, bindGroup39, new Uint32Array(4789), 1_131, 0);
} catch {}
try {
computePassEncoder138.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder32.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer55, 'uint32', 4_364, 1_203);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData11,
  origin: { x: 0, y: 3 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView197 = texture211.createView({aspect: 'all', format: 'r32float', arrayLayerCount: 1});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder98.setBindGroup(2, bindGroup65, new Uint32Array(1040), 83, 0);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer12, 'uint32', 712, 1_809);
} catch {}
try {
renderPassEncoder29.setVertexBuffer(3, buffer63);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer74, 'uint16', 24, 557);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 1, depthOrArrayLayers: 135}
*/
{
  source: imageBitmap3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture90,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 5},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = buffer112.label;
} catch {}
let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 19,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'float', multisampled: false },
    },
    {binding: 51, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 71,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {binding: 112, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {
      binding: 175,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 507,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let commandEncoder189 = device0.createCommandEncoder({});
let texture227 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder139 = commandEncoder189.beginComputePass({});
let sampler116 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 16,
});
try {
renderPassEncoder44.setViewport(43.32920322213799, 0.527578025081279, 17.695161556257727, 0.25692789486200013, 0.4543075365130582, 0.9970246741651067);
} catch {}
try {
renderPassEncoder34.setVertexBuffer(4, buffer57, 0, 1_354);
} catch {}
try {
commandEncoder179.copyBufferToTexture({
  /* bytesInLastRow: 2328 widthInBlocks: 291 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4520 */
  offset: 4520,
  bytesPerRow: 13312,
  buffer: buffer93,
}, {
  texture: texture20,
  mipLevel: 0,
  origin: {x: 399, y: 0, z: 0},
  aspect: 'all',
}, {width: 291, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture93,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(43).fill(49), /* required buffer size: 43 */
{offset: 43, rowsPerImage: 36}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder29.label = '\u{1fe04}\u3ac4\u0055\u117d\u{1fbce}\u103f\u0c62\u0b45\u0e12\u807e';
} catch {}
let autogeneratedBindGroupLayout89 = pipeline22.getBindGroupLayout(0);
let buffer120 = device0.createBuffer({size: 5933, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder190 = device0.createCommandEncoder({});
let texture228 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 1},
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView198 = texture217.createView({dimension: '2d-array'});
try {
computePassEncoder136.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup87);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer36, 'uint16', 980, 44);
} catch {}
try {
buffer85.unmap();
} catch {}
let bindGroup112 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout40,
  entries: [{binding: 79, resource: {buffer: buffer119, offset: 1024, size: 1110}}],
});
let buffer121 = device0.createBuffer({
  size: 15432,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder191 = device0.createCommandEncoder({});
let texture229 = device0.createTexture({
  size: [336, 1, 1],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder56 = commandEncoder179.beginRenderPass({
  colorAttachments: [{
  view: textureView195,
  clearValue: { r: 56.25, g: 922.7, b: -144.8, a: 474.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder139.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer55, 'uint16', 792, 775);
} catch {}
try {
buffer95.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,
});
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
let buffer122 = device0.createBuffer({
  label: '\u4031\u062d\u0ad5\u0e6c\u09cd\u{1ff48}\u{1fd9e}\u3533\u{1ffd5}\u51a6',
  size: 8841,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let texture230 = device0.createTexture({
  size: [30, 1, 1],
  mipLevelCount: 3,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder140 = commandEncoder191.beginComputePass({});
try {
computePassEncoder5.setBindGroup(1, bindGroup11, new Uint32Array(1432), 281, 0);
} catch {}
try {
computePassEncoder140.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder24.beginOcclusionQuery(8);
} catch {}
try {
renderBundleEncoder19.setBindGroup(2, bindGroup104);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline24);
} catch {}
try {
commandEncoder190.copyTextureToBuffer({
  texture: texture158,
  mipLevel: 0,
  origin: {x: 55, y: 9, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 88 */
  offset: 88,
  bytesPerRow: 34816,
  rowsPerImage: 634,
  buffer: buffer77,
}, {width: 6, height: 30, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture118,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(781).fill(120), /* required buffer size: 781 */
{offset: 781, rowsPerImage: 55}, {width: 617, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise26;
} catch {}
let buffer123 = device0.createBuffer({
  size: 19220,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder192 = device0.createCommandEncoder();
let texture231 = device0.createTexture({
  label: '\ud2e3\u02b0\u0856\u58d4\u0e9f',
  size: {width: 2688, height: 1, depthOrArrayLayers: 102},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true});
let renderBundle19 = renderBundleEncoder20.finish({});
let sampler117 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  lodMaxClamp: 84.35,
});
try {
computePassEncoder23.setBindGroup(0, bindGroup41, new Uint32Array(37), 4, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup37, new Uint32Array(103), 5, 0);
} catch {}
try {
renderPassEncoder15.setBlendConstant({ r: -861.0, g: 386.9, b: 296.9, a: -205.7, });
} catch {}
try {
renderPassEncoder12.setVertexBuffer(7, buffer37, 92);
} catch {}
try {
commandEncoder190.copyBufferToBuffer(buffer64, 560, buffer89, 2832, 680);
} catch {}
let buffer124 = device0.createBuffer({
  size: 9271,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let textureView199 = texture201.createView({dimension: '2d', baseArrayLayer: 1});
let renderBundle20 = renderBundleEncoder19.finish({});
let sampler118 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 84.43,
});
try {
computePassEncoder19.setBindGroup(1, bindGroup47);
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup9);
} catch {}
try {
buffer43.unmap();
} catch {}
let buffer125 = device0.createBuffer({size: 20478, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let texture232 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 34},
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture233 = device0.createTexture({
  size: {width: 288},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView200 = texture179.createView({format: 'rg8sint'});
let renderPassEncoder57 = commandEncoder190.beginRenderPass({
  colorAttachments: [{
  view: textureView195,
  clearValue: { r: -290.3, g: -329.9, b: -810.5, a: -621.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet22,
});
try {
computePassEncoder64.setBindGroup(2, bindGroup46);
} catch {}
try {
renderPassEncoder30.setBindGroup(1, bindGroup47);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer74, 'uint16', 244, 251);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture71,
  mipLevel: 0,
  origin: {x: 40, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(20).fill(26), /* required buffer size: 20 */
{offset: 20}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let autogeneratedBindGroupLayout90 = pipeline11.getBindGroupLayout(1);
let commandEncoder193 = device0.createCommandEncoder({});
let texture234 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder58 = commandEncoder192.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: -128.2, g: 750.1, b: 694.7, a: 264.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 133951285,
});
try {
computePassEncoder38.setBindGroup(2, bindGroup109);
} catch {}
try {
computePassEncoder132.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(549);
} catch {}
let commandEncoder194 = device0.createCommandEncoder({});
let texture235 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture236 = device0.createTexture({
  size: {width: 72},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder141 = commandEncoder193.beginComputePass();
let renderPassEncoder59 = commandEncoder194.beginRenderPass({
  colorAttachments: [{view: textureView172, depthSlice: 11, loadOp: 'clear', storeOp: 'discard'}],
  maxDrawCount: 369609521,
});
try {
renderPassEncoder22.executeBundles([renderBundle13]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'jedecP22Phosphors', transfer: 'bt709'} });
let commandEncoder195 = device0.createCommandEncoder({});
let texture237 = device0.createTexture({
  size: [144, 1, 1],
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder142 = commandEncoder195.beginComputePass({});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], stencilReadOnly: true});
let renderBundle21 = renderBundleEncoder21.finish();
try {
computePassEncoder133.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup104, new Uint32Array(1521), 15, 0);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.setBlendConstant({ r: -745.2, g: -543.4, b: 893.3, a: 217.1, });
} catch {}
let texture238 = device0.createTexture({
  size: {width: 240, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler119 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 92.62,
  maxAnisotropy: 14,
});
try {
computePassEncoder71.end();
} catch {}
try {
computePassEncoder142.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup50);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline13);
} catch {}
try {
commandEncoder94.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 32 */
  offset: 32,
  bytesPerRow: 22016,
  buffer: buffer86,
}, {
  texture: texture90,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder32.pushDebugGroup('\uc964');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 36, height: 1, depthOrArrayLayers: 33}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture90,
  mipLevel: 2,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout48]});
let commandEncoder196 = device0.createCommandEncoder({});
let texture239 = device0.createTexture({
  size: [288, 1, 84],
  format: 'r8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture240 = device0.createTexture({
  size: {width: 576},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rg8sint'],
});
try {
computePassEncoder0.setBindGroup(0, bindGroup68);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(1, buffer80, 648);
} catch {}
try {
commandEncoder94.resolveQuerySet(querySet8, 30, 57, buffer15, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandBuffer5 = commandEncoder94.finish();
let texture241 = device0.createTexture({
  size: [240, 1, 12],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture242 = device0.createTexture({
  size: [288],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder100.setBindGroup(1, bindGroup74, new Uint32Array(3326), 130, 0);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle5, renderBundle5]);
} catch {}
let commandEncoder197 = device0.createCommandEncoder();
let texture243 = device0.createTexture({
  size: [672, 1, 1],
  mipLevelCount: 2,
  format: 'rg16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder60 = commandEncoder196.beginRenderPass({
  colorAttachments: [{
  view: textureView130,
  clearValue: { r: 354.0, g: -350.5, b: 737.4, a: -958.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler120 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 53.08,
});
let externalTexture20 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
computePassEncoder98.setBindGroup(2, bindGroup70);
} catch {}
try {
computePassEncoder141.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle8, renderBundle2, renderBundle9, renderBundle10, renderBundle11, renderBundle18]);
} catch {}
try {
commandEncoder197.copyBufferToTexture({
  /* bytesInLastRow: 1280 widthInBlocks: 160 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4992 */
  offset: 4992,
  bytesPerRow: 17664,
  buffer: buffer8,
}, {
  texture: texture20,
  mipLevel: 0,
  origin: {x: 289, y: 0, z: 0},
  aspect: 'all',
}, {width: 160, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeBuffer(buffer75, 9200, new BigUint64Array(26286), 535, 176);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder198 = device0.createCommandEncoder({});
let texture244 = device0.createTexture({
  size: [60, 1, 158],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture245 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 229},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let texture246 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder62.setBindGroup(0, bindGroup58);
} catch {}
try {
renderPassEncoder39.setViewport(58.635485970359625, 0.6850047271412101, 4.924584021760421, 0.30225193504974, 0.548047451561764, 0.6818969700786687);
} catch {}
try {
renderPassEncoder53.setIndexBuffer(buffer96, 'uint32', 4_732, 1_788);
} catch {}
try {
renderPassEncoder42.setPipeline(pipeline7);
} catch {}
try {
commandEncoder198.copyTextureToBuffer({
  texture: texture217,
  mipLevel: 0,
  origin: {x: 188, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 48 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 756 */
  offset: 756,
  bytesPerRow: 1280,
  rowsPerImage: 1517,
  buffer: buffer96,
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder198.clearBuffer(buffer63);
} catch {}
await gc();
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpte170m', transfer: 'pq'} });
let autogeneratedBindGroupLayout91 = pipeline8.getBindGroupLayout(1);
let buffer126 = device0.createBuffer({size: 3027, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder199 = device0.createCommandEncoder({});
let texture247 = device0.createTexture({
  label: '\u{1fe13}\ucb1c\u0cb1',
  size: {width: 2688, height: 1, depthOrArrayLayers: 5},
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture248 = device0.createTexture({
  size: [240, 1, 20],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder61 = commandEncoder197.beginRenderPass({
  colorAttachments: [{view: textureView165, depthSlice: 32, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 31544650,
});
try {
renderPassEncoder24.beginOcclusionQuery(21);
} catch {}
try {
renderPassEncoder29.setViewport(29.27338130767818, 0.35226748230148497, 0.4089677634485223, 0.09228619745884167, 0.3111889420739209, 0.4732718533876571);
} catch {}
try {
renderPassEncoder60.setIndexBuffer(buffer106, 'uint16', 148, 3_186);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline2);
} catch {}
try {
commandEncoder198.clearBuffer(buffer10, 1144, 828);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let texture249 = device0.createTexture({
  size: [60, 1, 35],
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView201 = texture169.createView({});
let computePassEncoder143 = commandEncoder199.beginComputePass();
try {
computePassEncoder129.setBindGroup(2, bindGroup71, new Uint32Array(441), 54, 0);
} catch {}
try {
computePassEncoder143.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder32.setBindGroup(0, bindGroup93, new Uint32Array(1451), 163, 0);
} catch {}
try {
renderPassEncoder27.beginOcclusionQuery(7);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture174,
  mipLevel: 1,
  origin: {x: 12, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(77).fill(60), /* required buffer size: 77 */
{offset: 77}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u44ed\u{1f9fd}\udc19\u{1ffde}\u3ee3\u4ee3\ua901\u181f';
} catch {}
try {
texture144.label = '\u8c39\u991e\uc31e\u1720\u095d\u{1fef8}\ub214\u0c97\u9a2a\u1621\u0dfd';
} catch {}
let veryExplicitBindGroupLayout28 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 19,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'float', multisampled: false },
    },
    {binding: 51, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 71,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
    {binding: 112, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {
      binding: 175,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 507,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let commandEncoder200 = device0.createCommandEncoder({});
let texture250 = device0.createTexture({
  size: {width: 30, height: 1, depthOrArrayLayers: 40},
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView202 = texture81.createView({baseMipLevel: 0});
try {
computePassEncoder43.setBindGroup(3, bindGroup50, []);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, buffer38);
} catch {}
try {
buffer15.unmap();
} catch {}
try {
commandEncoder198.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 168 */
  offset: 168,
  buffer: buffer62,
}, {
  texture: texture230,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise27 = device0.queue.onSubmittedWorkDone();
let autogeneratedBindGroupLayout92 = pipeline19.getBindGroupLayout(0);
let commandEncoder201 = device0.createCommandEncoder({label: '\uc393\u08a8\u34d9\u0fb7\u73e5\u050d\uc02d\u{1fea5}\u36af'});
let texture251 = device0.createTexture({
  size: [2688, 1, 1],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder60.setBindGroup(3, bindGroup84);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline5);
} catch {}
try {
buffer16.unmap();
} catch {}
try {
commandEncoder201.copyTextureToTexture({
  texture: texture90,
  mipLevel: 2,
  origin: {x: 6, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture121,
  mipLevel: 2,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img3);
let imageData30 = new ImageData(84, 40);
let veryExplicitBindGroupLayout29 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 50,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 146,
      visibility: 0,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
  ],
});
let autogeneratedBindGroupLayout93 = pipeline20.getBindGroupLayout(0);
let bindGroup113 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout63,
  entries: [{binding: 73, resource: {buffer: buffer5, offset: 0, size: 1396}}],
});
let commandEncoder202 = device0.createCommandEncoder({});
let texture252 = device0.createTexture({
  size: [120, 1, 20],
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder89.setBindGroup(0, bindGroup81, new Uint32Array(824), 11, 0);
} catch {}
try {
renderPassEncoder27.endOcclusionQuery();
} catch {}
try {
renderPassEncoder15.setStencilReference(230);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer70, 'uint32', 1_588, 4_974);
} catch {}
try {
commandEncoder198.copyBufferToTexture({
  /* bytesInLastRow: 88 widthInBlocks: 44 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 304 */
  offset: 304,
  bytesPerRow: 1280,
  buffer: buffer64,
}, {
  texture: texture240,
  mipLevel: 0,
  origin: {x: 193, y: 0, z: 0},
  aspect: 'all',
}, {width: 44, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder110.pushDebugGroup('\u04b6');
} catch {}
document.body.append(img3);
let commandEncoder203 = device0.createCommandEncoder({});
let texture253 = device0.createTexture({
  size: {width: 1344},
  dimension: '1d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder144 = commandEncoder198.beginComputePass();
try {
computePassEncoder136.setBindGroup(2, bindGroup29, new Uint32Array(825), 6, 0);
} catch {}
try {
computePassEncoder144.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer71, 1_456, 1_321);
} catch {}
try {
computePassEncoder116.pushDebugGroup('\u{1fad1}');
} catch {}
let commandEncoder204 = device0.createCommandEncoder({});
let texture254 = device0.createTexture({
  size: {width: 2688, height: 1, depthOrArrayLayers: 206},
  mipLevelCount: 2,
  format: 'stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder145 = commandEncoder200.beginComputePass();
try {
renderPassEncoder44.setBindGroup(3, bindGroup64, new Uint32Array(764), 206, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder44.setIndexBuffer(buffer90, 'uint16', 542, 728);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
  await promise27;
} catch {}
let veryExplicitBindGroupLayout30 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 50,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 146,
      visibility: 0,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
  ],
});
let texture255 = device0.createTexture({
  size: [60, 1, 12],
  sampleCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler121 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 74.76,
  compare: 'equal',
  maxAnisotropy: 1,
});
try {
renderPassEncoder59.setIndexBuffer(buffer71, 'uint16', 1_394, 549);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer55, 0, 724);
} catch {}
try {
commandEncoder202.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 716 */
  offset: 716,
  buffer: buffer75,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer5]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 312, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(31).fill(135), /* required buffer size: 31 */
{offset: 31}, {width: 77, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); };
} catch {}
let bindGroup114 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout67,
  entries: [{binding: 79, resource: {buffer: buffer100, offset: 0, size: 69}}],
});
let texture256 = device0.createTexture({
  size: {width: 128, height: 128, depthOrArrayLayers: 13},
  mipLevelCount: 2,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder146 = commandEncoder204.beginComputePass({});
try {
computePassEncoder145.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup64, new Uint32Array(283), 6, 0);
} catch {}
try {
buffer89.unmap();
} catch {}
try {
commandEncoder202.copyBufferToBuffer(buffer40, 236, buffer5, 1360, 540);
} catch {}
try {
commandEncoder202.copyTextureToTexture({
  texture: texture71,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture71,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 6},
  aspect: 'all',
}, new Uint8Array(28_667).fill(229), /* required buffer size: 28_667 */
{offset: 107, bytesPerRow: 136, rowsPerImage: 21}, {width: 13, height: 0, depthOrArrayLayers: 11});
} catch {}
let buffer127 = device0.createBuffer({size: 3691, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder205 = device0.createCommandEncoder();
let texture257 = device0.createTexture({
  size: {width: 1344, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 7,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture258 = device0.createTexture({
  size: {width: 120},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let veryExplicitBindGroupLayout31 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 35,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 67,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 91, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let texture259 = device0.createTexture({
  size: {width: 336, height: 1, depthOrArrayLayers: 26},
  dimension: '2d',
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder147 = commandEncoder201.beginComputePass({});
try {
renderPassEncoder23.setBindGroup(1, bindGroup103, new Uint32Array(195), 26, 0);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(2, buffer124, 908);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder203.copyBufferToTexture({
  /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3640 */
  offset: 3640,
  buffer: buffer46,
}, {
  texture: texture159,
  mipLevel: 1,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {width: 9, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder205.insertDebugMarker('\u50b5');
} catch {}
let autogeneratedBindGroupLayout94 = pipeline3.getBindGroupLayout(1);
let textureView203 = texture256.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 6});
let texture260 = device0.createTexture({
  size: {width: 60, height: 1, depthOrArrayLayers: 80},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let sampler122 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.25,
  maxAnisotropy: 6,
});
try {
computePassEncoder146.setPipeline(pipeline21);
} catch {}
try {
commandEncoder203.copyTextureToTexture({
  texture: texture214,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture242,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
},
{width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder203.resolveQuerySet(querySet5, 33, 50, buffer78, 512);
} catch {}
let autogeneratedBindGroupLayout95 = pipeline22.getBindGroupLayout(1);
let texture261 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 48},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder148 = commandEncoder202.beginComputePass();
try {
computePassEncoder26.setBindGroup(3, bindGroup47);
} catch {}
try {
renderPassEncoder50.setPipeline(pipeline11);
} catch {}
try {
commandEncoder205.copyTextureToTexture({
  texture: texture133,
  mipLevel: 0,
  origin: {x: 70, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture235,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 1, depthOrArrayLayers: 62}
*/
{
  source: videoFrame21,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture132,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 45},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

requires readonly_and_readwrite_storage_textures;

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

override override23: i32;

@group(0) @binding(75) var st8: texture_storage_2d<r32float, read_write>;

override override22: f32;

struct FragmentOutput5 {
  @location(1) f0: vec2u,
  @location(0) @interpolate(flat) f1: vec4u,
}

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

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

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

struct T0 {
  f0: vec4h,
  @size(208) f1: array<mat2x4f, 1>,
  @align(8) @size(40) f2: array<mat4x2h, 2>,
}

@id(30900) override override24: f16;

override override21: i32;

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

var<workgroup> vw26: array<atomic<i32>, 5>;

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

fn fn0() -> vec2u {
  var out: vec2u;
  var vf86: f32 = override20;
  let vf87: vec2f = clamp(vec2f(unconst_f32(-0.3377), unconst_f32(0.00071)), vec2f(unconst_f32(0.04542), unconst_f32(-0.04116)), vec2f(unconst_f32(-0.03957), unconst_f32(0.00527)));
  out >>= vec2u(saturate(vec2h(unconst_f16(2897.9), unconst_f16(4104.4))));
  var vf88: f32 = override20;
  var vf89: i32 = override21;
  var vf90: f32 = floor(f32(unconst_f32(0.1044)));
  vf89 -= vec2i(vf87).g;
  var vf91: vec2f = vf87;
  let vf92: u32 = pack4x8snorm(vec4f(unconst_f32(0.03655), unconst_f32(0.2347), unconst_f32(-0.5129), unconst_f32(0.1008)));
  vf86 = f32(vf89);
  vf91 *= vec2f(f32(any(bool(unconst_bool(true)))));
  vf89 = i32(vf87[u32(unconst_u32(97))]);
  vf90 -= f32(firstLeadingBit(vec3i(unconst_i32(181), unconst_i32(168), unconst_i32(27))).y);
  vf89 = bitcast<i32>(floor(f32(unconst_f32(0.02732))));
  vf90 = f32(atanh(vec4h(unconst_f16(8740.1), unconst_f16(2221.2), unconst_f16(458.9), unconst_f16(13852.2)))[0]);
  vf89 = vec3i(min(vec3u(unconst_u32(14), unconst_u32(184), unconst_u32(329)), vec3u(unconst_u32(268), unconst_u32(42), unconst_u32(278))))[0];
  vf86 = vec4f(log(bitcast<vec4h>(clamp(vec2u(unconst_u32(29), unconst_u32(13)), vec2u(unconst_u32(24), unconst_u32(384)), vec2u(unconst_u32(134), unconst_u32(127)))))).r;
  return out;
  _ = override20;
  _ = override21;
}

struct FragmentOutput4 {
  @location(7) @interpolate(flat) f0: vec2u,
  @location(0) f1: vec2i,
}

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

@id(37596) override override20 = 0.1109;

@fragment
fn fragment5() -> FragmentOutput4 {
  var out: FragmentOutput4;
  out.f1 = vec2i(unpack2x16snorm(u32(unconst_u32(120))));
  fn0();
  var vf93 = fn0();
  out.f0 -= vec2u(dot4U8Packed(u32(exp(f16(unconst_f16(3439.3)))), bitcast<u32>(override22)));
  var vf94 = fn0();
  let ptr64: ptr<function, vec2u> = &vf94;
  var vf95 = fn0();
  out.f1 &= vec2i(i32(vf95[u32(unconst_u32(242))]));
  var vf96 = fn0();
  vf94 *= (*ptr64);
  fn0();
  vf96 -= vec2u(bitcast<u32>(dot(vec3i(unconst_i32(28), unconst_i32(69), unconst_i32(49)), vec3i(bitcast<i32>(vf94[u32(unconst_u32(105))])))));
  var vf97 = fn0();
  var vf98: u32 = dot4U8Packed(u32(unconst_u32(205)), vf94[u32(unconst_u32(21))]);
  return out;
  _ = override21;
  _ = override22;
  _ = override20;
}

@fragment
fn fragment6() -> FragmentOutput5 {
  var out: FragmentOutput5;
  fn0();
  var vf99 = fn0();
  out.f0 &= vec2u(bitcast<u32>(override20));
  out.f0 |= vec2u(bitcast<u32>(dot4I8Packed(u32(unconst_u32(98)), u32(unconst_u32(360)))));
  var vf100: vec2u = textureDimensions(et2);
  vf99 |= bitcast<vec2u>(cross(vec3f(unconst_f32(0.1761), unconst_f32(0.02809), unconst_f32(0.08904)), vec3f(bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(-0.1823), unconst_f32(0.4834), unconst_f32(0.2460), unconst_f32(0.1304)))))).zy);
  let vf101: u32 = vf99[u32(unconst_u32(270))];
  let vf102: f16 = override24;
  var vf103: i32 = dot4I8Packed(u32(unconst_u32(182)), u32(unconst_u32(14)));
  vf99 -= vec2u(u32(vf102));
  var vf104: vec4f = acosh(vec4f(unconst_f32(0.1326), unconst_f32(0.2356), unconst_f32(0.01298), unconst_f32(0.00046)));
  out.f1 = unpack4xU8(bitcast<u32>(vf104[u32(unconst_u32(97))]));
  fn0();
  var vf105: f32 = override22;
  var vf106: vec3f = log2(vec3f(f32(pack4x8unorm(vec4f(unconst_f32(0.1396), unconst_f32(0.02003), unconst_f32(0.04011), unconst_f32(0.03482))))));
  out.f1 = vec4u(u32(vf103));
  vf104 = vec4f(tan(vec3h(unconst_f16(11375.1), unconst_f16(11428.9), unconst_f16(7552.2))).rrbg);
  out.f0 |= vec2u(u32(vf103));
  vf105 *= bitcast<f32>(vf99[u32(unconst_u32(83))]);
  out.f1 >>= vec4u(acosh(vec4f(unconst_f32(0.4860), unconst_f32(0.4316), unconst_f32(0.2529), unconst_f32(0.1924))));
  let vf107: u32 = vf101;
  vf106 += unpack4x8snorm(u32(unconst_u32(103))).yyx;
  out.f1 ^= unpack4xU8(bitcast<u32>(dot4I8Packed(u32(unconst_u32(145)), u32(unconst_u32(203)))));
  let vf108: f16 = vf102;
  return out;
  _ = override21;
  _ = override20;
  _ = override24;
  _ = override22;
  _ = et2;
}

@compute @workgroup_size(1, 1, 1)
fn compute4() {
  textureStore(st8, vec2i(unconst_i32(115), unconst_i32(64)), vec4f(vec4f(unconst_f32(-0.2618), unconst_f32(0.08543), unconst_f32(0.1229), unconst_f32(0.1287))));
  let vf109: vec4i = countOneBits(vec4i(unconst_i32(105), unconst_i32(235), unconst_i32(150), unconst_i32(243)));
  _ = st8;
}`,
});
let textureView204 = texture245.createView({});
try {
computePassEncoder143.setBindGroup(1, bindGroup32);
} catch {}
try {
computePassEncoder106.setBindGroup(1, bindGroup30, new Uint32Array(363), 42, 0);
} catch {}
try {
computePassEncoder147.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup91);
} catch {}
try {
commandEncoder203.clearBuffer(buffer69, 12, 592);
} catch {}
try {
computePassEncoder110.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer55, 1780, new BigUint64Array(35398), 10903, 68);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture193,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(5).fill(254), /* required buffer size: 5 */
{offset: 5, bytesPerRow: 291}, {width: 57, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder206 = device0.createCommandEncoder();
let textureView205 = texture236.createView({aspect: 'all'});
let computePassEncoder149 = commandEncoder205.beginComputePass({});
try {
renderPassEncoder9.setBindGroup(0, bindGroup32, new Uint32Array(14), 0, 0);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder36.setVertexBuffer(1, buffer57);
} catch {}
let arrayBuffer8 = buffer49.getMappedRange(824, 8);
document.body.append(canvas1);
let imageData31 = new ImageData(16, 136);
let bindGroup115 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 79, resource: {buffer: buffer115, offset: 256, size: 2698}}],
});
let texture262 = device0.createTexture({
  size: {width: 576, height: 1, depthOrArrayLayers: 18},
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder62 = commandEncoder206.beginRenderPass({colorAttachments: [{view: textureView21, loadOp: 'load', storeOp: 'store'}]});
try {
computePassEncoder148.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer80, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder35.pushDebugGroup('\ud294');
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let videoFrame26 = new VideoFrame(canvas0, {timestamp: 0});
let buffer129 = device0.createBuffer({
  size: 17763,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder207 = device0.createCommandEncoder();
let textureView206 = texture128.createView({format: 'rg32float'});
let shaderModule7 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

enable f16;

var<workgroup> vw27: FragmentOutput6;

override override28: f16 = 10756.0;

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

@id(63613) override override25: i32;

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

var<private> vp14 = array(modf(f32(0.2279)));

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

@group(0) @binding(127) var<uniform> buffer131: array<array<mat2x3h, 29>, 3>;

@group(1) @binding(127) var<uniform> buffer133: array<array<array<array<vec4f, 3>, 1>, 29>, 1>;

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

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

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

override override32: f16;

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

@id(52961) override override27: u32 = 74;

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

@id(52835) override override29: f32;

@group(0) @binding(79) var<uniform> buffer130: mat3x3f;

override override31: u32;

struct FragmentOutput6 {
  @location(0) @interpolate(flat, sample) f0: vec4f,
  @location(2) @interpolate(flat, centroid) f1: u32,
}

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

struct T3 {
  @size(304) f0: mat2x3h,
  @size(1088) f1: array<T0>,
}

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

override override30 = true;

@group(1) @binding(79) var<uniform> buffer132: array<array<array<array<VertexOutput8, 1>, 1>, 6>, 1>;

override override26 = -221;

struct T1 {
  @size(112) f0: array<mat2x4f, 1>,
}

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

@vertex
fn vertex8() -> VertexOutput7 {
  var out: VertexOutput7;
  vp14[u32(unconst_u32(76))] = modf((*&buffer132)[0][5][0][0].f13[2]);
  let ptr65 = &vp14[u32(unconst_u32(226))];
  out = VertexOutput7((*&buffer132)[0][5][u32(unconst_u32(5))][0].f13);
  vp14[u32(acosh(f16(vp14[0].whole)))] = modf(buffer132[0][5][bitcast<u32>((*&buffer132)[u32(unconst_u32(176))][5][0][u32(unconst_u32(111))].f13.r)][0].f13[1]);
  let vf110: f32 = buffer132[u32(unconst_u32(210))][u32(unconst_u32(19))][u32(unconst_u32(0))][0].f13[u32(unconst_u32(4))];
  let ptr66: ptr<uniform, VertexOutput8> = &(*&buffer132)[0][u32(unconst_u32(85))][0][u32(unconst_u32(36))];
  let ptr67: ptr<uniform, array<array<VertexOutput8, 1>, 1>> = &(*&buffer132)[0][5];
  out = VertexOutput7((*&buffer132)[0][pack4xU8Clamp(vec4u(buffer132[u32(unconst_u32(325))][u32(unconst_u32(82))][0][u32(unconst_u32(82))].f13))][0][u32(unconst_u32(247))].f13);
  let vf111: vec2u = textureDimensions(tex8, i32(unconst_i32(315)));
  vp14[u32(unconst_u32(295))].whole -= buffer132[u32(unconst_u32(197))][5][0][pack4x8snorm(buffer132[u32(unconst_u32(526))][5][0][0].f13)].f13[2];
  var vf112: f32 = (*&buffer132)[0][5][0][0].f13[u32((*&buffer132)[override31][5][0][0].f13.a)];
  let ptr68: ptr<uniform, vec4f> = &(*&buffer132)[u32(unconst_u32(27))][u32(unconst_u32(198))][0][0].f13;
  let vf113: f32 = (*ptr67)[bitcast<u32>(override29)][u32((*&buffer132)[0][5][0][u32(unconst_u32(186))].f13[u32(unconst_u32(278))])].f13[u32(unconst_u32(105))];
  vp14[u32(unconst_u32(248))] = modf(buffer132[0][u32(unconst_u32(31))][0][u32(unconst_u32(88))].f13.r);
  out.f12 = (*ptr67)[0][0].f13;
  out.f12 = buffer132[u32(unconst_u32(122))][5][u32(unconst_u32(128))][u32(unconst_u32(170))].f13;
  let vf114: f32 = (*&buffer132)[bitcast<u32>(buffer132[u32(unconst_u32(178))][u32(unconst_u32(193))][u32(unconst_u32(133))][0].f13.g)][pack4x8snorm((*&buffer132)[u32(unconst_u32(78))][u32(unconst_u32(3))][0][u32(unconst_u32(529))].f13)][0][0].f13[pack4x8snorm(buffer132[0][5][0][0].f13)];
  let ptr69: ptr<uniform, array<VertexOutput8, 1>> = &buffer132[u32(unconst_u32(86))][5][0];
  let ptr70: ptr<uniform, VertexOutput8> = &(*&buffer132)[0][u32(unconst_u32(451))][u32(unconst_u32(18))][u32(unconst_u32(120))];
  var vf115: vec2f = reflect(bitcast<vec2f>(textureDimensions(tex8, i32(unconst_i32(207)))), vec2f(unconst_f32(0.03399), unconst_f32(-0.03487)));
  out = VertexOutput7(buffer132[0][u32(unconst_u32(328))][u32(unconst_u32(49))][0].f13);
  let ptr71 = &vp14[u32(unconst_u32(288))];
  return out;
  _ = override31;
  _ = override29;
  _ = buffer132;
  _ = tex8;
}

@vertex
fn vertex9(@location(10) @interpolate(flat) a0: vec4u, @location(3) @interpolate(flat, centroid) a1: i32, @location(14) a2: vec4f) -> VertexOutput8 {
  var out: VertexOutput8;
  let ptr72: ptr<uniform, VertexOutput8> = &(*&buffer132)[0][u32(unconst_u32(843))][u32(unconst_u32(31))][u32(unconst_u32(511))];
  let ptr73: ptr<uniform, VertexOutput8> = &(*&buffer132)[u32(unconst_u32(140))][u32(unconst_u32(52))][0][u32(unconst_u32(68))];
  let ptr74: ptr<private, f32> = &vp14[u32(unconst_u32(26))].whole;
  let ptr75: ptr<uniform, VertexOutput8> = &(*&buffer132)[0][u32((*&buffer132)[u32(unconst_u32(30))][u32(unconst_u32(150))][0][0].f13[u32(unconst_u32(302))])][0][u32(unconst_u32(214))];
  var vf116: f32 = (*&buffer132)[u32(unconst_u32(165))][5][0][0].f13[u32(unconst_u32(19))];
  vp14[u32(unconst_u32(449))].fract -= (*ptr72).f13[u32(unconst_u32(376))];
  let ptr76: ptr<private, f32> = &vp14[u32(unconst_u32(6))].whole;
  let ptr77: ptr<uniform, vec4f> = &buffer132[u32(unconst_u32(154))][5][u32(unconst_u32(36))][u32(unconst_u32(83))].f13;
  let ptr78: ptr<uniform, VertexOutput8> = &buffer132[0][5][u32(unconst_u32(86))][0];
  let ptr79: ptr<uniform, VertexOutput8> = &buffer132[0][u32(unconst_u32(159))][u32(unconst_u32(263))][0];
  var vf117: f32 = (*ptr75).f13[u32(unconst_u32(531))];
  let ptr80: ptr<uniform, vec4f> = &buffer132[u32(unconst_u32(392))][5][0][0].f13;
  let vf118: f32 = (*ptr80)[pack4x8snorm((*&buffer132)[0][5][0][0].f13)];
  vf116 = bitcast<f32>(textureNumLevels(tex7));
  let ptr81: ptr<uniform, VertexOutput8> = &(*&buffer132)[0][5][0][0];
  out.f13 = vec4f((*&buffer132)[u32(unconst_u32(73))][u32(unconst_u32(152))][u32(unconst_u32(68))][0].f13[u32(unconst_u32(214))]);
  vf117 = f32(override28);
  return out;
  _ = override28;
  _ = tex7;
  _ = buffer132;
}

@fragment
fn fragment7() -> FragmentOutput6 {
  var out: FragmentOutput6;
  let vf119: f32 = (*&buffer132)[u32(unconst_u32(61))][5][u32(unconst_u32(31))][u32(unconst_u32(85))].f13[u32(unconst_u32(50))];
  let vf120: vec2f = floor(vec2f(unconst_f32(0.1515), unconst_f32(0.05821)));
  out.f0 = (*&buffer132)[u32(unconst_u32(22))][5][u32(unconst_u32(371))][u32(unconst_u32(548))].f13;
  let ptr82: ptr<uniform, VertexOutput8> = &buffer132[0][5][u32(unconst_u32(0))][u32(unconst_u32(58))];
  out.f1 = vec4u(buffer132[0][5][u32(unconst_u32(10))][0].f13).y;
  let ptr83: ptr<uniform, array<VertexOutput8, 1>> = &(*&buffer132)[0][u32((*&buffer132)[u32((*&buffer132)[u32(unconst_u32(143))][5][u32(unconst_u32(341))][0].f13[3])][5][0][u32(unconst_u32(52))].f13[u32(unconst_u32(172))])][0];
  let ptr84: ptr<uniform, vec4f> = &(*&buffer132)[0][5][u32(unconst_u32(121))][u32(unconst_u32(171))].f13;
  let ptr85: ptr<uniform, vec4f> = &buffer132[0][u32(unconst_u32(16))][u32(unconst_u32(129))][u32(unconst_u32(56))].f13;
  vp14[u32(unconst_u32(375))].whole = buffer132[0][u32(unconst_u32(90))][bitcast<vec4u>((*ptr83)[u32(unconst_u32(572))].f13)[1]][0].f13[pack4x8snorm((*&buffer132)[0][5][0][0].f13)];
  let ptr86: ptr<uniform, array<array<array<VertexOutput8, 1>, 1>, 6>> = &(*&buffer132)[0];
  let ptr87: ptr<uniform, vec4f> = &buffer132[0][5][0][u32(unconst_u32(298))].f13;
  return out;
  _ = buffer132;
}

@compute @workgroup_size(3, 1, 2)
fn compute5() {
  vw27.f1 = u32(buffer132[u32(unconst_u32(240))][5][u32(unconst_u32(15))][u32(unconst_u32(22))].f13[u32(unconst_u32(27))]);
  var vf121: vec2u = textureDimensions(tex8, i32(unconst_i32(113)));
  let ptr88: ptr<uniform, array<array<vec4f, 3>, 1>> = &buffer133[u32(unconst_u32(25))][u32(unconst_u32(322))];
  vp14[u32(unconst_u32(76))] = modf((*&buffer132)[u32(unconst_u32(165))][5][u32(unconst_u32(429))][0].f13.a);
  let ptr89: ptr<uniform, mat2x3h> = &(*&buffer131)[u32(unconst_u32(57))][u32(unconst_u32(13))];
  let ptr90: ptr<uniform, array<array<array<array<vec4f, 3>, 1>, 29>, 1>> = &(*&buffer133);
  vw27.f1 = u32(buffer133[u32(unconst_u32(4))][u32(unconst_u32(233))][0][2][1]);
  vf121 ^= bitcast<vec2u>((*ptr90)[u32(unconst_u32(500))][28][0][2].bg);
  vw27 = FragmentOutput6(vec4f((*&buffer132)[u32(unconst_u32(211))][u32(unconst_u32(248))][0][u32(unconst_u32(210))].f13[u32(unconst_u32(300))]), u32((*&buffer132)[u32(unconst_u32(211))][u32(unconst_u32(248))][0][u32(unconst_u32(210))].f13[u32(unconst_u32(300))]));
  let ptr91: ptr<uniform, array<mat2x3h, 29>> = &(*&buffer131)[u32(unconst_u32(137))];
  vw27.f1 = u32(buffer133[0][28][vec3u((*ptr91)[28][u32(unconst_u32(81))]).y][2].z);
  let ptr92: ptr<uniform, vec4f> = &(*&buffer133)[0][u32(unconst_u32(17))][0][u32(unconst_u32(395))];
  vw27.f1 = vec3u(buffer130[unconst_i32(2)])[0];
  let ptr93: ptr<uniform, vec4f> = &(*ptr90)[0][u32(unconst_u32(116))][0][u32(unconst_u32(77))];
  let ptr94: ptr<uniform, vec4f> = &buffer132[0][5][0][0].f13;
  vp14[u32(unconst_u32(612))].fract = buffer132[0][u32(unconst_u32(232))][0][0].f13.a;
  let ptr95: ptr<uniform, vec4f> = &(*&buffer133)[u32(unconst_u32(200))][28][0][2];
  vp14[u32(unconst_u32(18))].fract = vp14[u32(unconst_u32(33))].whole;
  let ptr96: ptr<uniform, mat2x3h> = &buffer131[u32(unconst_u32(454))][28];
  _ = buffer133;
  _ = buffer132;
  _ = buffer130;
  _ = buffer131;
  _ = tex8;
}`,
});
let bindGroup116 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout72,
  entries: [{binding: 79, resource: {buffer: buffer37, offset: 1280, size: 357}}],
});
let commandEncoder208 = device0.createCommandEncoder({});
try {
computePassEncoder64.setBindGroup(1, bindGroup24, new Uint32Array(331), 41, 0);
} catch {}
try {
computePassEncoder149.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder14.beginOcclusionQuery(87);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle17, renderBundle21, renderBundle1, renderBundle15, renderBundle18, renderBundle1, renderBundle11]);
} catch {}
try {
  await buffer113.mapAsync(GPUMapMode.WRITE, 0, 1760);
} catch {}
let autogeneratedBindGroupLayout96 = pipeline17.getBindGroupLayout(0);
let buffer134 = device0.createBuffer({
  size: 11506,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder209 = device0.createCommandEncoder({});
let textureView207 = texture172.createView({dimension: '2d', baseArrayLayer: 12});
let textureView208 = texture110.createView({dimension: '2d', format: 'rgba8uint'});
let computePassEncoder150 = commandEncoder207.beginComputePass({});
let renderPassEncoder63 = commandEncoder208.beginRenderPass({
  colorAttachments: [{
  view: textureView135,
  clearValue: { r: -623.0, g: -196.3, b: -491.9, a: 433.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true});
try {
computePassEncoder150.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder14.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup0, new Uint32Array(1139), 301, 0);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline24);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let texture263 = device0.createTexture({
  size: {width: 144, height: 1, depthOrArrayLayers: 1},
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder151 = commandEncoder203.beginComputePass({});
try {
computePassEncoder151.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder7.setViewport(4.568504941008076, 0.6619666438617245, 20.681621219232305, 0.05016530626739068, 0.5537970305645159, 0.9345059666904383);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup10, new Uint32Array(1272), 316, 0);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer109, 'uint32', 188, 461);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(5, buffer26, 0, 478);
} catch {}
try {
commandEncoder209.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 36 */
  offset: 36,
  bytesPerRow: 5376,
  rowsPerImage: 836,
  buffer: buffer103,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder209.copyTextureToTexture({
  texture: texture162,
  mipLevel: 1,
  origin: {x: 26, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup117 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout74,
  entries: [{binding: 73, resource: {buffer: buffer74, offset: 0, size: 68}}],
});
let computePassEncoder152 = commandEncoder209.beginComputePass({});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], stencilReadOnly: true});
try {
computePassEncoder93.setBindGroup(3, bindGroup1, new Uint32Array(4), 0, 0);
} catch {}
try {
computePassEncoder152.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder37.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder40.setIndexBuffer(buffer7, 'uint32', 360, 292);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline13);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture234,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(31).fill(214), /* required buffer size: 31 */
{offset: 31}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'gamma28curve'} });
let autogeneratedBindGroupLayout97 = pipeline13.getBindGroupLayout(0);
let bindGroup118 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout94,
  entries: [{binding: 79, resource: {buffer: buffer12, offset: 256, size: 3319}}],
});
let textureView209 = texture35.createView({baseMipLevel: 0, arrayLayerCount: 1});
try {
renderPassEncoder28.setBindGroup(3, bindGroup118);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer74, 'uint16', 94, 154);
} catch {}
try {
buffer38.unmap();
} catch {}
let bindGroup119 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [{binding: 79, resource: {buffer: buffer111, offset: 0, size: 84}}],
});
try {
renderPassEncoder59.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder23.setBindGroup(2, bindGroup78, new Uint32Array(2648), 1_008, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let buffer135 = device0.createBuffer({
  size: 20155,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let sampler123 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 86.29,
});
try {
computePassEncoder12.setBindGroup(0, bindGroup62);
} catch {}
try {
computePassEncoder122.setBindGroup(2, bindGroup93, new Uint32Array(3978), 2_134, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline24);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 120, height: 1, depthOrArrayLayers: 10}
*/
{
  source: videoFrame18,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture248,
  mipLevel: 1,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture17.label = '\u{1f8b6}\u297c';
} catch {}
try {
computePassEncoder80.setBindGroup(3, bindGroup84);
} catch {}
try {
computePassEncoder82.setBindGroup(0, bindGroup72, new Uint32Array(1168), 86, 0);
} catch {}
try {
renderPassEncoder43.setPipeline(pipeline15);
} catch {}
try {
renderBundleEncoder23.setBindGroup(0, bindGroup99, new Uint32Array(794), 70, 0);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer15, 'uint32', 400, 31);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 13}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 8},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let textureView210 = texture62.createView({dimension: '2d-array', mipLevelCount: 2});
let sampler124 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 65.73});
try {
computePassEncoder131.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder45.setVertexBuffer(4, buffer112, 0);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup90);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup10, new Uint32Array(635), 21, 0);
} catch {}
document.body.append(canvas1);
let commandEncoder210 = device0.createCommandEncoder({});
let textureView211 = texture204.createView({});
let computePassEncoder153 = commandEncoder210.beginComputePass({});
let sampler125 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.28,
  compare: 'never',
});
try {
computePassEncoder153.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder28.setBindGroup(0, bindGroup52);
} catch {}
try {
renderPassEncoder60.executeBundles([renderBundle14, renderBundle1]);
} catch {}
try {
renderPassEncoder12.setStencilReference(1249);
} catch {}
try {
renderPassEncoder47.setIndexBuffer(buffer21, 'uint16', 482, 501);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline8);
} catch {}
try {
computePassEncoder66.insertDebugMarker('\ue334');
} catch {}
let promise28 = device0.queue.onSubmittedWorkDone();
let bindGroup120 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout51,
  entries: [
    {binding: 125, resource: textureView176},
    {binding: 79, resource: {buffer: buffer30, offset: 0, size: 1199}},
  ],
});
let buffer136 = device0.createBuffer({size: 38692, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let texture264 = gpuCanvasContext2.getCurrentTexture();
let textureView212 = texture97.createView({baseArrayLayer: 24, arrayLayerCount: 2});
try {
computePassEncoder88.setBindGroup(3, bindGroup92);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(5, buffer45, 1_100, 16_717);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 24},
  aspect: 'all',
}, new Uint8Array(98_328).fill(70), /* required buffer size: 98_328 */
{offset: 152, bytesPerRow: 208, rowsPerImage: 8}, {width: 11, height: 0, depthOrArrayLayers: 60});
} catch {}
await gc();
let autogeneratedBindGroupLayout98 = pipeline18.getBindGroupLayout(0);
let bindGroup121 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout87,
  entries: [{binding: 79, resource: {buffer: buffer5, offset: 0, size: 509}}],
});
let texture265 = device0.createTexture({
  size: {width: 120, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture266 = gpuCanvasContext1.getCurrentTexture();
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], stencilReadOnly: true});
try {
computePassEncoder147.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder43.executeBundles([renderBundle13, renderBundle6, renderBundle13, renderBundle6]);
} catch {}
try {
renderPassEncoder37.setIndexBuffer(buffer71, 'uint32', 88, 2_908);
} catch {}
try {
renderPassEncoder39.setVertexBuffer(7, buffer23);
} catch {}
try {
renderPassEncoder59.insertDebugMarker('\u3d2e');
} catch {}
try {
adapter0.label = '\u8ef2\u0b7a';
} catch {}
let autogeneratedBindGroupLayout99 = pipeline10.getBindGroupLayout(1);
let bindGroup122 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout3,
  entries: [
    {binding: 125, resource: textureView7},
    {binding: 79, resource: {buffer: buffer27, offset: 1280, size: 726}},
  ],
});
let sampler126 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  lodMaxClamp: 85.87,
});
try {
computePassEncoder69.setBindGroup(0, bindGroup78);
} catch {}
try {
computePassEncoder120.setBindGroup(1, bindGroup3, new Uint32Array(4672), 556, 0);
} catch {}
try {
renderPassEncoder24.beginOcclusionQuery(25);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder47.executeBundles([renderBundle18]);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, undefined, 0);
} catch {}
try {
renderBundleEncoder23.setBindGroup(0, bindGroup118, new Uint32Array(1619), 303, 0);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline24);
} catch {}
let autogeneratedBindGroupLayout100 = pipeline16.getBindGroupLayout(0);
let buffer137 = device0.createBuffer({
  size: 5474,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder211 = device0.createCommandEncoder({});
let querySet26 = device0.createQuerySet({type: 'occlusion', count: 294});
let textureView213 = texture172.createView({dimension: '2d', format: 'rgba16sint'});
let textureView214 = texture122.createView({label: '\uf55b\u53ac\u0d2d\ufcb4\u033c\u{1fe4b}\u002e\u{1fdca}\u9a3e'});
let computePassEncoder154 = commandEncoder211.beginComputePass({});
let sampler127 = device0.createSampler({addressModeV: 'mirror-repeat', mipmapFilter: 'linear', lodMaxClamp: 93.57});
try {
renderPassEncoder47.setBindGroup(3, bindGroup115, new Uint32Array(4028), 1_674, 0);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(0, buffer57);
} catch {}
try {
renderBundleEncoder24.setBindGroup(1, bindGroup15);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(7, buffer42);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt709', transfer: 'bt1361ExtendedColourGamut'} });
try {
adapter0.label = '\u{1fa8d}\u37d7\u{1fc05}\uae13\uad01';
} catch {}
let buffer138 = device0.createBuffer({
  size: 3233,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let textureView215 = texture46.createView({aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder109.setBindGroup(0, bindGroup93);
} catch {}
try {
computePassEncoder154.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder43.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer30, 'uint16', 1_166, 525);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline15);
} catch {}
let arrayBuffer9 = buffer49.getMappedRange(1352, 140);
let bindGroup123 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout99,
  entries: [{binding: 79, resource: {buffer: buffer52, offset: 768, size: 982}}],
});
let buffer139 = device0.createBuffer({
  size: 2928,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let commandEncoder212 = device0.createCommandEncoder({});
let computePassEncoder155 = commandEncoder212.beginComputePass();
let renderBundle22 = renderBundleEncoder23.finish({});
try {
computePassEncoder85.setBindGroup(2, bindGroup71);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup2, []);
} catch {}
try {
renderPassEncoder54.executeBundles([renderBundle13, renderBundle6, renderBundle5, renderBundle6]);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline0);
} catch {}
try {
  await buffer98.mapAsync(GPUMapMode.READ, 0, 888);
} catch {}
let pipeline27 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {mask: 0xc64573e},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment1',
  constants: {},
  targets: [{format: 'rgba8uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule7,
    entryPoint: 'vertex9',
    constants: {},
    buffers: [
      {
        arrayStride: 556,
        attributes: [
          {format: 'float32x3', offset: 28, shaderLocation: 14},
          {format: 'sint32', offset: 44, shaderLocation: 3},
          {format: 'uint16x4', offset: 36, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'},
});
try {
computePassEncoder152.setBindGroup(1, bindGroup108);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup59);
} catch {}
try {
renderPassEncoder34.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(1, buffer62, 0, 1_000);
} catch {}
let pipeline28 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment6',
  constants: {30_900: 0, override21: 0, override22: 0},
  targets: [{format: 'rgba8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule3,
    constants: {},
    buffers: [
      {
        arrayStride: 564,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 28, shaderLocation: 4},
          {format: 'float32x2', offset: 192, shaderLocation: 7},
          {format: 'sint32x2', offset: 36, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'},
});
await gc();
let autogeneratedBindGroupLayout101 = pipeline2.getBindGroupLayout(1);
let bindGroup124 = device0.createBindGroup({layout: veryExplicitBindGroupLayout17, entries: [{binding: 36, resource: textureView2}]});
let texture267 = device0.createTexture({
  size: {width: 30},
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder96.setBindGroup(2, bindGroup54, new Uint32Array(709), 39, 0);
} catch {}
try {
computePassEncoder155.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder63.setBindGroup(0, bindGroup92, new Uint32Array(389), 3, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer57);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup70);
} catch {}
try {
renderBundleEncoder24.setBindGroup(3, bindGroup5, new Uint32Array(1317), 759, 0);
} catch {}
let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'unspecified'} });
let texture268 = device0.createTexture({
  size: [144],
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder149.setBindGroup(0, bindGroup107, new Uint32Array(278), 96, 0);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup99);
} catch {}
try {
renderBundleEncoder24.setBindGroup(1, bindGroup88, new Uint32Array(1859), 69, 0);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer70, 'uint16', 5_372, 1_938);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(7, buffer123, 660);
} catch {}
let promise29 = device0.queue.onSubmittedWorkDone();
let texture269 = device0.createTexture({
  size: {width: 288, height: 1, depthOrArrayLayers: 84},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView216 = texture43.createView({});
let renderBundle23 = renderBundleEncoder22.finish();
try {
renderPassEncoder60.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder28.executeBundles([renderBundle13]);
} catch {}
try {
renderPassEncoder54.setVertexBuffer(0, buffer129);
} catch {}
try {
renderBundleEncoder24.setBindGroup(0, bindGroup61);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(5, buffer66, 0);
} catch {}
await gc();
let shaderModule8 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

enable f16;

requires packed_4x8_integer_dot_product;

requires readonly_and_readwrite_storage_textures;

var<private> vp15 = modf(vec2h(5724.9, 3854.3));

fn fn0(a0: ptr<storage, atomic<i32>, read_write>) -> mat4x2h {
  var out: mat4x2h;
  let ptr97: ptr<private, vec2h> = &vp15.fract;
  vp15.fract += (*ptr97);
  let ptr98: ptr<private, vec2h> = &(*ptr97);
  var vf122: i32 = atomicLoad(&(*a0));
  var vf123: vec4i = textureLoad(st9, vec2i(unconst_i32(16), unconst_i32(32)));
  var vf124: vec4i = textureLoad(st9, vec2i(unconst_i32(275), unconst_i32(426)));
  let ptr99 = &vp15;
  let ptr100: ptr<private, vec2h> = &(*ptr98);
  out += mat4x2h((*ptr98)[u32(unconst_u32(185))], (*ptr98)[u32(unconst_u32(185))], (*ptr98)[u32(unconst_u32(185))], (*ptr98)[u32(unconst_u32(185))], (*ptr98)[u32(unconst_u32(185))], (*ptr98)[u32(unconst_u32(185))], (*ptr98)[u32(unconst_u32(185))], (*ptr98)[u32(unconst_u32(185))]);
  let ptr101: ptr<private, vec2h> = &vp15.whole;
  vp16 -= vec4i((*ptr100).gggg);
  var vf125: i32 = atomicExchange(&(*a0), i32(unconst_i32(291)));
  out = mat4x2h((*ptr100), (*ptr100), (*ptr100), (*ptr100));
  var vf126: f16 = (*ptr97)[u32(unconst_u32(47))];
  let ptr102: ptr<private, vec2h> = &(*ptr99).whole;
  let ptr103: ptr<private, vec4i> = &vp16;
  vf123 |= vec4i(vp15.fract.xyyy);
  vp16 = vec4i(i32((*ptr97)[u32(unconst_u32(145))]));
  let ptr104: ptr<private, vec4i> = &(*ptr103);
  let ptr105: ptr<private, vec4i> = &vp16;
  let ptr106: ptr<private, vec4i> = &(*ptr103);
  vf124 ^= vec4i((*ptr97).xyxx);
  let ptr107: ptr<private, vec4i> = &(*ptr105);
  let vf127: f16 = saturate(f16(unconst_f16(4598.0)));
  return out;
  _ = st9;
}

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

var<workgroup> vw28: atomic<u32>;

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

fn fn1() -> mat3x4f {
  var out: mat3x4f;
  let ptr108: ptr<storage, vec2f, read_write> = &buffer140[u32(unconst_u32(208))];
  vp16 = bitcast<vec4i>(buffer140[arrayLength(&buffer140) - 1].gggg);
  out = mat3x4f((*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(172))]);
  out += mat3x4f(buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))], buffer140[u32(unconst_u32(226))][u32(unconst_u32(257))]);
  vp15 = modf(bitcast<vec2h>(buffer140[arrayLength(&buffer140)][u32(unconst_u32(19))]));
  let ptr109: ptr<storage, vec2f, read_write> = &(*&buffer140)[arrayLength(&(*&buffer140)) - 1];
  let ptr110: ptr<private, vec2h> = &vp15.whole;
  buffer140[u32(unconst_u32(11))] += vec2f(buffer140[arrayLength(&buffer140)][u32(unconst_u32(44))]);
  let ptr111: ptr<storage, vec2f, read_write> = &buffer140[u32(cosh(vec3f(unconst_f32(0.1946), unconst_f32(0.1899), unconst_f32(0.2154))).b)];
  vp16 = vec4i(vp15.whole.xxxy);
  var vf128: f16 = (*ptr110)[u32(unconst_u32(265))];
  let vf129: f16 = (*ptr110)[u32(unconst_u32(71))];
  let vf130: u32 = dot4U8Packed(u32(unconst_u32(120)), u32(unconst_u32(14)));
  vf128 = fract(bitcast<vec2h>((*ptr111)[u32(unconst_u32(363))])).y;
  let ptr112: ptr<storage, vec2f, read_write> = &buffer140[u32(vf128)];
  var vf131: f16 = (*ptr110)[u32(unconst_u32(130))];
  let ptr113: ptr<storage, vec2f, read_write> = &(*&buffer140)[u32(unconst_u32(112))];
  out -= mat3x4f(vec4f(vp15.fract.xyyy), vec4f(vp15.fract.yyyy), vec4f(vp15.fract.xyyx));
  let ptr114: ptr<private, vec4i> = &vp16;
  var vf132: f32 = (*ptr109)[u32(unconst_u32(3))];
  buffer140[u32(unconst_u32(478))] = (*&buffer140)[arrayLength(&(*&buffer140)) - 1];
  let ptr115: ptr<storage, vec2f, read_write> = &buffer140[u32(buffer140[arrayLength(&buffer140)][u32(unconst_u32(85))])];
  return out;
  _ = buffer140;
}

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

var<private> vp16: vec4i = vec4i(69, 244, -119, 157);

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

@group(0) @binding(73) var<storage, read_write> buffer140: array<vec2f>;

alias vec3b = vec3<bool>;

@group(0) @binding(57) var st9: texture_storage_2d<rg32sint, read>;

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

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

@vertex
fn vertex10(@location(9) @interpolate(flat) a0: u32, @location(3) a1: f16, @location(5) a2: vec2u, @location(2) @interpolate(linear) a3: vec2f) -> @builtin(position) vec4f {
  var out: vec4f;
  vp16 |= vec4i(i32(countLeadingZeros(u32(unconst_u32(85)))));
  vp16 = vec4i(bitcast<i32>(pack2x16snorm(vec2f(unconst_f32(0.2645), unconst_f32(0.1266)))));
  out = unpack4x8snorm(a2[pack4xU8Clamp(unpack4xU8(u32(unconst_u32(273))))]);
  vp16 = vec4i(i32(length(f16(unconst_f16(1567.1)))));
  var vf133: u32 = a0;
  vf133 -= pack2x16snorm(vec2f(unconst_f32(0.3378), unconst_f32(0.2317)));
  vp16 = unpack4xI8(vf133);
  var vf134: u32 = pack2x16snorm(vec2f(unconst_f32(0.1290), unconst_f32(0.00163)));
  vp16 *= vec4i(i32(pack2x16snorm(vec2f(unconst_f32(-0.1922), unconst_f32(0.06116)))));
  vp16 |= vec4i(acosh(vec2h(unconst_f16(5020.5), unconst_f16(41729.3))).rgrr);
  var vf135: vec3f = asinh(vec3f(unconst_f32(0.09956), unconst_f32(0.07084), unconst_f32(0.00949)));
  vp16 = vec4i(trunc(vec4h(unconst_f16(11986.6), unconst_f16(23.63), unconst_f16(2791.0), unconst_f16(19215.7))));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute6() {
  vp15 = modf(vec2h(cross(vec3f(unconst_f32(0.3170), unconst_f32(-0.2653), unconst_f32(0.1227)), vec3f(unconst_f32(-0.04129), unconst_f32(0.1750), unconst_f32(0.06311))).rb));
  let vf136: vec4i = textureLoad(st9, vec2i(unconst_i32(21), unconst_i32(156)));
  atomicCompareExchangeWeak(&vw28, unconst_u32(99), unconst_u32(97));
  vp15 = modf(vp15.fract);
  let ptr116: ptr<workgroup, atomic<u32>> = &vw28;
  var vf137 = fn1();
  vf137 = mat3x4f(bitcast<f32>(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), bitcast<f32>(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), f32(atomicExchange(&(*&vw28), u32(unconst_u32(86)))), bitcast<f32>(atomicExchange(&(*&vw28), u32(unconst_u32(86)))));
  let ptr117: ptr<storage, vec2f, read_write> = &buffer140[arrayLength(&buffer140)];
  let ptr118: ptr<private, vec2h> = &vp15.fract;
  vp16 = bitcast<vec4i>(vf137[u32(unconst_u32(26))]);
  vf137 += mat3x4f((*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))], (*&buffer140)[arrayLength(&(*&buffer140))][u32(unconst_u32(1))]);
  vf137 -= mat3x4f(dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))), dot(vec2f(unconst_f32(0.07222), unconst_f32(-0.1027)), vec2f(unconst_f32(0.4589), unconst_f32(0.3303))));
  let ptr119: ptr<storage, vec2f, read_write> = &buffer140[u32(unconst_u32(84))];
  atomicAnd(&vw28, u32(unconst_u32(35)));
  var vf138 = fn1();
  vp16 |= vec4i(i32((*&buffer140)[u32(unconst_u32(231))][u32(unconst_u32(104))]));
  buffer140[u32(unconst_u32(7))] = vec2f(f32(dot(vec3i(unconst_i32(110), unconst_i32(653), unconst_i32(12)), vec3i(bitcast<i32>(pack4xI8(vec4i(unconst_i32(93), unconst_i32(299), unconst_i32(93), unconst_i32(372))))))));
  vp16 |= vec4i(i32(smoothstep(f16(unconst_f16(5826.1)), f16(unconst_f16(8497.3)), f16(unconst_f16(1900.2)))));
  _ = buffer140;
  _ = st9;
}`,
});
let buffer141 = device0.createBuffer({
  size: 414,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder45.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder55.setScissorRect(14, 0, 9, 0);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(2, buffer134, 0);
} catch {}
try {
renderBundleEncoder24.setBindGroup(3, bindGroup82, new Uint32Array(1988), 69, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 15, height: 1, depthOrArrayLayers: 12}
*/
{
  source: imageData13,
  origin: { x: 15, y: 6 },
  flipY: true,
}, {
  texture: texture120,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder213 = device0.createCommandEncoder({});
let computePassEncoder156 = commandEncoder213.beginComputePass({});
let renderBundle24 = renderBundleEncoder24.finish({});
try {
computePassEncoder156.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer72, 'uint16', 418, 202);
} catch {}
try {
renderPassEncoder23.setVertexBuffer(2, buffer107, 0, 69);
} catch {}
try {
computePassEncoder32.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer16, 712, new Int16Array(16364), 8451, 108);
} catch {}
let buffer142 = device0.createBuffer({size: 748, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder214 = device0.createCommandEncoder({});
let computePassEncoder157 = commandEncoder214.beginComputePass({});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint']});
let renderBundle25 = renderBundleEncoder25.finish();
try {
computePassEncoder157.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder39.setBindGroup(1, bindGroup65, new Uint32Array(1150), 143, 0);
} catch {}
try {
renderPassEncoder58.setViewport(290.0431517592745, 0.31494816674168025, 4.117451948112715, 0.10647149106003462, 0.4095108932398467, 0.7402749654287486);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer63);
} catch {}
document.body.append(img1);
let offscreenCanvas3 = new OffscreenCanvas(126, 191);
let buffer143 = device0.createBuffer({
  size: 26879,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let sampler128 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
renderPassEncoder27.setBindGroup(0, bindGroup107, new Uint32Array(356), 42, 0);
} catch {}
try {
renderPassEncoder39.executeBundles([renderBundle24]);
} catch {}
let pipeline29 = device0.createRenderPipeline({
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment4',
  constants: {},
  targets: [{
  format: 'rg8sint',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {
        arrayStride: 344,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 16, shaderLocation: 12},
          {format: 'snorm8x4', offset: 0, shaderLocation: 4},
          {format: 'unorm8x2', offset: 62, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let buffer144 = device0.createBuffer({
  size: 4652,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture270 = device0.createTexture({
  size: [30, 1, 118],
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler129 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 36.10,
  compare: 'greater',
});
try {
computePassEncoder104.setBindGroup(2, bindGroup86);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline26);
} catch {}
try {
device0.queue.writeBuffer(buffer97, 1952, new BigUint64Array(31469), 786, 260);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 144, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame17,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture71,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas2);
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame5.close();
videoFrame6.close();
videoFrame8.close();
videoFrame9.close();
videoFrame11.close();
videoFrame13.close();
videoFrame14.close();
videoFrame16.close();
videoFrame17.close();
videoFrame18.close();
videoFrame19.close();
videoFrame21.close();
videoFrame22.close();
videoFrame24.close();
videoFrame25.close();
videoFrame27.close();
videoFrame28.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?.notifyDone();
};
</script>