<!-- webkit-test-runner [ dumpJSConsoleLogInStdErr=true ] -->
<style>
  :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; }
</style>
<script id="shared">
const log = console.log;

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

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

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

const videoUrls = [

];

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

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

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

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

async function window0() {
let adapter0 = await navigator.gpu.requestAdapter();
let adapter1 = await navigator.gpu.requestAdapter();
let device0 = await adapter0.requestDevice({
  requiredFeatures: [
    'indirect-first-instance',
    'timestamp-query',
    'depth-clip-control',
    'texture-compression-etc2',
    'depth32float-stencil8',
    'bgra8unorm-storage',
    'rg11b10ufloat-renderable',
    'float16-renderable',
    'float32-blendable',
    'float32-renderable',
    'shader-f16',
    'texture-compression-astc',
  ],
  requiredLimits: {
    maxBindGroups: 4,
    maxInterStageShaderComponents: 64,
    maxStorageBufferBindingSize: 183447130,
    maxTextureDimension2D: 8192,
    maxUniformBufferBindingSize: 114958729,
    maxVertexBufferArrayStride: 2048,
    minStorageBufferOffsetAlignment: 256,
  },
});
let commandEncoder0 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 27},
  format: 'etc2-rgb8a1unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let commandEncoder1 = device0.createCommandEncoder({});
let textureView0 = texture0.createView({dimension: 'cube-array', arrayLayerCount: 6});
let sampler0 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 96.63,
});
let offscreenCanvas0 = new OffscreenCanvas(176, 353);
let commandEncoder2 = device0.createCommandEncoder({});
let texture1 = device0.createTexture({
  size: {width: 848, height: 1, depthOrArrayLayers: 61},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView1 = texture1.createView({mipLevelCount: 1});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true});
try {
renderBundleEncoder0.insertDebugMarker('\ue2cc');
} catch {}
let buffer0 = device0.createBuffer({size: 216, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
try {
device0.pushErrorScope('internal');
} catch {}
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
let buffer1 = device0.createBuffer({size: 248, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder3 = device0.createCommandEncoder({});
let texture2 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 243},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder1.setIndexBuffer(buffer1, 'uint32', 60, 15);
} catch {}
let buffer2 = device0.createBuffer({size: 168, usage: GPUBufferUsage.VERTEX});
let commandEncoder4 = device0.createCommandEncoder({});
let computePassEncoder0 = commandEncoder1.beginComputePass();
try {
renderBundleEncoder1.setIndexBuffer(buffer1, 'uint32', 88, 41);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(5, buffer2, 0);
} catch {}
let videoFrame0 = new VideoFrame(offscreenCanvas0, {timestamp: 0});
let buffer3 = device0.createBuffer({size: 100, usage: GPUBufferUsage.COPY_DST});
let texture3 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 14},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture4 = device0.createTexture({size: [848], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC});
let textureView2 = texture1.createView({mipLevelCount: 1});
let computePassEncoder1 = commandEncoder2.beginComputePass();
try {
device0.queue.writeBuffer(buffer3, 4, new Uint32Array(20805).map((_, i) => i * 9), 1394, 0);
} catch {}
let device1 = await adapter1.requestDevice({requiredFeatures: ['shader-f16']});
let texture5 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 38},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture6 = device0.createTexture({
  size: [3395, 1, 1],
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView3 = texture5.createView({baseArrayLayer: 16, arrayLayerCount: 2});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({label: '\u{1f7f0}\u878a\u0df7\u{1fa5b}\ua5b7\u9601', colorFormats: ['rgba16float'], sampleCount: 4});
try {
renderBundleEncoder2.setIndexBuffer(buffer1, 'uint16', 2, 83);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 12, new Float32Array(6180).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.935)), 792, 0);
} catch {}
let texture7 = device0.createTexture({
  size: {width: 16},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView4 = texture1.createView({mipLevelCount: 1});
try {
renderBundleEncoder2.setVertexBuffer(0, buffer2, 0, 30);
} catch {}
try {
commandEncoder3.insertDebugMarker('\u{1f60d}');
} catch {}
try {
device0.queue.writeBuffer(buffer3, 0, new Float32Array(1575).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.546)), 269, 0);
} catch {}
try {
adapter1.label = '\u{1fcbf}\u{1fde5}\u0b24\u16eb\u9e35\udf29\u73be';
} catch {}
let textureView5 = texture7.createView({dimension: '1d', arrayLayerCount: 1});
let texture8 = device0.createTexture({
  size: [16, 16, 27],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true});
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 30,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false },
    },
    {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
  ],
});
let textureView6 = texture3.createView({arrayLayerCount: 6});
let sampler1 = device0.createSampler({addressModeV: 'mirror-repeat', maxAnisotropy: 1});
try {
buffer0.unmap();
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 16, new Uint16Array(22484).map((_, i) => i + 10), 4712, 8);
} catch {}
offscreenCanvas0.height = 425;
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let buffer4 = device0.createBuffer({size: 78, usage: GPUBufferUsage.INDEX});
let texture9 = device0.createTexture({
  size: [424, 1, 101],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture10 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder2 = commandEncoder3.beginComputePass();
try {
renderBundleEncoder0.setVertexBuffer(6, buffer2, 0, 9);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 0, new Uint32Array(24467).map((_, i) => i * 4), 1235, 0);
} catch {}
offscreenCanvas0.height = 652;
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 44, hasDynamicOffset: false },
    },
  ],
});
let commandEncoder5 = device0.createCommandEncoder({});
let texture11 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 26},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder3 = commandEncoder5.beginComputePass();
try {
commandEncoder4.copyBufferToBuffer(buffer0, 0, buffer3, 8, 12);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
globalThis.someLabel = device1.label;
} catch {}
let buffer5 = device1.createBuffer({size: 180, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 30,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false },
    },
    {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
  ],
});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]});
let buffer6 = device0.createBuffer({size: 412, usage: GPUBufferUsage.MAP_WRITE});
let sampler2 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 85.14,
  maxAnisotropy: 1,
});
let computePassEncoder4 = commandEncoder0.beginComputePass();
let texture12 = device0.createTexture({
  size: [4, 712, 1],
  mipLevelCount: 2,
  format: 'astc-4x4-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture13 = device0.createTexture({
  size: [848, 1, 40],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView7 = texture8.createView({dimension: '2d', baseArrayLayer: 2});
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture14 = device0.createTexture({
  size: [424],
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture15 = device0.createTexture({
  size: [1, 178, 4],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView8 = texture2.createView({});
let buffer7 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let texture16 = device0.createTexture({
  size: [1, 178, 14],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture17 = device0.createTexture({
  size: {width: 2, height: 356, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder5 = commandEncoder4.beginComputePass();
let sampler3 = device1.createSampler({addressModeV: 'clamp-to-edge', minFilter: 'linear', lodMinClamp: 47.27, lodMaxClamp: 68.63});
try {
buffer5.unmap();
} catch {}
let veryExplicitBindGroupLayout3 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true },
    },
    {
      binding: 98,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let texture18 = device1.createTexture({
  size: [102, 1, 1],
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
let commandEncoder6 = device0.createCommandEncoder();
let textureView9 = texture11.createView({arrayLayerCount: 3});
let textureView10 = texture5.createView({dimension: '2d-array', arrayLayerCount: 3});
try {
commandEncoder6.copyBufferToBuffer(buffer7, 28, buffer3, 0, 0);
} catch {}
try {
commandEncoder6.clearBuffer(buffer7);
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

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

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

var<workgroup> vw0: atomic<u32>;

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

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

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

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

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

struct T4 {
  @size(192) f0: T1,
  @size(800) f1: atomic<i32>,
}

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

@group(0) @binding(0) var sam0: sampler;

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

/* zero global variables used */
@must_use 
fn fn0(a0: sampler) -> vec2u {
  var out: vec2u;
  var vf0: vec3f = quantizeToF16(vec3f(unconst_f32(-0.1505e-12), unconst_f32(0.04325e-19), unconst_f32(0.2047e38)));
  var vf1: vec2h = acosh(vec2h(round(vec4f(unconst_f32(0.06220), unconst_f32(0.3644e-30), unconst_f32(0.3542), unconst_f32(0.1972e22))).zy.rg.yy.rr));
  return out;
}

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

struct T5 {
  f0: array<u32>,
}

override override0: f16;

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

struct T1 {
  f0: atomic<i32>,
}

var<workgroup> vw2: atomic<u32>;

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

struct T2 {
  @align(8) @size(32) f0: T1,
}

/* used global variables: sam0 */
fn fn1(a0: i32) -> vec2u {
  var out: vec2u;
  let ptr0: ptr<function, vec2u> = &out;
  var vf2 = fn0(sam0);
  let vf3: u32 = vf2[unconst_u32(467333467)];
  vf2 |= vec2u((*ptr0)[unconst_u32(58747457)]);
  out |= vec2u(u32(a0));
  _ = fn0(sam0);
  let vf4: vec2f = tanh(vec2f(unconst_f32(0.1090), unconst_f32(0.2551)));
  out = out;
  return out;
  _ = sam0;
}

/* zero global variables used */
@compute @workgroup_size(4, 1, 1)
fn compute0(@builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u, a3: ComputeInput0) {
  atomicSub(&vw2, unconst_u32(354441726));
  loop {
  let ptr1: ptr<workgroup, atomic<u32>> = &vw1[unconst_u32(531334364)];
  atomicAnd(&vw2, workgroup_id[unconst_u32(88185036)]);
  let ptr2: ptr<workgroup, atomic<u32>> = &vw1[unconst_u32(1420491009)];
  let ptr3: ptr<workgroup, array<atomic<u32>, 1>> = &(*&vw1);
  let ptr4: ptr<workgroup, atomic<u32>> = &(*ptr3)[unconst_u32(1299125040)];
  atomicSub(&vw0, unconst_u32(1401347106));
  break;
}
  var vf5: u32 = atomicExchange(&vw2, unconst_u32(457132739));
  var vf6: vec3u = local_invocation_id;
  atomicCompareExchangeWeak(&vw2, unconst_u32(1424555608), unconst_u32(1109369112));
  atomicStore(&vw1[unconst_u32(73234630)], unconst_u32(251358043));
  let ptr5: ptr<function, u32> = &vf5;
  textureBarrier();
  let vf7: u32 = atomicLoad(&vw1[0]);
  let ptr6: ptr<workgroup, atomic<u32>> = &vw1[unconst_u32(287296750)];
}

/* zero global variables used */
@compute @workgroup_size(1, 1, 1)
fn compute1(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, a4: ComputeInput1) {
  atomicExchange(&vw2, unconst_u32(39258931));
  atomicXor(&vw0, unconst_u32(71807738));
  var vf8: u32 = atomicLoad(&vw1[0]);
  var vf9: u32 = atomicExchange(&(*&vw2), unconst_u32(2131339945));
}

/* zero global variables used */
@compute @workgroup_size(1, 1, 1)
fn compute2(a0: ComputeInput2, a1: ComputeInput3, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(workgroup_id) workgroup_id: vec3u) {
  let vf10: u32 = pack2x16snorm(vec2f(f32(atomicLoad(&(*&vw2)))));
  let vf11: ComputeInput2 = a0;
  let vf12: vec4f = ceil(vec4f(unconst_f32(0.00286e-39), unconst_f32(0.1833), unconst_f32(0.1988e-37), unconst_f32(-0.05506e-39)));
  atomicExchange(&vw2, unconst_u32(390213240));
  atomicMin(&vw0, unconst_u32(986153183));
  atomicAdd(&vw1[0], unconst_u32(457839297));
  atomicAdd(&vw2, unconst_u32(163522733));
  atomicCompareExchangeWeak(&vw0, unconst_u32(973652385), unconst_u32(136232184));
  var vf13: u32 = a0.local_invocation_id[unconst_u32(1292573732)];
}`,
});
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 30,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false },
    },
    {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
  ],
});
let texture19 = device0.createTexture({
  size: [1697, 1, 4],
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture20 = device0.createTexture({
  size: [1697, 1, 6],
  mipLevelCount: 4,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderBundleEncoder1.setIndexBuffer(buffer1, 'uint32', 40, 43);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder6.insertDebugMarker('\u8207');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 1,
  origin: {x: 245, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(10).fill(123), /* required buffer size: 10 */
{offset: 10}, {width: 373, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer8 = device0.createBuffer({size: 17996, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder7 = device0.createCommandEncoder({});
let texture21 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  dimension: '2d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder6 = commandEncoder6.beginComputePass();
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
renderBundleEncoder1.setIndexBuffer(buffer1, 'uint16', 20, 33);
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(24, 154);
let texture22 = device0.createTexture({
  size: [1, 178, 1],
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView11 = texture21.createView({});
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 30,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false },
    },
    {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
  ],
});
let buffer9 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let textureView12 = texture19.createView({
  label: '\u0896\uc252\uf925\u0b63\u{1fbad}\u02e8\u9622\u1774\uc7dd\u36e0',
  dimension: '2d',
  arrayLayerCount: 1,
});
let externalTexture1 = device0.importExternalTexture({source: videoFrame0});
let commandEncoder8 = device1.createCommandEncoder({});
let texture23 = device1.createTexture({
  size: {width: 2560},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
buffer5.unmap();
} catch {}
let veryExplicitBindGroupLayout6 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true },
    },
    {
      binding: 98,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let pipelineLayout2 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3, veryExplicitBindGroupLayout3]});
let textureView13 = texture18.createView({baseMipLevel: 0});
let computePassEncoder7 = commandEncoder8.beginComputePass();
let texture24 = device1.createTexture({
  size: {width: 256},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture25 = device1.createTexture({
  size: [1280, 1, 1],
  mipLevelCount: 4,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
try {
device1.queue.submit([]);
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let textureView14 = texture12.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
renderBundleEncoder2.setIndexBuffer(buffer1, 'uint16', 2, 106);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 2,
  origin: {x: 76, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(128).fill(97), /* required buffer size: 128 */
{offset: 128}, {width: 31, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer10 = device0.createBuffer({size: 500, usage: GPUBufferUsage.INDEX});
let texture26 = device0.createTexture({
  size: [8, 1424, 1],
  mipLevelCount: 2,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture27 = device0.createTexture({
  size: [8, 1424, 1],
  sampleCount: 4,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder2.insertDebugMarker('\ud527');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext1 = offscreenCanvas1.getContext('webgpu');
let commandEncoder10 = device1.createCommandEncoder();
let textureView15 = texture24.createView({format: 'r32float', baseMipLevel: 0});
let texture28 = device1.createTexture({
  size: [408, 1, 1],
  mipLevelCount: 3,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let pipelineLayout3 = device1.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout6, veryExplicitBindGroupLayout6, veryExplicitBindGroupLayout3],
});
let buffer11 = device1.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let texture29 = device1.createTexture({
  size: [256, 256, 33],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder8 = commandEncoder10.beginComputePass();
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(389).fill(70), /* required buffer size: 389 */
{offset: 389}, {width: 193, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture30 = device0.createTexture({
  size: [2, 356, 1],
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture2 = device0.importExternalTexture({source: videoFrame0});
try {
renderBundleEncoder2.setIndexBuffer(buffer1, 'uint16', 18, 81);
} catch {}
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]});
let commandEncoder11 = device0.createCommandEncoder({});
let texture31 = device0.createTexture({
  size: [2, 356, 1],
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture32 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture33 = device0.createTexture({
  size: [848, 1, 45],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView16 = texture21.createView({label: '\uf36b\u7116\u0ccd\uc6e1\u649b\u{1ffcd}\u{1f7e6}'});
let computePassEncoder9 = commandEncoder11.beginComputePass();
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 424, height: 1, depthOrArrayLayers: 14}
*/
{
  source: offscreenCanvas1,
  origin: { x: 1, y: 6 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let imageData0 = new ImageData(8, 4);
try {
adapter1.label = '\u004f\u{1fd27}\u7008\u672e';
} catch {}
let textureView17 = texture25.createView({dimension: '2d', mipLevelCount: 1});
await gc();
let texture34 = device0.createTexture({
  size: {width: 2, height: 356, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder2.setIndexBuffer(buffer10, 'uint32', 500);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 12, new Uint32Array(30860).map((_, i) => i * 6), 16104, 0);
} catch {}
let commandEncoder12 = device1.createCommandEncoder({});
let textureView18 = texture25.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
buffer11.unmap();
} catch {}
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 64, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(74).fill(86), /* required buffer size: 74 */
{offset: 74}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer12 = device1.createBuffer({size: 224, usage: GPUBufferUsage.COPY_DST});
let commandEncoder13 = device1.createCommandEncoder();
let renderBundleEncoder4 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], stencilReadOnly: false});
let texture35 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 50},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder1.setIndexBuffer(buffer4, 'uint32', 0, 0);
} catch {}
let veryExplicitBindGroupLayout7 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true },
    },
    {
      binding: 98,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer13 = device1.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let textureView19 = texture24.createView({});
let computePassEncoder10 = commandEncoder13.beginComputePass();
try {
device1.queue.writeBuffer(buffer12, 8, new Float16Array(7249).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.7356)), 996, 4);
} catch {}
let promise0 = device1.queue.onSubmittedWorkDone();
let texture36 = device1.createTexture({
  size: [19, 20, 539],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
device1.queue.writeBuffer(buffer12, 68, new Float64Array(52858).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/52856)), 17669, 16);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder14 = device0.createCommandEncoder({});
let textureView20 = texture34.createView({dimension: '2d-array'});
let externalTexture3 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
let imageData1 = new ImageData(16, 104);
let pipelineLayout5 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout6]});
let commandEncoder15 = device1.createCommandEncoder({});
let textureView21 = texture18.createView({});
try {
  await promise0;
} catch {}
let commandEncoder16 = device1.createCommandEncoder({});
let computePassEncoder11 = commandEncoder16.beginComputePass();
try {
commandEncoder15.insertDebugMarker('\uaf00');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
globalThis.someLabel = buffer1.label;
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let textureView22 = texture14.createView({aspect: 'all'});
try {
renderBundleEncoder2.setIndexBuffer(buffer1, 'uint32', 12, 44);
} catch {}
try {
buffer3.unmap();
} catch {}
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'smpte240m'} });
let shaderModule1 = device1.createShaderModule({
  code: `
enable f16;

@group(0) @binding(0) var st0: texture_storage_1d<r32float, read_write>;

struct VertexInput4 {
  @location(4) location_4: vec4f,
}

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

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

struct VertexInput1 {
  @location(6) @interpolate(flat, first) location_6: i32,
}

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

struct VertexInput5 {
  @location(9) @interpolate(flat, first) location_9: u32,
}

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

struct VertexInput0 {
  @location(1) location_1: f16,
  @location(10) @interpolate(flat) location_10: f16,
}

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

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

struct FragmentOutput0 {
  @location(4) @interpolate(flat, either) location_4: vec4u,
  @location(0) location_0: vec4f,
}

var<workgroup> vw3: bool;

struct VertexInput3 {
  @location(8) @interpolate(flat) location_8: vec2i,
  @location(0) location_0: vec2h,
  @location(14) location_14: vec4i,
}

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

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

@group(0) @binding(2) var<storage, read_write> buffer14: array<array<f16, 13>>;

struct T0 {
  f0: array<u32>,
}

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

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

struct T4 {
  f0: array<u32>,
}

struct T3 {
  f0: array<u32>,
}

struct T1 {
  @size(26) f0: array<array<vec4i, 1>, 1>,
}

struct VertexInput2 {
  @location(5) location_5: vec2i,
  @location(2) location_2: vec2h,
  @location(11) @interpolate(flat) location_11: u32,
}

struct T6 {
  f0: array<u32>,
}

@group(1) @binding(2) var<storage, read_write> buffer15: array<array<f16, 13>, 1>;

@group(1) @binding(0) var st1: texture_storage_1d<r32float, read_write>;

struct T7 {
  @size(16) f0: atomic<i32>,
}

/* zero global variables used */
@vertex
fn vertex0(@location(13) location_13: vec2u, @location(15) location_15: f16, a2: VertexInput0, a3: VertexInput1, a4: VertexInput2, a5: VertexInput3, @location(3) location_3: vec2h, a7: VertexInput4, a8: VertexInput5, @location(12) location_12: i32, @location(7) @interpolate(linear) location_7: vec4h, @builtin(vertex_index) vertex_index: u32, a12: VertexInput6) -> @builtin(position) vec4f {
  var out: vec4f;
  out = unpack4x8unorm(a12.instance_index);
  out = vec4f(bitcast<f32>(location_12));
  out = asinh(vec3f(f32(location_7[unconst_u32(1794129708)]))).yzxy;
  var vf14: i32 = insertBits(unconst_i32(29993911), unconst_i32(260681058), unconst_u32(1439666379), unconst_u32(182591578));
  out *= bitcast<vec4f>(a4.location_5.gggr.xyyx.yzxx.bgba);
  var vf15: f16 = a2.location_10;
  let vf16: vec4f = ldexp(vec4f(unconst_f32(0.08947e-19), unconst_f32(0.3287), unconst_f32(0.06209), unconst_f32(0.2756)), vec4i(bitcast<i32>((unconst_u32(436895946) << unconst_u32(4294967295)))));
  let vf17: bool = (unconst_bool(true) && unconst_bool(true));
  out = bitcast<vec4f>(a4.location_5.yxyx);
  return out;
}

/* used global variables: buffer14, buffer15 */
@fragment
fn fragment0(a0: FragmentInput0, @builtin(position) position: vec4f) -> FragmentOutput0 {
  var out: FragmentOutput0;
  let ptr7: ptr<storage, array<f16, 13>, read_write> = &(*&buffer15)[unconst_u32(491548134)];
  let ptr8: ptr<storage, f16, read_write> = &(*&buffer15)[unconst_u32(2467857238)][unconst_u32(2392806664)];
  for (var jj71=0u; jj71<15; jj71++) { buffer14[unconst_u32(397259175)][jj71] = (*&buffer15)[0][12]; }
  out.location_4 = vec4u(u32((*&buffer14)[arrayLength(&(*&buffer14))][12]));
  var vf18: FragmentInput0 = a0;
  let ptr9: ptr<storage, array<f16, 13>, read_write> = &(*&buffer15)[unconst_u32(30927996)];
  out.location_0 = vec4f((vec3u(unconst_u32(111967757), unconst_u32(543195532), unconst_u32(477139718)) >= vec3u(u32((*&buffer15)[0][12]))).zzxz);
  let ptr10: ptr<storage, array<f16, 13>, read_write> = &(*&buffer14)[unconst_i32(55148158)];
  out.location_4 ^= vec4u(u32(vf18.front_facing));
  let ptr11: ptr<storage, f16, read_write> = &(*ptr10)[12];
  let ptr12: ptr<storage, array<f16, 13>, read_write> = &buffer15[unconst_u32(1437911378)];
  let ptr13: ptr<storage, array<f16, 13>, read_write> = &buffer15[unconst_u32(371294992)];
  return out;
  _ = buffer14;
  _ = buffer15;
}

/* used global variables: st0, st1 */
@compute @workgroup_size(2, 1, 1)
fn compute3(a0: ComputeInput4) {
  vw3 = (*&vw3);
  textureStore(st0, unconst_i32(1013261528), vec4f(vec4f(unconst_f32(0.4999e-8), unconst_f32(-0.4883), unconst_f32(0.05409e34), unconst_f32(0.07229))));
  let vf19: i32 = insertBits(unconst_i32(-712460652), unconst_i32(2014165987), pack2x16snorm(tanh(vec2f(unconst_f32(0.04443e3), unconst_f32(0.2238e35)))), unconst_u32(382651743));
  let vf20: f16 = length(vec4h(unconst_f16(18693.8), unconst_f16(-13586.9), unconst_f16(22529.8), unconst_f16(-2833.4)));
  var vf21: u32 = textureDimensions(st0);
  vf21 |= u32(length(bitcast<vec4h>(extractBits(vec2i(unconst_i32(527981195), unconst_i32(9848936)), unconst_u32(2737175954), unconst_u32(382597031)))));
  _ = st1;
  let vf22: vec2f = tanh(vec2f(unconst_f32(0.4738e-3), unconst_f32(0.4859e-13)));
  textureStore(st1, i32(vf21), vec4f(vec4f(unconst_f32(0.2055e-8), unconst_f32(0.01059), unconst_f32(0.2562e-37), unconst_f32(0.3649))));
  _ = st1;
  _ = st0;
}`,
});
let commandEncoder18 = device1.createCommandEncoder({});
let textureView23 = texture29.createView({mipLevelCount: 1});
try {
computePassEncoder10.end();
} catch {}
let pipeline0 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1}});
let texture37 = device0.createTexture({
  size: [2, 356, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture4 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'srgb'});
let commandEncoder19 = device0.createCommandEncoder({});
let texture38 = device0.createTexture({
  size: [848, 1, 1],
  dimension: '2d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture39 = device0.createTexture({
  size: [16, 16, 80],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture5 = device0.importExternalTexture({source: videoFrame0});
try {
renderBundleEncoder3.setIndexBuffer(buffer10, 'uint32', 68, 20);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(5, buffer2, 0, 29);
} catch {}
try {
renderBundleEncoder3.insertDebugMarker('\u06a2');
} catch {}
try {
device1.label = '\u0056\u6929\ubb22';
} catch {}
let autogeneratedBindGroupLayout0 = pipeline0.getBindGroupLayout(1);
let computePassEncoder12 = commandEncoder13.beginComputePass();
try {
renderBundleEncoder4.setVertexBuffer(0, undefined, 36_925_854);
} catch {}
let commandEncoder20 = device0.createCommandEncoder({});
let texture40 = device0.createTexture({
  size: [4, 712, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture41 = gpuCanvasContext1.getCurrentTexture();
await gc();
let texture42 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 1},
  format: 'rg16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView24 = texture0.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6});
let sampler4 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'not-equal',
});
try {
renderBundleEncoder2.setVertexBuffer(0, buffer8, 2_460);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 122, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(28).fill(153), /* required buffer size: 28 */
{offset: 28, rowsPerImage: 3}, {width: 167, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder21 = device1.createCommandEncoder({});
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 0, new DataView(new Uint8Array(1985).map((_, i) => i).buffer), 406, 40);
} catch {}
let pipeline1 = await device1.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x4da36271},
  fragment: {
  module: shaderModule1,
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 16, shaderLocation: 7},
          {format: 'float16x4', offset: 0, shaderLocation: 1},
          {format: 'sint16x4', offset: 8, shaderLocation: 5},
          {format: 'float32x3', offset: 0, shaderLocation: 0},
          {format: 'unorm16x4', offset: 0, shaderLocation: 15},
          {format: 'uint8x4', offset: 4, shaderLocation: 9},
          {format: 'sint32x2', offset: 0, shaderLocation: 14},
          {format: 'uint8x2', offset: 4, shaderLocation: 11},
          {format: 'unorm16x2', offset: 0, shaderLocation: 4},
          {format: 'sint32x4', offset: 0, shaderLocation: 6},
          {format: 'snorm8x2', offset: 8, shaderLocation: 3},
          {format: 'snorm8x2', offset: 0, shaderLocation: 2},
          {format: 'uint32x3', offset: 0, shaderLocation: 13},
          {format: 'sint32', offset: 0, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 10},
          {format: 'sint16x4', offset: 0, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip'},
});
let shaderModule2 = device0.createShaderModule({
  code: `
requires unrestricted_pointer_parameters;

enable f16;

var<workgroup> vw6: array<array<array<array<u32, 1>, 2>, 1>, 15>;

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

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

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

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

var<workgroup> vw4: atomic<u32>;

@id(977) override override2: f32;

var<workgroup> vw5: array<array<array<array<vec4u, 1>, 6>, 1>, 1>;

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

override override1: f16;

struct T0 {
  f0: array<u32>,
}

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

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

/* zero global variables used */
@compute @workgroup_size(1, 1, 2)
fn compute4(@builtin(num_workgroups) num_workgroups: vec3u, a1: ComputeInput5, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, a4: ComputeInput6) {
  workgroupBarrier();
  let ptr14: ptr<workgroup, array<u32, 1>> = &vw6[unconst_u32(1127717973)][0][1];
  let ptr15: ptr<workgroup, u32> = &vw6[14][unconst_u32(753363658)][1][a4.local_invocation_id[2]];
}`,
});
let texture43 = device0.createTexture({size: [1697, 1, 1], format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []});
let texture44 = device0.createTexture({
  size: {width: 848, height: 1, depthOrArrayLayers: 17},
  mipLevelCount: 4,
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder1.setIndexBuffer(buffer9, 'uint32', 0, 10);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(0, buffer8);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let imageData2 = new ImageData(60, 8);
let bindGroup0 = device1.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView15}]});
let textureView25 = texture23.createView({arrayLayerCount: 1});
let computePassEncoder13 = commandEncoder15.beginComputePass();
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
let textureView26 = texture28.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder14 = commandEncoder12.beginComputePass();
try {
gpuCanvasContext0.unconfigure();
} catch {}
let renderBundleEncoder5 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float']});
try {
buffer5.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let promise1 = device1.queue.onSubmittedWorkDone();
let commandEncoder22 = device1.createCommandEncoder({});
let texture45 = device1.createTexture({
  size: [204, 1, 1],
  mipLevelCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder6 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: false});
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
commandEncoder22.clearBuffer(buffer12);
} catch {}
offscreenCanvas1.height = 471;
let videoFrame2 = new VideoFrame(videoFrame1, {timestamp: 0});
let shaderModule3 = device1.createShaderModule({
  code: `
enable f16;

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

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

var<workgroup> vw7: u32;

var<workgroup> vw8: array<array<atomic<i32>, 1>, 22>;

var<workgroup> vw9: atomic<i32>;

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

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

struct T5 {
  f0: array<u32>,
}

struct T0 {
  f0: array<u32>,
}

struct T6 {
  f0: atomic<u32>,
  f1: array<u32>,
}

@group(0) @binding(0) var<storage, read_write> buffer16: array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 2>, 2>>;

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

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

struct T7 {
  f0: array<array<array<array<array<array<array<vec2f, 1>, 1>, 1>, 1>, 1>, 1>, 6>,
}

@group(3) @binding(0) var st3: texture_storage_1d<r32float, read_write>;

struct T10 {
  f0: array<T7>,
}

@group(1) @binding(0) var st2: texture_storage_1d<r32float, read_write>;

struct T1 {
  @size(784) f0: array<array<vec2u, 1>, 49>,
}

struct T2 {
  f0: array<vec4f>,
}

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

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

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

var<private> vp0 = frexp(vec4h(6994.7, 2874.4, -9514.3, 6217.3));

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

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

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

struct T9 {
  @align(4) f0: array<array<vec2<bool>, 1>>,
}

struct T8 {
  f0: array<u32>,
}

/* used global variables: buffer16, st2, st3 */
@compute @workgroup_size(2, 1, 1)
fn compute5(a0: ComputeInput7, a1: ComputeInput8, a2: ComputeInput9, @builtin(global_invocation_id) global_invocation_id: vec3u, a4: ComputeInput10) {
  let ptr16: ptr<storage, f16, read_write> = &buffer16[arrayLength(&buffer16)][1][unconst_u32(982772891)][2][unconst_u32(47860297)][unconst_u32(311858670)][unconst_u32(2287701682)];
  textureStore(st3, unconst_i32(-28576040), vec4f(vec4f(unconst_f32(0.2313e26), unconst_f32(0.03022e-37), unconst_f32(0.2412e3), unconst_f32(0.03888e17))));
  let ptr17: ptr<workgroup, atomic<i32>> = &vw8[unconst_u32(2879107779)][unconst_u32(28486969)];
  while bool((*&buffer16)[arrayLength(&(*&buffer16))][1][unconst_u32(2490612288)][2][0][0][unconst_u32(1333015089)]) {
  let ptr18: ptr<storage, f16, read_write> = &buffer16[unconst_u32(512006993)][1][1][unconst_u32(7079215)][unconst_u32(808955379)][0][unconst_u32(21913270)];
  textureStore(st3, unconst_i32(1093382151), vec4f(vec4f(unconst_f32(0.3372e-6), unconst_f32(-0.2394e26), unconst_f32(0.3666e22), unconst_f32(0.02849))));
  textureStore(st2, unconst_i32(9208624), vec4f(vec4f(unconst_f32(0.3077), unconst_f32(0.2603e2), unconst_f32(0.1160e-36), unconst_f32(0.00572e-28))));
  let ptr19: ptr<storage, f16, read_write> = &(*&buffer16)[unconst_u32(1175626556)][1][1][2][0][0][0];
  let ptr20: ptr<storage, f16, read_write> = &(*&buffer16)[arrayLength(&(*&buffer16))][u32((*&buffer16)[arrayLength(&(*&buffer16))][unconst_u32(775359330)][1][2][0][unconst_u32(319288547)][0])][unconst_u32(289249692)][2][unconst_u32(593347480)][unconst_u32(2595553333)][unconst_u32(246869041)];
  let ptr21: ptr<storage, f16, read_write> = &(*&buffer16)[arrayLength(&(*&buffer16))][u32((*&buffer16)[arrayLength(&(*&buffer16))][unconst_u32(429251698)][1][2][0][0][0])][1][2][unconst_u32(240134884)][0][0];
  _ = st3;
  _ = st2;
  _ = buffer16;
}
  _ = buffer16;
  _ = st3;
  _ = st2;
}`,
});
let commandEncoder23 = device1.createCommandEncoder({});
let computePassEncoder15 = commandEncoder23.beginComputePass();
try {
computePassEncoder12.setBindGroup(1, bindGroup0, new Uint32Array(2911), 58, 0);
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(578).fill(171), /* required buffer size: 578 */
{offset: 578}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let sampler5 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.66,
  maxAnisotropy: 3,
});
let textureView27 = texture28.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1});
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(107).fill(233), /* required buffer size: 107 */
{offset: 107, rowsPerImage: 27}, {width: 169, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte240m', transfer: 'iec61966-2-1'} });
let autogeneratedBindGroupLayout1 = pipeline1.getBindGroupLayout(1);
let buffer21 = device1.createBuffer({size: 233, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder24 = device1.createCommandEncoder();
let texture46 = device1.createTexture({
  size: [156, 164, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline1);
} catch {}
try {
commandEncoder22.copyTextureToTexture({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 41, y: 37, z: 6},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
},
{width: 55, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 156, height: 164, depthOrArrayLayers: 1}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture46,
  mipLevel: 0,
  origin: {x: 48, y: 63, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder25 = device1.createCommandEncoder({});
let texture47 = device1.createTexture({
  size: [2560, 1, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder11.setBindGroup(0, bindGroup0);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
commandEncoder21.copyBufferToBuffer(buffer13, 0, buffer12, 84, 24);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 52, new Float32Array(15875).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.627)), 1605, 16);
} catch {}
await gc();
let textureView28 = texture47.createView({dimension: '2d-array', baseArrayLayer: 0});
let texture48 = device1.createTexture({
  size: {width: 320},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView29 = texture23.createView({});
try {
computePassEncoder12.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder15.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup0, []);
} catch {}
let bindGroup1 = device1.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView19}]});
try {
computePassEncoder14.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup0, new Uint32Array(3446), 320, 0);
} catch {}
try {
renderBundleEncoder5.pushDebugGroup('\u5c04');
} catch {}
try {
renderBundleEncoder5.popDebugGroup();
} catch {}
try {
  await promise1;
} catch {}
let texture49 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: false});
try {
device0.queue.writeBuffer(buffer3, 4, new Float16Array(18253).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.5228)), 4453, 8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture39,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 7},
  aspect: 'all',
}, new Uint8Array(60_567).fill(170), /* required buffer size: 60_567 */
{offset: 195, bytesPerRow: 78, rowsPerImage: 86}, {width: 5, height: 0, depthOrArrayLayers: 10});
} catch {}
let renderBundleEncoder8 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true});
try {
computePassEncoder11.setBindGroup(1, bindGroup1);
} catch {}
try {
computePassEncoder14.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup1);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture50 = device1.createTexture({
  size: [39, 41, 1],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder9 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
await gc();
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'smpteSt4281'} });
let buffer22 = device1.createBuffer({size: 248, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, mappedAtCreation: false});
let commandEncoder26 = device1.createCommandEncoder({});
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'bt1361ExtendedColourGamut'} });
let autogeneratedBindGroupLayout2 = pipeline0.getBindGroupLayout(1);
try {
computePassEncoder15.setBindGroup(1, bindGroup0, new Uint32Array(1937), 21, 0);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
commandEncoder25.insertDebugMarker('\ue9ad');
} catch {}
try {
renderBundleEncoder4.insertDebugMarker('\ua0fb');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 44, hasDynamicOffset: false },
    },
  ],
});
let texture51 = device0.createTexture({
  size: [848, 1, 1],
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let veryExplicitBindGroupLayout9 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 18,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let commandEncoder27 = device1.createCommandEncoder({});
let sampler6 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 9,
});
try {
{ clearResourceUsages(device1, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder12.end();
} catch {}
try {
computePassEncoder14.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup0, []);
} catch {}
let pipeline2 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}});
let imageData3 = new ImageData(44, 24);
let veryExplicitBindGroupLayout10 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 294,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
    {binding: 354, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let buffer23 = device1.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder28 = device1.createCommandEncoder({});
let texture52 = device1.createTexture({
  size: [51, 1, 141],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
{ clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderBundleEncoder4.setBindGroup(2, bindGroup0);
} catch {}
let promise2 = device1.queue.onSubmittedWorkDone();
try {
  await promise2;
} catch {}
let imageData4 = new ImageData(36, 24);
let commandEncoder29 = device0.createCommandEncoder({});
let texture53 = device0.createTexture({
  size: {width: 848, height: 1, depthOrArrayLayers: 65},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView30 = texture1.createView({format: 'rgba16float', mipLevelCount: 1});
await gc();
let shaderModule4 = device1.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

override override6 = 0.2100;

struct T6 {
  f0: array<T2>,
}

struct VertexInput10 {
  @location(14) location_14: vec4i,
}

@id(34792) override override8 = true;

@group(0) @binding(98) var tex5: texture_2d<i32>;

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

struct VertexOutput0 {
  @builtin(position) position: vec4f,
  @location(1) location_1: vec4f,
  @location(12) @interpolate(flat, sample) location_12: vec4u,
  @location(9) location_9: vec2f,
  @location(4) @interpolate(flat, centroid) location_4: i32,
  @location(8) location_8: vec2i,
  @location(15) location_15: vec2f,
  @location(6) @interpolate(flat, either) location_6: vec2u,
}

@id(34988) override override4: u32 = (1590390861 % 103) + 1;

@id(42037) override override3: u32;

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

var<workgroup> vw10: array<vec4f, 1>;

struct FragmentInput1 {
  @location(1) location_1: vec4f,
  @builtin(sample_mask) sample_mask: u32,
  @location(6) @interpolate(flat, either) location_6: vec2u,
  @location(15) location_15: vec2f,
}

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

struct T3 {
  f0: array<u32>,
}

struct T2 {
  f0: T0,
}

@group(1) @binding(0) var<storage, read_write> buffer25: array<array<vec4h, 47>>;

struct FragmentInput2 {
  @location(9) location_9: vec2f,
  @location(8) location_8: vec2i,
}

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

var<private> vp1 = array(modf(vec2h(25421.8, 1514.2)));

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

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

struct FragmentOutput1 {
  @builtin(sample_mask) sample_mask: u32,
  @location(0) location_0: vec4i,
  @location(7) location_7: f32,
  @location(5) @interpolate(flat) location_5: vec2i,
}

struct VertexInput8 {
  @location(1) location_1: vec2i,
}

struct VertexInput7 {
  @location(2) location_2: i32,
  @location(7) location_7: vec4f,
  @location(15) location_15: i32,
  @location(13) location_13: vec4f,
  @location(12) @interpolate(flat) location_12: vec2u,
  @location(0) location_0: f16,
  @location(11) location_11: vec4i,
  @location(4) @interpolate(perspective) location_4: vec4h,
  @location(5) location_5: vec4u,
  @builtin(vertex_index) vertex_index: u32,
  @location(9) @interpolate(flat, sample) location_9: u32,
  @location(10) @interpolate(flat, center) location_10: vec4h,
  @location(8) @interpolate(flat, either) location_8: u32,
}

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

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

struct FragmentInput3 {
  @location(12) @interpolate(flat, sample) location_12: vec4u,
}

/* used global variables: tex8 */
fn fn0(a0: ptr<function, array<f16, 77>>, a1: array<f32, 1>) {
  let ptr22: ptr<function, f16> = &(*a0)[76];
  let ptr23: ptr<function, f16> = &(*a0)[76];
  (*a0)[unconst_u32(1154985285)] -= (*a0)[u32((*ptr22))];
  loop {
  vp1[unconst_u32(293939199)].fract = vec2h(cosh(vec3f(unconst_f32(0.3702), unconst_f32(0.3256e-43), unconst_f32(0.01419e-14))).bg);
  (*a0)[unconst_u32(64083294)] -= f16(a1[u32(a1[0])]);
  continuing
  {
  vp1[unconst_u32(842795197)].whole = vec2h( !vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false)).zy);
  for (var it0=u32((vec2i(unconst_i32(27925089), unconst_i32(277339348)) << bitcast<vec2u>(tan(vec4h(unconst_f16(212.1), unconst_f16(8417.3), unconst_f16(11847.6), unconst_f16(47176.4))))).r); it0<(bitcast<u32>(vp1[0].fract) & 0xfff); it0++) {
  (*a0)[unconst_u32(838495432)] = f16(exp(vec3f(unconst_f32(0.06990), unconst_f32(0.1646e-17), unconst_f32(0.1015)))[1]);
  var vf23: f16 = length(vec3h(unconst_f16(12384.0), unconst_f16(6411.5), unconst_f16(2667.8)));
  vp1[unconst_u32(124880274)].fract = vec2h(textureLoad(tex8, vec2i(unconst_i32(-587902795), unconst_i32(196706159)), unconst_i32(135855976)).zz);
  _ = tex8;
}
  (*a0)[unconst_u32(411630112)] = f16(unconst_f16(-8299.7));
  _ = tex8;
}
  return;
  break;
  _ = tex8;
}
  (*a0)[bitcast<u32>(vp1[0].whole)] = vp1[unconst_u32(774395476)].whole[1];
  _ = tex8;
}

/* zero global variables used */
fn fn1() -> array<array<array<bool, 1>, 1>, 45> {
  var out: array<array<array<bool, 1>, 1>, 45>;
  let vf24: vec3f = asin(vec3f(unconst_f32(0.08710), unconst_f32(0.1179), unconst_f32(0.00451)));
  let ptr24: ptr<function, array<bool, 1>> = &out[44][0];
  return out;
}

@id(60087) override override7: bool;

@group(3) @binding(2) var<storage, read_write> buffer29: array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 13>>;

override override5: i32 = 29935959;

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

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

@group(3) @binding(98) var tex8: texture_2d<i32>;

struct T5 {
  @align(64) @size(768) f0: vec4<bool>,
  @align(32) @size(704) f1: T1,
}

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

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

/* used global variables: tex5 */
@vertex
fn vertex1(a0: VertexInput7, @location(3) location_3: vec4f, a2: VertexInput8, @location(6) location_6: vec2h, a4: VertexInput9, a5: VertexInput10) -> VertexOutput0 {
  var out: VertexOutput0;
  out.location_4 = bitcast<vec3i>(mix(vec3f(unconst_f32(0.05784), unconst_f32(0.2665), unconst_f32(0.04280)), vec3f(unconst_f32(0.1041e-44), unconst_f32(0.07569e-45), unconst_f32(0.2518e8)), unconst_f32(0.05889)).zyx)[0];
  if bool(a4.instance_index) {
  out.position -= bitcast<vec4f>(out.location_8.yyyx);
}
  let vf25: vec2u = textureDimensions(tex5, unconst_i32(161686123));
  let vf26: f16 = a0.location_0;
  var vf27 = fn1();
  let ptr25 = &vp1[0];
  out.location_1 += vec4f(out.location_15[unconst_u32(71717545)]);
  out.position *= a0.location_13;
  return out;
  _ = tex5;
}

/* used global variables: buffer29 */
@fragment
fn fragment1(a0: FragmentInput1, @location(4) @interpolate(flat, either) location_4: i32, a2: FragmentInput2, a3: FragmentInput3, @builtin(position) position: vec4f, a5: FragmentInput4, @builtin(sample_index) sample_index: u32) -> FragmentOutput1 {
  var out: FragmentOutput1;
  let ptr26: ptr<storage, f16, read_write> = &buffer29[unconst_u32(60250063)][unconst_u32(704177181)][unconst_u32(538134838)][0][0][0];
  vp1[unconst_u32(98163296)].fract *= vec2h((*&buffer29)[unconst_u32(1439518397)][unconst_u32(515442352)][unconst_u32(539830304)][unconst_u32(254249298)][0][unconst_u32(1165191583)]);
  var vf28 = fn1();
  return out;
  _ = buffer29;
}

/* used global variables: buffer25 */
@compute @workgroup_size(1, 1, 1)
fn compute6(a0: ComputeInput11, a1: ComputeInput12) {
  let ptr27: ptr<storage, vec4h, read_write> = &buffer25[arrayLength(&buffer25)][unconst_u32(104414225)];
  let ptr28: ptr<storage, vec4h, read_write> = &buffer25[unconst_u32(500893890)][46];
  let vf29: f32 = override6;
  _ = override6;
  _ = buffer25;
}`,
});
let buffer30 = device1.createBuffer({size: 25044, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let commandEncoder30 = device1.createCommandEncoder();
let textureView31 = texture47.createView({dimension: '2d-array'});
let textureView32 = texture36.createView({mipLevelCount: 1});
try {
renderBundleEncoder8.setPipeline(pipeline1);
} catch {}
await gc();
let buffer31 = device1.createBuffer({size: 64, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let renderBundleEncoder10 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float'], stencilReadOnly: true});
let buffer32 = device1.createBuffer({size: 100, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder31 = device1.createCommandEncoder({});
try {
renderBundleEncoder6.insertDebugMarker('\u00ba');
} catch {}
let buffer33 = device1.createBuffer({size: 115, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
let texture54 = device1.createTexture({
  size: {width: 39},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture55 = device1.createTexture({
  size: [39, 41, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder7.setBindGroup(0, bindGroup1, []);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1, 1); };
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer5, 16); };
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(0, buffer22, 0);
} catch {}
try {
  await shaderModule4.getCompilationInfo();
} catch {}
try {
device1.lost.then(r => { console.log('device1 lost!'); console.log(r.message, r.reason); });
} catch {}
let texture56 = device1.createTexture({
  size: {width: 102},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder11 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float'], depthReadOnly: true, stencilReadOnly: true});
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 44, hasDynamicOffset: false },
    },
  ],
});
let commandEncoder32 = device0.createCommandEncoder({});
let textureView33 = texture14.createView({mipLevelCount: 1});
let textureView34 = texture2.createView({});
try {
renderBundleEncoder2.setIndexBuffer(buffer4, 'uint32', 32, 1);
} catch {}
try {
renderBundleEncoder1.insertDebugMarker('\u0220');
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte432', transfer: 'unspecified'} });
let texture57 = device1.createTexture({
  size: [39],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture58 = device1.createTexture({
  size: {width: 51, height: 1, depthOrArrayLayers: 26},
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder13.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(2, buffer33, 0);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
commandEncoder13.copyBufferToBuffer(buffer11, 4, buffer23, 4, 0);
} catch {}
let textureView35 = texture56.createView({format: 'rgba8uint'});
let textureView36 = texture18.createView({dimension: '2d', baseArrayLayer: 0, arrayLayerCount: 1});
try {
renderBundleEncoder11.setBindGroup(3, bindGroup1);
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer13, 16, buffer30, 4608, 4);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm'],
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
globalThis.someLabel = pipeline0.label;
} catch {}
let commandEncoder33 = device1.createCommandEncoder();
let texture59 = device1.createTexture({
  size: [256, 256, 34],
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView37 = texture58.createView({mipLevelCount: 1, arrayLayerCount: 11});
try {
computePassEncoder15.setBindGroup(0, bindGroup1);
} catch {}
let texture60 = device0.createTexture({
  size: [1697, 1, 61],
  mipLevelCount: 2,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture61 = gpuCanvasContext1.getCurrentTexture();
let textureView38 = texture53.createView({dimension: '2d'});
try {
renderBundleEncoder1.setIndexBuffer(buffer10, 'uint16', 48, 30);
} catch {}
try {
buffer9.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(1_489).fill(40), /* required buffer size: 1_489 */
{offset: 32, bytesPerRow: 47, rowsPerImage: 29}, {width: 0, height: 3, depthOrArrayLayers: 2});
} catch {}
let shaderModule5 = device1.createShaderModule({
  label: '\ud7a3\u6a77',
  code: `
enable f16;

diagnostic(info, xyz);

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

var<workgroup> vw14: atomic<u32>;

/* used global variables: buffer34 */
fn fn0(a0: vec2i, a1: ptr<storage, f16, read_write>) {
  for (var jj65=0u; jj65<3; jj65++) { buffer34[unconst_u32(3249047665)][u32((*&buffer34)[unconst_u32(292325360)][unconst_u32(86358417)][unconst_u32(566340961)][0])][2][jj65] = step(unconst_f16(1767.0), buffer34[unconst_u32(393974568)][unconst_u32(757978264)][2][unconst_u32(1914357286)]); }
  return;
  _ = buffer34;
}

var<workgroup> vw13: atomic<i32>;

struct T0 {
  @size(26) f0: atomic<u32>,
}

struct T1 {
  f0: array<u32>,
}

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

@group(3) @binding(2) var<storage, read_write> buffer38: array<array<array<f16, 1>, 13>>;

var<workgroup> vw15: atomic<i32>;

struct FragmentInput5 {
  @location(9) location_9: vec2f,
}

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

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

@id(37089) override override10 = true;

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

var<workgroup> vw18: vec2<bool>;

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

override override11: u32;

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

@group(3) @binding(0) var st8: texture_storage_1d<r32float, read_write>;

override override9 = -450071326;

@group(2) @binding(2) var<storage, read_write> buffer37: array<array<array<array<f16, 13>, 1>, 1>>;

var<workgroup> vw11: atomic<u32>;

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

@group(1) @binding(0) var st6: texture_storage_1d<r32float, read_write>;

struct FragmentInput8 {
  @location(12) @interpolate(flat, sample) location_12: vec4u,
}

struct FragmentInput6 {
  @location(15) location_15: vec2f,
}

@group(2) @binding(0) var st7: texture_storage_1d<r32float, read_write>;

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

alias vec3b = vec3<bool>;

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

struct FragmentInput7 {
  @location(4) @interpolate(flat, centroid) location_4: i32,
}

@group(0) @binding(2) var<storage, read_write> buffer35: array<array<f16, 624>>;

var<workgroup> vw16: vec4i;

/* used global variables: buffer34, buffer35, buffer37, buffer38 */
@fragment
fn fragment2(a0: FragmentInput5, a1: FragmentInput6, a2: FragmentInput7, @location(8) @interpolate(flat, sample) location_8: vec2i, a4: FragmentInput8, a5: FragmentInput9) -> @location(200) @interpolate(perspective) vec4i {
  var out: vec4i;
  let ptr29: ptr<storage, f16, read_write> = &(*&buffer37)[arrayLength(&(*&buffer37))][unconst_u32(275079149)][unconst_u32(926689189)][12];
  let ptr30: ptr<storage, f16, read_write> = &buffer35[arrayLength(&buffer35)][unconst_u32(356036144)];
  fn0(vec2i(i32(buffer37[arrayLength(&buffer37)][0][0][12])), &(*&buffer38)[arrayLength(&(*&buffer38))][unconst_u32(74630737)][0]);
  fn0(vec2i(i32((*&buffer34)[u32(buffer37[unconst_u32(56905081)][unconst_u32(362970871)][unconst_u32(139359796)][12])][unconst_u32(348204072)][unconst_u32(1375009705)][unconst_u32(794707391)])), &buffer34[unconst_u32(372879513)][3][unconst_u32(409220151)][unconst_u32(616480589)]);
  let ptr31: ptr<storage, array<f16, 1>, read_write> = &(*&buffer34)[arrayLength(&(*&buffer34))][3][2];
  return out;
  _ = buffer38;
  _ = buffer37;
  _ = buffer35;
  _ = buffer34;
}

/* used global variables: buffer34, st6, st7, st8 */
@compute @workgroup_size(2, 2, 1)
fn compute7(@builtin(local_invocation_index) local_invocation_index: u32, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u, a3: ComputeInput13) {
  let ptr32: ptr<workgroup, vec4i> = &vw16;
  textureStore(st7, unconst_i32(30455327), vec4f(vec4f(unconst_f32(0.1326), unconst_f32(0.05903), unconst_f32(0.04720e37), unconst_f32(0.2257e33))));
  textureStore(st6, unconst_i32(138963263), vec4f(vec4f(unconst_f32(0.3284), unconst_f32(0.01332e-24), unconst_f32(0.00889), unconst_f32(0.03787))));
  textureStore(st8, unconst_i32(480957692), vec4f(vec4f(unconst_f32(0.00372), unconst_f32(0.3581), unconst_f32(0.1147), unconst_f32(0.01253e9))));
  textureStore(st7, unconst_i32(692363), vec4f(vec4f(unconst_f32(0.2747e0), unconst_f32(0.1639), unconst_f32(0.2199), unconst_f32(-0.3912))));
  textureStore(st8, unconst_i32(114619179), vec4f(vec4f(unconst_f32(0.1356e-42), unconst_f32(0.2379e13), unconst_f32(0.4067e-44), unconst_f32(0.06760e19))));
  fn0(vec2i(i32(buffer34[unconst_u32(742350960)][3][2][unconst_u32(530879824)])), &buffer34[arrayLength(&buffer34)][unconst_u32(249366969)][unconst_u32(230588921)][dot4U8Packed(pack4x8unorm(textureLoad(st7, unconst_i32(130681546))), unconst_u32(738906188))]);
  _ = st7;
  _ = st8;
  _ = buffer34;
  _ = st6;
}`,
});
let autogeneratedBindGroupLayout3 = pipeline1.getBindGroupLayout(0);
let textureView39 = texture52.createView({aspect: 'all'});
try {
computePassEncoder8.setBindGroup(1, bindGroup0);
} catch {}
let commandBuffer0 = commandEncoder13.finish();
let texture62 = device1.createTexture({
  size: [19, 20, 9],
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView40 = texture48.createView({});
try {
computePassEncoder13.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup1, new Uint32Array(503), 21, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer32, 'uint32', 4, 12);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
  await buffer13.mapAsync(GPUMapMode.WRITE, 152, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer23, 12, new DataView(new Uint8Array(13103).map((_, i) => i).buffer), 1547, 0);
} catch {}
let shaderModule6 = device1.createShaderModule({
  code: `
enable f16;

var<workgroup> vw21: atomic<u32>;

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

struct T1 {
  f0: array<vec2i>,
}

var<workgroup> vw20: vec4<bool>;

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

@group(0) @binding(2) var<storage, read_write> buffer39: array<array<array<array<array<f16, 13>, 1>, 1>, 1>>;

@id(56479) override override13: f16 = 6601.8;

alias vec3b = vec3<bool>;

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

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

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

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

struct FragmentOutput2 {
  @location(0) location_0: vec4f,
  @location(1) location_1: vec4u,
}

@group(2) @binding(0) var<storage, read_write> buffer42: array<array<f16, 94>, 2>;

struct VertexInput14 {
  @location(3) @interpolate(flat) location_3: i32,
}

struct T0 {
  f0: atomic<i32>,
}

@group(3) @binding(0) var st10: texture_storage_1d<r32float, read_write>;

@group(2) @binding(1) var<storage, read_write> buffer43: u32;

var<private> vp2: vec4h = vec4h(6044.9, 20609.3, 11746.5, 8823.7);

@group(1) @binding(0) var<storage, read_write> buffer40: array<i32, 94>;

override override15: f32;

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

@id(5803) override override14: i32;

struct VertexInput12 {
  @location(0) @interpolate(flat) location_0: vec2u,
}

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

struct VertexInput11 {
  @location(9) location_9: vec2i,
}

struct VertexInput13 {
  @location(10) location_10: vec4u,
}

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

@id(51525) override override12: u32;

/* zero global variables used */
@vertex
fn vertex2(a0: VertexInput11, @location(2) @interpolate(linear) location_2: vec4f, @location(14) location_14: f32, @location(13) location_13: vec4h, a4: VertexInput12, a5: VertexInput13, @location(1) location_1: vec4u, a7: VertexInput14, @location(11) location_11: f16, @location(5) @interpolate(flat) location_5: vec2i, a10: VertexInput15, @location(6) location_6: vec4u, @location(7) @interpolate(flat) location_7: i32) -> @builtin(position) vec4f {
  var out: vec4f;
  out = vec4f((vec3u(unconst_u32(1084289261), unconst_u32(709217561), unconst_u32(2783665049)) >  ~vec2u(unconst_u32(506035062), unconst_u32(75087546)).yxx).grbr);
  vp2 *= bitcast<vec4h>((mat2x2f(unconst_f32(0.1138e-5), unconst_f32(0.3157), unconst_f32(0.02238), unconst_f32(0.2936)) + mat2x2f(unconst_f32(0.1871), unconst_f32(0.3274e32), unconst_f32(0.1069), unconst_f32(0.09090)))[unconst_i32(1)]);
  return out;
}

/* used global variables: buffer39, buffer43 */
@fragment
fn fragment3() -> FragmentOutput2 {
  var out: FragmentOutput2;
  out.location_1 = vec4u(u32((*&buffer39)[arrayLength(&(*&buffer39))][0][0][0][12]));
  buffer43 = u32((*&buffer39)[arrayLength(&(*&buffer39))][unconst_u32(401863238)][unconst_u32(696354199)][0][12]);
  let ptr33: ptr<storage, array<array<array<array<f16, 13>, 1>, 1>, 1>, read_write> = &(*&buffer39)[unconst_i32(135719015)];
  let ptr34: ptr<storage, array<f16, 13>, read_write> = &(*&buffer39)[unconst_u32(340245634)][0][0][unconst_u32(259209717)];
  return out;
  _ = buffer39;
  _ = buffer43;
}

/* used global variables: buffer40, buffer42, st10 */
@compute @workgroup_size(2, 1, 1)
fn compute8(a0: ComputeInput14, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u) {
  buffer40[unconst_u32(744710018)] = i32(a0.local_invocation_index);
  textureStore(st10, atomicLoad(&vw19[unconst_u32(2000019694)]), vec4f(vec4f(unconst_f32(0.01011), unconst_f32(0.2163), unconst_f32(0.4872e-27), unconst_f32(-0.1430e29))));
  let ptr35: ptr<workgroup, array<atomic<i32>, 1>> = &vw19;
  let ptr36: ptr<storage, array<f16, 94>, read_write> = &(*&buffer42)[unconst_u32(1323056239)];
  let ptr37: ptr<storage, array<f16, 94>, read_write> = &(*&buffer42)[1];
  let ptr38: ptr<storage, f16, read_write> = &(*&buffer42)[unconst_u32(1470602299)][93];
  vp2 = vec4h(f16(atomicLoad(&vw19[unconst_u32(1241882383)])));
  _ = buffer40;
  _ = buffer42;
  _ = st10;
}`,
});
let texture63 = device1.createTexture({
  size: {width: 19, height: 20, depthOrArrayLayers: 366},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture64 = device1.createTexture({size: {width: 256}, dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.COPY_DST});
let texture65 = gpuCanvasContext1.getCurrentTexture();
let computePassEncoder16 = commandEncoder30.beginComputePass();
try {
renderBundleEncoder10.setIndexBuffer(buffer32, 'uint16', 4, 1);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(4, buffer33);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 156, height: 164, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas1,
  origin: { x: 0, y: 28 },
  flipY: false,
}, {
  texture: texture46,
  mipLevel: 0,
  origin: {x: 50, y: 26, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 6, depthOrArrayLayers: 0});
} catch {}
let querySet0 = device1.createQuerySet({type: 'occlusion', count: 386});
let textureView41 = texture62.createView({});
let texture66 = device1.createTexture({
  size: {width: 78},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba16sint'],
});
try {
computePassEncoder16.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline1);
} catch {}
try {
commandEncoder27.copyTextureToTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 5, y: 3, z: 0},
  aspect: 'all',
},
{
  texture: texture63,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 39},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 4});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 1, depthOrArrayLayers: 26}
*/
{
  source: imageData0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture58,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture67 = device0.createTexture({
  size: [1697, 1, 16],
  mipLevelCount: 10,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture68 = device0.createTexture({
  size: [8, 1424, 1],
  mipLevelCount: 9,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView42 = texture11.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 7});
try {
device0.queue.writeTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 139, y: 0, z: 15},
  aspect: 'all',
}, new Uint8Array(248).fill(38), /* required buffer size: 248 */
{offset: 248}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture69 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView43 = texture9.createView({baseArrayLayer: 32, arrayLayerCount: 23});
let computePassEncoder17 = commandEncoder20.beginComputePass();
let veryExplicitBindGroupLayout12 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 68,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 174, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 236,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 379,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let texture70 = device1.createTexture({
  size: {width: 156},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView44 = texture58.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 2});
let renderBundleEncoder12 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder8.setBindGroup(0, bindGroup0, []);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(0, buffer21, 64);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let veryExplicitBindGroupLayout13 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 68,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 174, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 236,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 379,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer45 = device1.createBuffer({size: 7700, usage: GPUBufferUsage.INDIRECT});
let commandEncoder34 = device1.createCommandEncoder({});
let textureView45 = texture66.createView({aspect: 'all', baseMipLevel: 0, arrayLayerCount: 1});
let texture71 = device1.createTexture({
  size: {width: 39, height: 41, depthOrArrayLayers: 166},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder13 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder14.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder16.setBindGroup(3, bindGroup1, new Uint32Array(3945), 907, 0);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer21);
} catch {}
let commandEncoder35 = device0.createCommandEncoder({});
let texture72 = device0.createTexture({
  size: [8, 1424, 1],
  mipLevelCount: 2,
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView46 = texture26.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let buffer46 = device0.createBuffer({size: 5132, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let texture73 = device0.createTexture({
  size: [848, 1, 1],
  format: 'rg32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture74 = device0.createTexture({
  size: [1697, 1, 1],
  mipLevelCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4});
let textureView47 = texture56.createView({});
let renderBundleEncoder15 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true});
let sampler7 = device1.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 98.67});
try {
computePassEncoder8.setBindGroup(1, bindGroup0, new Uint32Array(1075), 86, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let texture75 = device0.createTexture({
  size: [4, 712, 1],
  sampleCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView48 = texture26.createView({dimension: '2d', mipLevelCount: 1});
let imageBitmap0 = await createImageBitmap(imageData0);
let bindGroup2 = device1.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView15}]});
let texture76 = device1.createTexture({
  size: [2560],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder7.setBindGroup(1, bindGroup1);
} catch {}
try {
computePassEncoder13.setBindGroup(0, bindGroup0, new Uint32Array(227), 10, 0);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(4, buffer22, 48, 16);
} catch {}
try {
commandEncoder27.copyBufferToBuffer(buffer13, 0, buffer31, 4, 0);
} catch {}
let offscreenCanvas2 = new OffscreenCanvas(294, 170);
let buffer47 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let texture77 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

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

struct VertexInput20 {
  @location(6) location_6: vec2f,
}

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

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

struct VertexInput22 {
  @location(15) location_15: vec2f,
}

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

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

struct T0 {
  @size(16) f0: atomic<u32>,
  @size(224) f1: atomic<u32>,
  f2: array<array<array<vec4u, 1>, 1>>,
}

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

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

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

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

struct VertexInput17 {
  @location(5) @interpolate(flat, sample) location_5: vec2u,
  @builtin(vertex_index) vertex_index: u32,
}

struct VertexInput18 {
  @location(13) location_13: vec4i,
  @location(14) location_14: f16,
  @location(9) location_9: vec4h,
  @location(7) @interpolate(perspective, sample) location_7: vec2h,
  @location(8) @interpolate(flat) location_8: u32,
  @location(10) location_10: vec4u,
  @location(2) location_2: vec4i,
}

struct VertexInput16 {
  @location(3) location_3: u32,
  @location(4) @interpolate(flat) location_4: i32,
}

/* zero global variables used */
fn fn2(a0: sampler) -> vec2h {
  var out: vec2h;
  out = vec2h(floor(vec2f(unconst_f32(0.2342), unconst_f32(0.03633))).rr.yx);
  out = vec2h(fma(vec4f(unconst_f32(-0.3382e35), unconst_f32(0.08308e37), unconst_f32(0.06859e-39), unconst_f32(0.06341)), vec4f(unconst_f32(0.04234e11), unconst_f32(0.3314e-33), unconst_f32(-0.05179e-12), unconst_f32(0.1087)), vec4f(f32(length(vec2h(unconst_f16(7652.3), unconst_f16(2432.8)))))).ra);
  out -= pow(vec4h(unconst_f16(19016.6), unconst_f16(8154.2), unconst_f16(2972.8), unconst_f16(666.9)), vec4h(unconst_f16(11971.2), unconst_f16(4962.0), unconst_f16(6077.1), unconst_f16(140.8))).xw;
  out = bitcast<vec2h>(pack2x16snorm(vec2f(unconst_f32(0.02920e-33), unconst_f32(0.2791e-9))));
  out -= vec2h(fma(vec4f(unconst_f32(0.08981e34), unconst_f32(0.4141e8), unconst_f32(0.2176e-36), unconst_f32(0.5855e-33)), vec4f(unconst_f32(1.000e-21), unconst_f32(-0.9321e-28), unconst_f32(0.00304), unconst_f32(0.04891)), floor(vec2f(unconst_f32(0.1700), unconst_f32(0.5450e-42))).rgrr).yy);
  let vf36: vec3f = select(vec3f(unconst_f32(0.02886), unconst_f32(0.00966), unconst_f32(0.1372e-28)), vec3f(unconst_f32(0.1664e23), unconst_f32(0.01290), unconst_f32(0.3722)), vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false)));
  out += vec2h(fract(unconst_f16(-14876.9)));
  out = bitcast<vec2h>(pack2x16snorm(faceForward(round(vec4f(unconst_f32(0.1696e-24), unconst_f32(0.1646e20), unconst_f32(0.04622e30), unconst_f32(0.03288e-6))), vec4f(unconst_f32(0.06383e21), unconst_f32(0.1316e19), unconst_f32(0.01560), unconst_f32(0.4490e18)), vec4f(unconst_f32(0.1864e-33), unconst_f32(-0.1732e-15), unconst_f32(0.05229), unconst_f32(0.1989e35))).xy));
  let vf37: f32 = ldexp(unconst_f32(0.3074e10), unconst_i32(114014587));
  out += pow(vec4h(unconst_f16(-5222.4), unconst_f16(38076.6), unconst_f16(3408.1), unconst_f16(16411.9)), pow(vec2h(unconst_f16(2980.9), unconst_f16(7084.5)), vec2h(out[unconst_u32(87265602)])).gggr).xy;
  out = round(vec3h(unconst_f16(6095.5), unconst_f16(2444.2), unconst_f16(23815.7))).zy;
  out *= bitcast<vec2h>(vf37);
  return out;
}

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

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

struct VertexInput19 {
  @location(1) @interpolate(linear, either) location_1: f32,
}

/* zero global variables used */
fn fn0() {
  loop {
  loop {
  let vf30: vec2h = degrees(vec2h(unconst_f16(14595.9), unconst_f16(-2398.1)));
  break;
}
  let vf31: f16 = smoothstep(unconst_f16(34745.0), unconst_f16(1567.0), unconst_f16(2045.1));
  break;
}
  var vf32: u32 = dot4U8Packed(unconst_u32(365189223), unconst_u32(651179358));
}

struct FragmentOutput3 {
  @location(5) location_5: vec4f,
  @location(2) location_2: vec2i,
  @location(0) @interpolate(perspective) location_0: vec4f,
}

/* used global variables: sam2 */
fn fn1(a0: sampler) {
  let vf33: f32 = exp2(unconst_f32(0.1702e-20));
  _ = sam2;
  fn0();
  let vf34: vec2u = countOneBits(vec2u(unconst_u32(209812076), unconst_u32(213383380)));
  _ = a0;
  var vf35: vec3i = min(vec3i(unconst_i32(306962296), unconst_i32(73626135), unconst_i32(113203945)), vec3i(unconst_i32(392560721), unconst_i32(3215174), unconst_i32(563765876)));
  vf35 = vec3i(vec3i(unconst_i32(629618309), unconst_i32(194255016), unconst_i32(239215163)));
  _ = sam2;
}

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

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

/* zero global variables used */
@vertex
fn vertex3(a0: VertexInput16, @location(11) location_11: i32, a2: VertexInput17, a3: VertexInput18, @location(12) location_12: vec2h, a5: VertexInput19, a6: VertexInput20, a7: VertexInput21, a8: VertexInput22, @builtin(instance_index) instance_index: u32) -> @builtin(position) vec4f {
  var out: vec4f;
  fn0();
  out -= bitcast<vec4f>(select(vec3i(unconst_i32(24848795), unconst_i32(841373121), unconst_i32(498120809)), vec3i(i32(radians(unconst_f32(0.05729)))), vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false))).zxyz);
  out += unpack4x8snorm(a2.vertex_index);
  out += vec4f(a2.location_5.yyyx.raar.aagb.rgrr);
  var vf38: f16 = a3.location_14;
  out = vec4f(a3.location_2);
  out += vec4f(f32(a3.location_7[unconst_u32(2870814000)]));
  return out;
}

/* zero global variables used */
@fragment
fn fragment4(@invariant @builtin(position) position: vec4f) -> FragmentOutput3 {
  var out: FragmentOutput3;
  fn0();
  return out;
}

/* used global variables: sam2 */
@compute @workgroup_size(1, 1, 2)
fn compute9(@builtin(local_invocation_id) local_invocation_id: vec3u, a1: ComputeInput15, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, a4: ComputeInput16) {
  fn2(sam2);
  fn0();
  _ = sam2;
}`,
});
let texture78 = device0.createTexture({
  size: [424, 1, 43],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture79 = device0.createTexture({
  size: {width: 4, height: 712, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView49 = texture22.createView({});
let externalTexture6 = device0.importExternalTexture({source: videoFrame2});
await gc();
let img0 = await imageWithData(167, 4, '#10101010', '#20202020');
let buffer48 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder36 = device0.createCommandEncoder({});
let texture80 = device0.createTexture({
  size: [8, 1424, 1],
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4});
try {
renderBundleEncoder7.setVertexBuffer(0, buffer8, 0, 1_103);
} catch {}
let imageData5 = new ImageData(20, 16);
let buffer49 = device0.createBuffer({
  size: 253,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let texture81 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture82 = device0.createTexture({
  size: [16, 16, 27],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder18 = commandEncoder17.beginComputePass();
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
let texture83 = device1.createTexture({
  size: {width: 102, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder8.setVertexBuffer(0, buffer31, 0, 2);
} catch {}
try {
commandEncoder22.resolveQuerySet(querySet0, 0, 6, buffer5, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
let texture84 = device0.createTexture({
  size: {width: 8, height: 1424, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture85 = device0.createTexture({
  size: {width: 8},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView50 = texture19.createView({dimension: '2d'});
let texture86 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 27},
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
device0.queue.writeTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 70, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(13).fill(190), /* required buffer size: 13 */
{offset: 13}, {width: 142, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView51 = texture86.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 7, arrayLayerCount: 6});
let texture87 = device0.createTexture({size: [8], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC});
let texture88 = gpuCanvasContext0.getCurrentTexture();
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
computePassEncoder16.setBindGroup(3, bindGroup0);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(2); };
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline1);
} catch {}
try {
device1.queue.writeBuffer(buffer30, 20_232, new Float32Array(3932).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.638)), 503, 124);
} catch {}
let texture89 = device1.createTexture({size: [2560], dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.STORAGE_BINDING});
let computePassEncoder19 = commandEncoder25.beginComputePass();
try {
computePassEncoder8.setBindGroup(1, bindGroup1);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(2, 1); };
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer45, 488); };
} catch {}
try {
renderBundleEncoder13.setBindGroup(2, bindGroup1, new Uint32Array(119), 0, 0);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline1);
} catch {}
let commandEncoder37 = device0.createCommandEncoder();
let texture90 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 84},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext2 = offscreenCanvas2.getContext('webgpu');
document.body.append(img0);
let commandEncoder38 = device1.createCommandEncoder();
let texture91 = device1.createTexture({size: [256, 256, 12], format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING});
let externalTexture7 = device1.importExternalTexture({source: videoFrame3});
try {
renderBundleEncoder9.setBindGroup(2, bindGroup2, new Uint32Array(499), 152, 0);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(0, buffer33, 0, 51);
} catch {}
try {
commandEncoder38.clearBuffer(buffer23);
} catch {}
try {
commandEncoder24.pushDebugGroup('\u{1fe2b}');
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 1, depthOrArrayLayers: 26}
*/
{
  source: offscreenCanvas1,
  origin: { x: 2, y: 101 },
  flipY: false,
}, {
  texture: texture58,
  mipLevel: 2,
  origin: {x: 3, y: 0, z: 8},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder39 = device1.createCommandEncoder({});
let textureView52 = texture36.createView({arrayLayerCount: 1});
let renderBundleEncoder18 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true});
try {
computePassEncoder11.setBindGroup(1, bindGroup1);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1, 1); };
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer5, 4); };
} catch {}
try {
computePassEncoder7.end();
} catch {}
try {
computePassEncoder19.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup1);
} catch {}
try {
buffer5.unmap();
} catch {}
let canvas0 = document.createElement('canvas');
try {
device0.queue.writeBuffer(buffer3, 4, new Float32Array(1464).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.320)), 174, 8);
} catch {}
let commandEncoder40 = device1.createCommandEncoder();
let texture92 = device1.createTexture({
  size: [640, 1, 1],
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder13.setBindGroup(1, bindGroup0);
} catch {}
try {
buffer32.unmap();
} catch {}
try {
commandEncoder38.copyBufferToBuffer(buffer13, 4, buffer31, 16, 12);
} catch {}
let shaderModule8 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

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

struct VertexInput23 {
  @location(5) @interpolate(flat, either) location_5: vec4i,
}

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

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

struct T1 {
  @size(448) f0: array<vec4f, 11>,
  f1: array<atomic<u32>>,
}

override override16: i32;

override override17: bool;

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

struct T0 {
  @size(34) f0: array<vec4f, 1>,
}

struct VertexOutput1 {
  @location(12) location_12: u32,
  @invariant @builtin(position) position: vec4f,
  @location(6) @interpolate(flat, first) location_6: u32,
}

struct VertexInput25 {
  @location(3) location_3: vec2f,
  @location(9) location_9: i32,
  @builtin(vertex_index) vertex_index: u32,
}

var<private> vp3: vec4u = vec4u(24226650, 394249774, 490580452, 1097881783);

struct T4 {
  f0: array<u32>,
}

struct T5 {
  f0: array<u32>,
}

alias vec3b = vec3<bool>;

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

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

struct FragmentOutput4 {
  @location(3) location_3: u32,
  @location(7) location_7: vec4i,
  @location(0) @interpolate(flat) location_0: vec4f,
}

struct VertexInput24 {
  @location(12) @interpolate(perspective) location_12: vec4h,
  @location(0) location_0: u32,
  @location(8) location_8: vec2u,
  @location(13) location_13: vec4h,
  @location(6) @interpolate(flat) location_6: i32,
  @location(15) @interpolate(perspective) location_15: vec2h,
  @location(14) location_14: vec2f,
  @location(4) @interpolate(flat) location_4: vec4i,
}

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

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

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

/* zero global variables used */
@vertex
fn vertex4(a0: VertexInput23, a1: VertexInput24, a2: VertexInput25, @location(2) @interpolate(perspective, center) location_2: vec4f, @location(10) location_10: f16, @location(1) location_1: vec4h, @location(7) @interpolate(flat) location_7: vec2u) -> VertexOutput1 {
  var out: VertexOutput1;
  out.position *= vec4f(a1.location_8.grrg.xzzx.yyyz);
  var vf39: mat3x2h = (mat3x2h(unconst_f16(3564.0), unconst_f16(9828.8), unconst_f16(15599.4), unconst_f16(16158.3), unconst_f16(368.4), unconst_f16(-13936.4)) + mat3x2h(unconst_f16(2796.1), unconst_f16(12810.1), unconst_f16(3799.6), unconst_f16(-25463.8), unconst_f16(12360.9), unconst_f16(17572.6)));
  let vf40: f32 = location_2[unconst_u32(856524387)];
  vp3 >>= vec4u(out.location_6);
  var vf41: vec4h = a1.location_12;
  var vf42: i32 = a1.location_4[unconst_u32(167839260)];
  return out;
}

/* zero global variables used */
@fragment
fn fragment5() -> FragmentOutput4 {
  var out: FragmentOutput4;
  let vf43: vec2f = unpack2x16unorm(unconst_u32(1803416637));
  out.location_3 >>= pack2x16unorm(vec2f(unconst_f32(0.2546e22), unconst_f32(0.03249e-23)));
  let ptr39: ptr<function, u32> = &out.location_3;
  out.location_7 *= vec4i(normalize(vec3h(unconst_f16(11844.5), unconst_f16(10635.1), unconst_f16(1047.2))).zyxy);
  out.location_0 = bitcast<vec4f>(out.location_7.baab);
  if bool(normalize(vec3h(unconst_f16(1660.8), unconst_f16(4571.0), unconst_f16(8242.3))).b) {
  var vf44: vec4h = exp(vec4h(unconst_f16(2207.0), unconst_f16(15512.5), unconst_f16(12567.7), unconst_f16(11969.1)));
  out.location_3 &= vp3[u32(override17)];
  out.location_7 = unpack4xI8(countTrailingZeros(unconst_u32(319588710)));
  while bool(out.location_3) {
  out.location_0 += unpack4x8unorm(unconst_u32(361348781));
  {
  let vf45: mat2x3h = (mat2x3h(unconst_f16(5833.8), unconst_f16(5813.0), unconst_f16(8479.8), unconst_f16(5544.5), unconst_f16(8017.2), unconst_f16(25974.1)) + mat2x3h(unconst_f16(6453.4), unconst_f16(30220.4), unconst_f16(427.9), unconst_f16(16639.1), unconst_f16(3705.3), unconst_f16(6398.5)));
  break;
}
  break;
}
  {
  let vf46: u32 = pack2x16unorm(vec2f(unconst_f32(0.1255), unconst_f32(0.3922)));
  out.location_3 -= u32(override16);
  out.location_3 |= vec2u(max(vec2f(unconst_f32(0.1217e-36), unconst_f32(0.4306)), vec2f(bitcast<f32>(out.location_7[unconst_u32(775017818)])))).g;
  var vf47: vec3h = sin(vec3h(unconst_f16(2141.9), unconst_f16(8205.7), unconst_f16(7436.9)));
  _ = override16;
}
  var vf48: u32 = pack4xI8(vec4i(unconst_i32(214612935), unconst_i32(191258900), unconst_i32(1875137452), unconst_i32(71090150)));
  _ = override16;
  _ = override17;
}
  let ptr40: ptr<function, FragmentOutput4> = &out;
  return out;
  _ = override17;
  _ = override16;
}

/* used global variables: sam3 */
@compute @workgroup_size(2, 1, 1)
fn compute10(a0: ComputeInput17, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u) {
  var vf49: u32 = a0.local_invocation_index;
  _ = sam3;
  let vf50: vec2<bool> = (vec2h(unconst_f16(34547.3), unconst_f16(2041.6)) < vec2h(workgroup_id.yz.rr));
  vf49 <<= vp3[u32(all(vf50))];
  vp3 = vec4u(vp3[unconst_u32(587149260)]);
  vp3 -= unpack4xU8(u32(vf50[unconst_u32(167906817)]));
  for (var it1=u32(all((vec2h(unconst_f16(25048.8), unconst_f16(6891.0)) < vec2h(unconst_f16(13963.6), unconst_f16(5082.8))))); it1<(u32(override17) & 0xfff); it1++) {
  vp3 = vec4u((unconst_f16(3893.5) + vec4h(unconst_f16(30000.6), unconst_f16(9314.1), unconst_f16(2854.5), unconst_f16(3599.8))).yyxx.wxww);
}
  vf49 = bitcast<u32>(override16);
  _ = override17;
  _ = override16;
  _ = sam3;
}`,
});
let commandEncoder41 = device0.createCommandEncoder({});
let textureView53 = texture85.createView({label: '\u24c5\udde5\u0c30', mipLevelCount: 1});
try {
renderBundleEncoder7.setIndexBuffer(buffer47, 'uint32', 12, 14);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(2, buffer8, 0);
} catch {}
let textureView54 = texture91.createView({dimension: 'cube'});
let computePassEncoder20 = commandEncoder39.beginComputePass();
try {
computePassEncoder19.setBindGroup(3, bindGroup2, new Uint32Array(4072), 1_655, 0);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder20.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer32, 'uint16', 6, 4);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline1);
} catch {}
try {
commandEncoder21.copyTextureToTexture({
  texture: texture55,
  mipLevel: 0,
  origin: {x: 0, y: 17, z: 0},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 1, y: 9, z: 118},
  aspect: 'all',
},
{width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
let img1 = await imageWithData(108, 47, '#10101010', '#20202020');
let commandEncoder42 = device0.createCommandEncoder();
let texture93 = device0.createTexture({
  size: [424],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture94 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView55 = texture33.createView({mipLevelCount: 1});
try {
renderBundleEncoder2.setVertexBuffer(5, buffer8, 5_392, 4_262);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 24, new DataView(new ArrayBuffer(17190)), 129, 4);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let texture95 = gpuCanvasContext0.getCurrentTexture();
let commandEncoder43 = device0.createCommandEncoder({});
let texture96 = device0.createTexture({size: [1697, 1, 75], dimension: '3d', format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
renderBundleEncoder14.setVertexBuffer(3, buffer8, 0, 8_878);
} catch {}
try {
gpuCanvasContext2.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC, alphaMode: 'premultiplied'});
} catch {}
let gpuCanvasContext3 = canvas0.getContext('webgpu');
document.body.append(img0);
let bindGroup3 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [{binding: 1, resource: {buffer: buffer49, size: 56}}],
});
let commandEncoder44 = device0.createCommandEncoder({label: '\u674f\uc796\ub911\u7f3a\u{1fed5}\u5246\uefae\ue5e1\ufea1'});
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpteRp431', transfer: 'bt709'} });
let buffer50 = device1.createBuffer({
  size: 81,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder45 = device1.createCommandEncoder({});
let texture97 = device1.createTexture({
  size: {width: 78},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let renderBundleEncoder19 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float'], depthReadOnly: true});
try {
renderBundleEncoder4.setBindGroup(0, bindGroup2, new Uint32Array(1375), 44, 0);
} catch {}
try {
device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); });
} catch {}
let bindGroup4 = device1.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 0, resource: textureView15}]});
let commandEncoder46 = device1.createCommandEncoder({});
let renderBundleEncoder20 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true});
try {
{ clearResourceUsages(device1, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer5, 4); };
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer32, 'uint16', 12, 1);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline3 = await device1.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule1, targets: [{format: 'rgba16float', writeMask: 0}]},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 392,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 26, shaderLocation: 11},
          {format: 'float16x2', offset: 84, shaderLocation: 7},
          {format: 'uint16x4', offset: 4, shaderLocation: 5},
          {format: 'sint32x3', offset: 4, shaderLocation: 15},
          {format: 'unorm16x4', offset: 20, shaderLocation: 0},
          {format: 'unorm16x2', offset: 60, shaderLocation: 6},
          {format: 'unorm8x2', offset: 2, shaderLocation: 13},
          {format: 'sint32', offset: 124, shaderLocation: 2},
          {format: 'float16x4', offset: 48, shaderLocation: 3},
          {format: 'snorm8x2', offset: 14, shaderLocation: 10},
          {format: 'uint8x4', offset: 44, shaderLocation: 9},
          {format: 'uint32x2', offset: 0, shaderLocation: 8},
          {format: 'sint8x4', offset: 60, shaderLocation: 1},
          {format: 'sint8x4', offset: 52, shaderLocation: 14},
          {format: 'uint32', offset: 36, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 184,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x2', offset: 16, shaderLocation: 4}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
let bindGroup5 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: textureView6},
    {binding: 13, resource: textureView51},
    {binding: 30, resource: {buffer: buffer49, size: 16}},
    {binding: 103, resource: externalTexture3},
    {binding: 9, resource: textureView5},
  ],
});
let commandEncoder47 = device0.createCommandEncoder({});
try {
renderBundleEncoder7.setBindGroup(3, bindGroup5, new Uint32Array(1396), 18, 0);
} catch {}
try {
commandEncoder43.copyTextureToTexture({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 0, y: 6, z: 0},
  aspect: 'all',
},
{
  texture: texture35,
  mipLevel: 0,
  origin: {x: 311, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline4 = device0.createRenderPipeline({
  label: '\u{1fe6d}\u0843\uf67a\u8d47\u6c64\u0dac',
  layout: pipelineLayout4,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule8,
  constants: {override17: 1, override16: 1},
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'dst-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule8,
    constants: {},
    buffers: [
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 0, shaderLocation: 8},
          {format: 'sint32x2', offset: 4, shaderLocation: 9},
          {format: 'sint8x2', offset: 10, shaderLocation: 5},
          {format: 'snorm16x2', offset: 8, shaderLocation: 14},
          {format: 'sint32x3', offset: 0, shaderLocation: 4},
          {format: 'uint8x2', offset: 22, shaderLocation: 0},
          {format: 'unorm8x4', offset: 12, shaderLocation: 13},
          {format: 'uint32x3', offset: 0, shaderLocation: 7},
          {format: 'unorm16x4', offset: 0, shaderLocation: 10},
          {format: 'unorm16x4', offset: 0, shaderLocation: 12},
          {format: 'snorm16x2', offset: 4, shaderLocation: 3},
          {format: 'unorm16x2', offset: 0, shaderLocation: 15},
          {format: 'snorm16x2', offset: 4, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 44,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 0, shaderLocation: 2}, {format: 'sint8x2', offset: 0, shaderLocation: 6}],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: false,
},
});
try {
computePassEncoder13.setBindGroup(1, bindGroup1);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer45, 776); };
} catch {}
try {
computePassEncoder11.end();
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer32, 'uint32', 16, 8);
} catch {}
try {
commandEncoder24.copyTextureToTexture({
  texture: texture83,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 11},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture0.label;
} catch {}
let bindGroup6 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [{binding: 1, resource: {buffer: buffer49, offset: 0, size: 72}}],
});
let texture98 = device0.createTexture({
  size: [2],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
device0.queue.writeBuffer(buffer3, 16, new DataView(new Uint8Array(8910).map((_, i) => i).buffer), 5572, 4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(34).fill(165), /* required buffer size: 34 */
{offset: 34}, {width: 136, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline5 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule8, constants: {override17: 1, override16: 1}}});
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 30,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false },
    },
    {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
  ],
});
let commandEncoder48 = device0.createCommandEncoder({});
let textureView56 = texture40.createView({});
try {
computePassEncoder6.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(6, buffer2, 0, 13);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
let commandEncoder49 = device1.createCommandEncoder({});
let textureView57 = texture46.createView({dimension: '2d-array', format: 'rgba16float', baseMipLevel: 0});
let computePassEncoder21 = commandEncoder18.beginComputePass();
let renderBundleEncoder21 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4});
try {
{ clearResourceUsages(device1, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); };
} catch {}
let texture99 = device1.createTexture({
  size: [102, 1, 1],
  sampleCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder21.setBindGroup(1, bindGroup2);
} catch {}
try {
computePassEncoder15.end();
} catch {}
try {
computePassEncoder21.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder19.setBindGroup(2, bindGroup4);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(1, buffer21, 16);
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
let texture100 = device1.createTexture({
  size: [408],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture101 = gpuCanvasContext2.getCurrentTexture();
let textureView58 = texture59.createView({format: 'r32sint'});
try {
{ clearResourceUsages(device1, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer45, 260); };
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup4, new Uint32Array(1605), 70, 0);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(1, buffer31, 4, 15);
} catch {}
let bindGroup7 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 30, resource: {buffer: buffer49, size: 76}},
    {binding: 103, resource: externalTexture0},
    {binding: 13, resource: textureView51},
    {binding: 9, resource: textureView5},
    {binding: 1, resource: textureView6},
  ],
});
let commandEncoder50 = device0.createCommandEncoder({});
let querySet1 = device0.createQuerySet({type: 'timestamp', count: 269});
let texture102 = device0.createTexture({
  size: [424, 1, 36],
  mipLevelCount: 6,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView59 = texture27.createView({});
let renderPassEncoder0 = commandEncoder41.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 238.2, g: 494.3, b: 767.4, a: -594.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder5.setPipeline(pipeline5);
} catch {}
try {
commandEncoder50.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 26, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3128 */
  offset: 3128,
  bytesPerRow: 4608,
  buffer: buffer46,
}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(18, 16);
let veryExplicitBindGroupLayout15 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {binding: 31, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 62,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 120,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 138,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let bindGroup8 = device1.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 0, resource: textureView15}]});
let buffer51 = device1.createBuffer({size: 440, usage: GPUBufferUsage.INDIRECT});
let texture103 = device1.createTexture({
  size: [78],
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder22 = commandEncoder26.beginComputePass();
let renderPassEncoder1 = commandEncoder49.beginRenderPass({
  colorAttachments: [{
  view: textureView57,
  clearValue: { r: 833.2, g: -406.4, b: -836.8, a: 238.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 15886176,
});
try {
computePassEncoder14.setBindGroup(1, bindGroup4, []);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder21.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup1, new Uint32Array(2794), 124, 0);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup1);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
commandEncoder21.copyTextureToTexture({
  texture: texture52,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 19},
  aspect: 'all',
},
{
  texture: texture64,
  mipLevel: 0,
  origin: {x: 87, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder4.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup7, new Uint32Array(3253), 826, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
texture33.label = '\u7aea\ua79f';
} catch {}
try {
computePassEncoder9.setBindGroup(1, bindGroup3);
} catch {}
try {
computePassEncoder9.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer2);
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 80}
*/
{
  source: imageData3,
  origin: { x: 7, y: 6 },
  flipY: false,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 8},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture104 = device1.createTexture({
  size: [1280],
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView60 = texture56.createView({});
try {
renderPassEncoder1.setBindGroup(2, bindGroup2);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(4, buffer33, 4, 58);
} catch {}
try {
adapter0.label = '\uf66a\u02a1\u9fee\u27f5\u02ba\u{1fd1f}\u34a2\ua0cf\ub9ff';
} catch {}
let commandEncoder51 = device1.createCommandEncoder({});
let texture105 = device1.createTexture({
  size: {width: 51},
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture106 = device1.createTexture({
  size: [51, 1, 17],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float'],
});
try {
commandEncoder31.copyTextureToBuffer({
  texture: texture104,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 796 widthInBlocks: 199 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2492 */
  offset: 2492,
  bytesPerRow: 4608,
  buffer: buffer30,
}, {width: 199, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise3;
} catch {}
let commandEncoder52 = device0.createCommandEncoder({});
let texture107 = device0.createTexture({
  size: {width: 8, height: 1424, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'eac-r11unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer47, 'uint16', 14, 13);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
let commandEncoder53 = device0.createCommandEncoder({});
let textureView61 = texture16.createView({mipLevelCount: 1});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder1.setBindGroup(1, bindGroup3, new Uint32Array(2532), 123, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer4, 'uint32', 4, 19);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(5, buffer2, 0, 23);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeBuffer(buffer46, 520, new Uint32Array(14713).map((_, i) => i * 5), 556, 76);
} catch {}
let buffer52 = device1.createBuffer({size: 44, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder54 = device1.createCommandEncoder({});
let texture108 = device1.createTexture({
  size: {width: 19, height: 20, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder23 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: true});
try {
{ clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer5, 20); };
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer32, 'uint16', 2, 5);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer32, 12, 14);
} catch {}
try {
buffer52.unmap();
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u04c1');
} catch {}
try {
device1.queue.submit([commandBuffer0]);
} catch {}
let pipeline6 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{format: 'rgba16float', writeMask: 0}],
},
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 6},
          {format: 'float16x2', offset: 0, shaderLocation: 1},
          {format: 'uint16x2', offset: 4, shaderLocation: 13},
          {format: 'sint8x2', offset: 8, shaderLocation: 12},
          {format: 'uint32x2', offset: 0, shaderLocation: 9},
          {format: 'float16x2', offset: 4, shaderLocation: 10},
          {format: 'float32x3', offset: 0, shaderLocation: 3},
          {format: 'float32x4', offset: 0, shaderLocation: 15},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 2},
          {format: 'unorm16x4', offset: 8, shaderLocation: 7},
          {format: 'sint32x3', offset: 0, shaderLocation: 5},
          {format: 'float32x4', offset: 0, shaderLocation: 4},
          {format: 'uint32x2', offset: 4, shaderLocation: 11},
          {format: 'sint8x4', offset: 4, shaderLocation: 8},
          {format: 'unorm16x4', offset: 4, shaderLocation: 0},
        ],
      },
      {arrayStride: 0, attributes: [{format: 'sint32x4', offset: 532, shaderLocation: 14}]},
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
let texture109 = device1.createTexture({
  size: {width: 408},
  dimension: '1d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture110 = device1.createTexture({
  size: {width: 39, height: 41, depthOrArrayLayers: 74},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
{ clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(4, 1); };
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer45, 1_788); };
} catch {}
try {
computePassEncoder22.setPipeline(pipeline2);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 25, height: 1, depthOrArrayLayers: 26}
*/
{
  source: offscreenCanvas1,
  origin: { x: 3, y: 211 },
  flipY: true,
}, {
  texture: texture58,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup9 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout14,
  entries: [
    {binding: 103, resource: externalTexture5},
    {binding: 30, resource: {buffer: buffer49, offset: 0, size: 56}},
    {binding: 13, resource: textureView51},
    {binding: 9, resource: textureView5},
    {binding: 1, resource: textureView6},
  ],
});
let renderPassEncoder2 = commandEncoder9.beginRenderPass({
  colorAttachments: [{view: textureView59, loadOp: 'load', storeOp: 'discard'}],
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 265},
});
try {
renderBundleEncoder3.setBindGroup(3, bindGroup6);
} catch {}
try {
commandEncoder14.clearBuffer(buffer3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 848, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture6,
  mipLevel: 2,
  origin: {x: 417, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline7 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}});
let canvas1 = document.createElement('canvas');
let buffer53 = device1.createBuffer({size: 428, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandBuffer1 = commandEncoder23.finish();
let textureView62 = texture103.createView({});
let textureView63 = texture45.createView({arrayLayerCount: 1});
try {
commandEncoder24.popDebugGroup();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
let recycledExplicitBindGroupLayout0 = pipeline7.getBindGroupLayout(0);
let textureView64 = texture19.createView({dimension: '2d'});
try {
computePassEncoder18.setPipeline(pipeline5);
} catch {}
try {
  await shaderModule7.getCompilationInfo();
} catch {}
try {
commandEncoder42.insertDebugMarker('\u8948');
} catch {}
try {
device0.queue.writeBuffer(buffer3, 12, new Float16Array(1762).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.3431)), 241, 4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 346, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(97).fill(14), /* required buffer size: 97 */
{offset: 97}, {width: 1109, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer54 = device0.createBuffer({size: 92, usage: GPUBufferUsage.INDEX});
let commandEncoder55 = device0.createCommandEncoder();
try {
computePassEncoder3.setPipeline(pipeline5);
} catch {}
try {
commandEncoder14.copyBufferToBuffer(buffer0, 4, buffer3, 12, 8);
} catch {}
try {
commandEncoder43.resolveQuerySet(querySet1, 223, 0, buffer1, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 180, new Uint16Array(30193).map((_, i) => i + 4), 5201, 204);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder56 = device0.createCommandEncoder({});
let texture111 = device0.createTexture({
  size: {width: 2},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
commandEncoder35.copyTextureToBuffer({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 224 */
  offset: 224,
  bytesPerRow: 10240,
  buffer: buffer46,
}, {width: 0, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder53.pushDebugGroup('\ua59e');
} catch {}
try {
commandEncoder53.popDebugGroup();
} catch {}
let shaderModule9 = device1.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

var<workgroup> vw22: i32;

struct VertexInput29 {
  @location(14) @interpolate(flat, sample) location_14: vec2i,
}

var<workgroup> vw23: atomic<i32>;

@group(3) @binding(98) var tex17: texture_2d<i32>;

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

struct VertexInput31 {
  @location(0) @interpolate(flat, first) location_0: u32,
}

override override24: f16 = 6808.3;

@id(27848) override override22 = true;

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

@id(64436) override override21 = 0.00812e-8;

@id(5349) override override23: u32;

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

@group(0) @binding(2) var<storage, read_write> buffer55: array<array<array<array<array<array<array<f16, 13>, 1>, 1>, 1>, 1>, 1>>;

struct T1 {
  f0: array<T0>,
}

@id(7569) override override18 = 0.2195;

struct FragmentOutput5 {
  @location(0) location_0: vec4u,
  @location(1) @interpolate(perspective) location_1: vec4f,
  @builtin(sample_mask) sample_mask: u32,
  @location(3) @interpolate(flat) location_3: vec2i,
  @location(4) @interpolate(flat) location_4: u32,
}

@id(38701) override override25: i32;

struct VertexInput30 {
  @location(2) @interpolate(flat) location_2: i32,
}

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

@group(2) @binding(1) var<storage, read_write> buffer59: T1;

struct VertexInput27 {
  @location(11) location_11: vec2i,
  @location(15) @interpolate(flat, center) location_15: vec4i,
  @location(10) location_10: vec4f,
}

override override19: i32;

struct VertexInput26 {
  @location(4) @interpolate(flat) location_4: vec2u,
  @builtin(vertex_index) vertex_index: u32,
}

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

@id(277) override override20: f16;

struct VertexInput28 {
  @location(8) @interpolate(flat) location_8: vec2f,
}

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

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

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

/* used global variables: tex17 */
@vertex
fn vertex5(@location(1) @interpolate(flat) location_1: vec2i, @location(13) location_13: vec4f, @location(3) @interpolate(linear) location_3: vec2h, @location(6) @interpolate(flat) location_6: vec2u, @location(5) @interpolate(flat, first) location_5: vec4i, @location(12) location_12: f32, a6: VertexInput26, a7: VertexInput27, a8: VertexInput28, @location(7) location_7: vec2f, a10: VertexInput29, a11: VertexInput30, @location(9) location_9: vec2u, a13: VertexInput31, @builtin(instance_index) instance_index: u32) -> @builtin(position) vec4f {
  var out: vec4f;
  var vf51: i32 = a11.location_2;
  out = vec4f(f32(a6.vertex_index));
  out = vec4f(bitcast<f32>(override19));
  let vf52: vec3f = cross(vec3f(unconst_f32(0.4783e-27), unconst_f32(0.02274e-45), unconst_f32(0.05888)), vec3f(unconst_f32(0.07328e23), unconst_f32(0.3637), unconst_f32(0.2058)));
  let vf53: vec2u = textureDimensions(tex17, unconst_i32(9080769));
  var vf54: f32 = out[unconst_u32(1747761166)];
  out = vec4f(location_6.rggr.xzzw.yywx.zwwz.bbaa);
  vf51 |= bitcast<i32>(dot(vec2u(unconst_u32(391615208), unconst_u32(588363071)), vec2u(unconst_u32(225391473), unconst_u32(279647885))));
  var vf55: f32 = override18;
  out = a7.location_10;
  let vf56: i32 = override19;
  var vf57: vec4f = a7.location_10;
  return out;
  _ = override18;
  _ = override19;
  _ = tex17;
}

/* used global variables: buffer55, buffer59 */
@fragment
fn fragment6(@builtin(position) position: vec4f, a1: FragmentInput10, a2: FragmentInput11) -> FragmentOutput5 {
  var out: FragmentOutput5;
  atomicCompareExchangeWeak(&buffer59.f0[u32(buffer55[arrayLength(&buffer55)][unconst_u32(1387946977)][unconst_u32(1132357614)][0][unconst_u32(1115309699)][0][unconst_u32(130536101)])].f0[u32((*&buffer55)[arrayLength(&(*&buffer55))][0][0][0][unconst_u32(268759485)][unconst_u32(1399846153)][12])][unconst_u32(1284196802)], unconst_i32(168913191), unconst_i32(8811784));
  let ptr41: ptr<storage, array<f16, 13>, read_write> = &buffer55[unconst_u32(1605491167)][0][0][unconst_u32(369261428)][0][unconst_u32(257292883)];
  for (var jj83=0u; jj83<3; jj83++) { buffer55[unconst_u32(141835753)][unconst_u32(153056707)][jj83][u32((*&buffer55)[arrayLength(&(*&buffer55))][0][u32((*&buffer55)[unconst_u32(372246688)][unconst_u32(208384818)][0][unconst_u32(558640983)][unconst_u32(10100056)][0][12])][unconst_u32(546112206)][0][0][12])][unconst_u32(1592451185)][unconst_u32(1324263618)][unconst_u32(137016334)] += (*&buffer55)[unconst_u32(358080265)][unconst_u32(136552830)][unconst_u32(2090570914)][0][0][0][12]; }
  out.sample_mask -= u32(atomicLoad(&(*&buffer59).f0[arrayLength(&(*&buffer59).f0)].f0[0][0]));
  let ptr42: ptr<storage, array<f16, 13>, read_write> = &buffer55[arrayLength(&buffer55)][0][0][0][unconst_u32(781082598)][0];
  let ptr43: ptr<storage, f16, read_write> = &buffer55[unconst_u32(68509761)][0][unconst_u32(125753025)][u32((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(292127309)][unconst_u32(2020607008)][unconst_u32(116882561)][0][0][unconst_u32(1262911248)])][0][0][12];
  let ptr44: ptr<storage, array<array<f16, 13>, 1>, read_write> = &(*&buffer55)[unconst_u32(105144855)][unconst_u32(1560059449)][unconst_u32(801679577)][0][0];
  let ptr45: ptr<storage, f16, read_write> = &buffer55[arrayLength(&buffer55)][unconst_u32(301273361)][unconst_u32(761288597)][0][unconst_u32(31249302)][u32(buffer55[unconst_u32(68994447)][unconst_u32(21794441)][0][unconst_u32(887393088)][unconst_u32(517407486)][0][12])][12];
  out.sample_mask = u32((*&buffer55)[unconst_u32(2030395982)][unconst_u32(870707674)][unconst_u32(631198539)][0][0][0][12]);
  out.location_3 &= vec2i(i32((*&buffer55)[arrayLength(&(*&buffer55))][0][unconst_u32(154616583)][unconst_u32(1752631702)][0][0][12]));
  let ptr46: ptr<storage, f16, read_write> = &buffer55[arrayLength(&buffer55)][0][unconst_u32(808610617)][unconst_u32(73983373)][0][0][12];
  return out;
  _ = buffer59;
  _ = buffer55;
}`,
});
let texture112 = device1.createTexture({
  size: [19, 20, 1785],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder24 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true});
try {
computePassEncoder13.setBindGroup(1, bindGroup0, new Uint32Array(4491), 755, 0);
} catch {}
try {
computePassEncoder14.end();
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(5, buffer32);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
textureView1.label = '\u71a1';
} catch {}
let bindGroup10 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout8,
  entries: [{binding: 1, resource: {buffer: buffer49, size: 68}}],
});
let renderPassEncoder3 = commandEncoder52.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 198.3, g: -101.7, b: -834.6, a: 91.90, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 534307039,
});
try {
computePassEncoder9.setBindGroup(3, bindGroup3, new Uint32Array(523), 121, 0);
} catch {}
try {
computePassEncoder4.setPipeline(pipeline5);
} catch {}
try {
computePassEncoder2.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer47, 'uint32', 8, 4);
} catch {}
let commandEncoder57 = device1.createCommandEncoder({});
let textureView65 = texture108.createView({});
let renderBundleEncoder25 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4});
try {
device1.queue.submit([commandBuffer1]);
} catch {}
let imageData6 = new ImageData(8, 84);
let commandEncoder58 = device0.createCommandEncoder({});
let renderPassEncoder4 = commandEncoder14.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: -558.0, g: -561.8, b: -818.9, a: 74.86, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 185},
  maxDrawCount: 171505427,
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(146), 3, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer47, 'uint16', 56, 28);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup9);
} catch {}
try {
gpuCanvasContext3.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, colorSpace: 'srgb'});
} catch {}
let gpuCanvasContext4 = canvas1.getContext('webgpu');
let commandEncoder59 = device1.createCommandEncoder({});
let texture113 = device1.createTexture({
  size: [51, 1, 2],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture114 = device1.createTexture({
  size: {width: 39},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let textureView66 = texture106.createView({mipLevelCount: 1});
try {
{ clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer51, 124); };
} catch {}
try {
computePassEncoder13.end();
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer53, 'uint16', 88, 94);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 8, new Uint32Array(767).map((_, i) => i * 3), 6, 24);
} catch {}
let texture115 = device0.createTexture({
  size: [3395],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float'],
});
let renderPassEncoder5 = commandEncoder47.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 50.60, g: -525.1, b: 844.8, a: 483.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 184562498,
});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({
  label: '\uc430\u5282\u06bf\uc6e9\u9000',
  colorFormats: ['rgba16float'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder16.setBindGroup(1, bindGroup5, new Uint32Array(1164), 19, 0);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(0, buffer2);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
buffer7.unmap();
} catch {}
let sampler8 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 91.79});
let texture116 = device0.createTexture({
  size: [1, 178, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder0.setPipeline(pipeline5);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer48, 'uint32', 16, 0);
} catch {}
let pipeline8 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule7, constants: {}}});
try {
renderBundleEncoder17.setBindGroup(2, bindGroup3);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 972, new Float32Array(7839).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.039)), 23, 64);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
await gc();
let shaderModule10 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

diagnostic(info, xyz);

struct FragmentInput13 {
  @location(10) @interpolate(perspective, centroid) location_10: vec2h,
  @location(11) @interpolate(linear, sample) location_11: vec2f,
  @location(2) location_2: vec4i,
  @location(12) location_12: vec2f,
  @location(6) location_6: vec4i,
  @location(15) location_15: vec2h,
  @location(14) location_14: f32,
  @location(0) location_0: vec4i,
  @location(8) location_8: f16,
}

struct VertexInput32 {
  @location(13) location_13: f32,
  @location(11) location_11: i32,
  @location(3) location_3: f32,
  @location(8) location_8: vec2f,
}

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

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

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

alias vec3b = vec3<bool>;

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

var<workgroup> vw24: atomic<i32>;

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

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

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

struct VertexOutput2 {
  @location(4) location_4: u32,
  @location(3) location_3: i32,
  @location(14) location_14: f32,
  @location(6) location_6: vec4i,
  @location(15) location_15: vec2h,
  @location(2) location_2: vec4i,
  @location(12) location_12: vec2f,
  @location(11) @interpolate(linear, sample) location_11: vec2f,
  @builtin(position) position: vec4f,
  @location(10) @interpolate(perspective, centroid) location_10: vec2h,
  @location(0) location_0: vec4i,
  @location(8) location_8: f16,
}

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

struct T0 {
  @size(576) f0: atomic<u32>,
}

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

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

/* zero global variables used */
@vertex
fn vertex6(a0: VertexInput32, @location(12) location_12: vec4u, @location(15) location_15: f16, @location(0) @interpolate(linear, sample) location_0: vec4h, @location(14) @interpolate(flat, sample) location_14: vec4u) -> VertexOutput2 {
  var out: VertexOutput2;
  out.location_14 += out.position[1];
  var vf58: f32 = out.position[unconst_u32(937826735)];
  out.position = vec4f(f32(out.location_2[unconst_u32(279634358)]));
  out.position -= vec4f(bitcast<f32>(out.location_4));
  out.location_14 = bitcast<f32>(out.location_15);
  if bool(extractBits(vec3i(unconst_i32(194370817), unconst_i32(246021025), unconst_i32(11719217)), unconst_u32(267052962), unconst_u32(40621883)).z) {
  let vf59: vec4f = tan(vec4f(unconst_f32(0.1085), unconst_f32(0.00639e-20), unconst_f32(-0.01841), unconst_f32(0.04689e5)));
  let ptr47: ptr<function, f16> = &out.location_8;
  let vf60: f16 = location_15;
  loop {
  var vf61: f32 = out.location_12[unconst_u32(27284939)];
  let vf62: vec2f = unpack2x16float(unconst_u32(646936541));
  return out;
  break;
}
}
  out.location_14 = out.position[0];
  var vf63: i32 = a0.location_11;
  let vf64: i32 = out.location_2[unconst_u32(70111836)];
  return out;
}

/* zero global variables used */
@fragment
fn fragment7(a0: FragmentInput12, @location(3) location_3: i32, a2: FragmentInput13, a3: FragmentInput14, @builtin(sample_mask) sample_mask: u32, a5: FragmentInput15, @builtin(sample_index) sample_index: u32) -> FragmentOutput6 {
  var out: FragmentOutput6;
  out.location_0 = unpack4x8snorm(a0.location_4);
  var vf65: FragmentInput12 = a0;
  out.location_0 = unpack4x8unorm(a0.location_4);
  out.sample_mask -= bitcast<u32>(unpack2x16float(unconst_u32(379869122))[0]);
  let ptr48: ptr<function, vec4f> = &out.location_0;
  var vf66: f32 = a2.location_12[unconst_u32(340415405)];
  var vf67: vec2h = a2.location_15;
  return out;
}

/* zero global variables used */
@fragment
fn fragment8(@builtin(sample_index) sample_index: u32, @builtin(sample_mask) sample_mask: u32, a2: FragmentInput16) -> @location(200) vec4f {
  var out: vec4f;
  out = log2((mat2x3f(unconst_f32(0.3465e25), unconst_f32(0.03872e-44), unconst_f32(0.04431), unconst_f32(0.03405e4), unconst_f32(0.08301e3), unconst_f32(-0.00989)) * vec2f(unconst_f32(0.02019), unconst_f32(0.06863e0)))).yzyy;
  let vf68: vec3u = extractBits(vec3u(acosh(vec3h(unconst_f16(10809.9), unconst_f16(3752.9), unconst_f16(15148.8)))), unconst_u32(624779808), unconst_u32(375244512));
  out -= vec4f(normalize(vec3h(unconst_f16(3936.9), unconst_f16(14506.7), unconst_f16(15781.2))).ggrb);
  var vf69: f16 = tan(unconst_f16(24057.0));
  let vf70: vec3f = (mat2x3f(unconst_f32(0.07790), unconst_f32(0.00417), unconst_f32(0.2774), unconst_f32(0.4550), unconst_f32(0.03947), unconst_f32(0.02034)) * vec2f(unconst_f32(0.1088), unconst_f32(0.08964)));
  var vf71: mat3x2f = (mat3x2f(trunc(vec3f(unconst_f32(0.03251), unconst_f32(0.08495e-27), unconst_f32(0.3000))).gb, trunc(vec3f(unconst_f32(0.03251), unconst_f32(0.08495e-27), unconst_f32(0.3000))).br, trunc(vec3f(unconst_f32(0.03251), unconst_f32(0.08495e-27), unconst_f32(0.3000))).br) * unconst_f32(0.3445e-26));
  out -= acos(vec4f(unconst_f32(0.1155e-6), unconst_f32(0.01189), unconst_f32(0.1280e5), unconst_f32(0.05458)));
  var vf72: u32 = sample_mask;
  return out;
}`,
});
let bindGroup11 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 13, resource: textureView51},
    {binding: 103, resource: externalTexture4},
    {binding: 30, resource: {buffer: buffer49, size: 84}},
    {binding: 1, resource: textureView6},
    {binding: 9, resource: textureView5},
  ],
});
let textureView67 = texture42.createView({});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true});
try {
computePassEncoder18.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer49, 'uint16', 126, 10);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer48, 'uint16', 4, 10);
} catch {}
let gpuCanvasContext5 = offscreenCanvas3.getContext('webgpu');
let commandEncoder60 = device0.createCommandEncoder({});
let textureView68 = texture7.createView({baseArrayLayer: 0, arrayLayerCount: 1});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: false, stencilReadOnly: true});
let sampler9 = device1.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'repeat', compare: 'equal'});
let texture117 = device1.createTexture({
  size: {width: 156, height: 164, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView69 = texture91.createView({dimension: 'cube', aspect: 'all', baseMipLevel: 0});
let computePassEncoder23 = commandEncoder22.beginComputePass();
try {
computePassEncoder16.setBindGroup(2, bindGroup0, new Uint32Array(1531), 10, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup2, new Uint32Array(180), 47, 0);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup1);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer53, 'uint16', 4, 141);
} catch {}
try {
buffer33.unmap();
} catch {}
let texture118 = device0.createTexture({
  size: [1, 178, 1],
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder24 = commandEncoder37.beginComputePass();
let renderPassEncoder6 = commandEncoder32.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: -971.6, g: 697.0, b: 743.2, a: -257.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderBundleEncoder7.setIndexBuffer(buffer54, 'uint16', 32, 0);
} catch {}
try {
renderPassEncoder6.insertDebugMarker('\u5015');
} catch {}
try {
device0.queue.writeBuffer(buffer46, 1_932, new Float32Array(65536).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.028)), 13374, 268);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 212, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture10,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout14,
  entries: [
    {binding: 9, resource: textureView5},
    {binding: 103, resource: externalTexture3},
    {binding: 13, resource: textureView51},
    {binding: 30, resource: {buffer: buffer49, size: 24}},
    {binding: 1, resource: textureView6},
  ],
});
let commandEncoder61 = device0.createCommandEncoder({});
let textureView70 = texture16.createView({mipLevelCount: 1});
let computePassEncoder25 = commandEncoder60.beginComputePass();
let sampler10 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.99,
  maxAnisotropy: 16,
});
try {
computePassEncoder24.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer8, 0);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline4);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
commandEncoder29.insertDebugMarker('\ua368');
} catch {}
try {
device0.queue.writeBuffer(buffer3, 4, new Uint32Array(16847).map((_, i) => i * 3), 1246, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 356, depthOrArrayLayers: 1}
*/
{
  source: videoFrame4,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture17,
  mipLevel: 0,
  origin: {x: 0, y: 51, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule11 = device0.createShaderModule({
  code: `
requires readonly_and_readwrite_storage_textures;

enable f16;

diagnostic(info, xyz);

struct T7 {
  f0: u32,
}

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

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

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

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

@group(0) @binding(0) var sam5: sampler;

struct T1 {
  f0: array<u32>,
}

var<workgroup> vw25: vec4<bool>;

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

struct T9 {
  f0: array<u32>,
}

var<private> vp4 = modf(vec3h(11621.4, -2291.0, 3541.6));

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

struct T8 {
  @size(44) f0: atomic<u32>,
}

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

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

struct T13 {
  @align(16) @size(64) f0: bool,
  f1: array<u32>,
}

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

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

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

struct T10 {
  @size(192) f0: mat4x2h,
  f1: array<u32>,
}

struct T5 {
  f0: array<f32>,
}

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

var<workgroup> vw26: atomic<i32>;

struct T12 {
  f0: vec4f,
}

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

/* used global variables: sam5 */
@compute @workgroup_size(2, 1, 1)
fn compute11(a0: ComputeInput18, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(global_invocation_id) global_invocation_id: vec3u, a3: ComputeInput19) {
  while bool(length(unconst_f16(13336.9))) {
  _ = sam5;
  var vf73: u32 = local_invocation_index;
  _ = sam5;
}
  var vf74: u32 = pack4xI8Clamp(vec4i(unconst_i32(687090126), unconst_i32(289151699), unconst_i32(417257785), unconst_i32(8619421)));
  let vf75: u32 = pack4xI8Clamp(vec4i(unconst_i32(-421976392), unconst_i32(142645894), unconst_i32(99613290), unconst_i32(358966676)));
  _ = sam5;
  vf74 += u32(unpack2x16float(bitcast<u32>(dot(vec2f(unconst_f32(0.1959e-21), unconst_f32(0.1462)), vec2f(unconst_f32(0.1158e-1), unconst_f32(0.2553)))))[1]);
  atomicMax(&vw26, unconst_i32(27173238));
  vf74 += bitcast<vec4u>(pow(vec4f(unconst_f32(0.03863), unconst_f32(0.02515), unconst_f32(0.04143), unconst_f32(0.01244)), bitcast<vec4f>(global_invocation_id.xzyx.rgrb.ggaa.zzzw.zzxz))).g;
  atomicXor(&vw26, unconst_i32(110600677));
  let vf76: u32 = global_invocation_id[unconst_u32(589977289)];
  vp4.whole = vec3h(unpack4xI8(unconst_u32(2462520503)).bgb);
  atomicSub(&vw26, unconst_i32(328016076));
  _ = sam5;
}`,
});
let autogeneratedBindGroupLayout4 = pipeline5.getBindGroupLayout(0);
let texture119 = device0.createTexture({size: [1697], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView71 = texture42.createView({dimension: '2d-array', arrayLayerCount: 1});
let computePassEncoder26 = commandEncoder42.beginComputePass({
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 77},
});
try {
computePassEncoder0.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer2);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer54, 'uint16', 28, 10);
} catch {}
let imageData7 = new ImageData(48, 20);
try {
adapter1.label = '\u90ac';
} catch {}
let textureView72 = texture98.createView({arrayLayerCount: 1});
try {
renderPassEncoder0.setPipeline(pipeline4);
} catch {}
let buffer61 = device1.createBuffer({size: 188, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let texture120 = device1.createTexture({
  size: {width: 39, height: 41, depthOrArrayLayers: 11},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture121 = device1.createTexture({
  size: [102, 1, 29],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder23.setPipeline(pipeline2);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 156, height: 164, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture46,
  mipLevel: 0,
  origin: {x: 18, y: 8, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup13 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 13, resource: textureView51},
    {binding: 1, resource: textureView6},
    {binding: 103, resource: externalTexture4},
    {binding: 30, resource: {buffer: buffer49, size: 120}},
    {binding: 9, resource: textureView5},
  ],
});
let commandEncoder62 = device0.createCommandEncoder();
let texture122 = device0.createTexture({
  size: [424, 1, 28],
  dimension: '2d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder17.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer10, 'uint32', 72, 62);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 1_348, new Uint32Array(15602).map((_, i) => i * 8), 1767, 208);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 178, depthOrArrayLayers: 1}
*/
{
  source: img0,
  origin: { x: 61, y: 1 },
  flipY: false,
}, {
  texture: texture94,
  mipLevel: 0,
  origin: {x: 0, y: 66, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout16 = device1.createBindGroupLayout({entries: [{binding: 93, visibility: GPUShaderStage.VERTEX, externalTexture: {}}]});
let bindGroup14 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout7,
  entries: [
    {binding: 2, resource: {buffer: buffer50, size: 36}},
    {binding: 0, resource: textureView19},
    {binding: 98, resource: textureView21},
  ],
});
let texture123 = device1.createTexture({
  size: [102, 1, 50],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
{ clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer51, 12); };
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device1.queue.writeBuffer(buffer30, 2_820, new Uint32Array(200).map((_, i) => i * 6), 20);
} catch {}
let buffer62 = device0.createBuffer({size: 96, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let textureView73 = texture31.createView({dimension: '2d-array', baseMipLevel: 0});
try {
computePassEncoder0.setBindGroup(0, bindGroup6, new Uint32Array(494), 78, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup13);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 2, 3);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(6, buffer2);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline4);
} catch {}
let buffer63 = device1.createBuffer({size: 340, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder63 = device1.createCommandEncoder({});
let texture124 = device1.createTexture({
  size: [156, 164, 232],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture125 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder27 = commandEncoder34.beginComputePass();
try {
{ clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder27.setPipeline(pipeline0);
} catch {}
let buffer64 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let texture126 = device0.createTexture({
  size: [3395, 1, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer0, 52); };
} catch {}
try {
computePassEncoder25.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup6, new Uint32Array(4819), 311, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup10, new Uint32Array(2952), 707, 0);
} catch {}
let shaderModule12 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

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

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

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

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

@group(0) @binding(0) var sam6: sampler;

struct ComputeInput20 {
  @builtin(local_invocation_id) local_invocation_id: vec3u,
  @builtin(local_invocation_index) local_invocation_index: u32,
}

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

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

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

struct T4 {
  f0: array<u32>,
}

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

var<private> vp7 = modf(vec3h(8965.6, 1759.8, -3037.8));

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

struct VertexOutput3 {
  @location(10) location_10: vec4f,
  @location(11) location_11: vec2u,
  @location(6) @interpolate(perspective, sample) location_6: vec2h,
  @location(12) @interpolate(flat, first) location_12: vec4u,
  @location(5) location_5: vec2f,
  @location(7) location_7: vec4f,
  @location(3) location_3: f32,
  @location(13) location_13: f16,
  @invariant @builtin(position) position: vec4f,
  @location(14) @interpolate(linear, first) location_14: vec2h,
  @location(1) @interpolate(flat, first) location_1: vec4u,
  @location(15) @interpolate(linear, centroid) location_15: vec2h,
  @location(2) @interpolate(flat, sample) location_2: vec4u,
}

var<private> vp6 = modf(f32(0.1639));

var<private> vp5 = array(array(frexp(f32(0.00479e-2))), array(frexp(f32(0.03467))), array(frexp(f32(0.07575e27))), array(frexp(f32(0.1013e24))), array(frexp(f32(0.1279))), array(frexp(f32(0.1588))));

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

struct VertexInput33 {
  @location(10) location_10: vec2h,
  @location(3) @interpolate(flat, either) location_3: vec2h,
  @location(4) location_4: vec4h,
  @location(9) @interpolate(linear) location_9: vec4h,
  @location(14) location_14: vec2i,
  @location(6) location_6: f16,
  @builtin(vertex_index) vertex_index: u32,
}

/* zero global variables used */
@vertex
fn vertex7(@location(5) @interpolate(flat, center) location_5: vec4i, @location(13) @interpolate(linear, centroid) location_13: vec4f, @location(15) location_15: f16, a3: VertexInput33, @location(12) @interpolate(flat) location_12: vec2h) -> VertexOutput3 {
  var out: VertexOutput3;
  for (var jj71=0u; jj71<8; jj71++) { vp5[jj71][unconst_u32(1560930348)].exp = bitcast<i32>(out.location_3); }
  let ptr49: ptr<private, f32> = &vp6.fract;
  let ptr50: ptr<function, vec2h> = &out.location_6;
  out.location_10 = ceil(vec2f(unconst_f32(0.04257e-40), unconst_f32(-0.00967e-27))).grgr;
  let ptr51 = &vp5[unconst_u32(1242715617)][0];
  return out;
}

/* zero global variables used */
@compute @workgroup_size(3, 3, 2)
fn compute12(a0: ComputeInput20) {
  vp7 = modf(vp7.whole);
  let ptr52: ptr<private, f32> = &vp6.fract;
  let ptr53 = &vp7;
  let ptr54: ptr<private, f32> = &(*ptr52);
  vp6 = modf(bitcast<f32>(normalize(vec2h(unconst_f16(14250.3), unconst_f16(28905.3)))));
}

/* used global variables: sam6 */
@compute @workgroup_size(1, 1, 1)
fn compute13(@builtin(num_workgroups) num_workgroups: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) {
  _ = sam6;
  var vf77: vec2h = degrees(vec2h(unconst_f16(4615.7), unconst_f16(16846.7)));
  var vf78: vec4h = min(vec4h(unconst_f16(15637.0), unconst_f16(1909.0), unconst_f16(12253.7), unconst_f16(8289.0)), vec4h(unconst_f16(15321.8), unconst_f16(9029.8), unconst_f16(13216.8), unconst_f16(21947.9)));
  let ptr55 = &vp5[5][0];
  switch bitcast<u32>(atan2(vec3f(unconst_f32(0.1066), unconst_f32(0.1791), unconst_f32(0.01225)), vec3f(unconst_f32(0.1606e-22), unconst_f32(0.1388), unconst_f32(0.4084))).x) { 
  default: {
  for (var it2=bitcast<u32>(vp6.whole); it2<(vec4u(firstLeadingBit(vec4i(unconst_i32(411864603), unconst_i32(29200405), unconst_i32(444770206), unconst_i32(87150095))).aaag.yxzz.xyyz).g & 0xfff); it2++) {
  {
  var vf79: vec4h = asin(vec4h(unconst_f16(2401.0), unconst_f16(7671.0), unconst_f16(13912.9), unconst_f16(1028.9)));
  vf79 = vec4h(f16(pack4xU8Clamp(vec4u(unconst_u32(736071130), unconst_u32(1242649513), unconst_u32(328762679), unconst_u32(110171862)))));
  vp5[unconst_u32(50569971)][unconst_u32(636406363)] = frexp(bitcast<f32>(reflect(vec2h(unconst_f16(13963.5), unconst_f16(7813.0)), vec2h(unconst_f16(14625.0), unconst_f16(18562.4)))));
}
  var vf80: vec3h = log(tanh(vec2h(unconst_f16(11908.5), unconst_f16(1876.3))).xxx);
  let vf81: vec2f = unpack2x16snorm(bitcast<vec3u>(select(vec3f(unconst_f32(0.1507e-23), unconst_f32(0.1179), unconst_f32(0.3091)), vec3f(unconst_f32(0.04094e-3), unconst_f32(0.3889), unconst_f32(0.1857e-38)), unconst_bool(true)))[2]);
  let ptr56: ptr<private, f32> = &vp5[unconst_u32(328390938)][unconst_u32(1449831696)].fract;
}
  var vf82: vec4i = select(vec4i(unconst_i32(-369632615), unconst_i32(864594465), unconst_i32(475211942), unconst_i32(466162178)), vec4i(unconst_i32(700592475), unconst_i32(1097629135), unconst_i32(-627733359), unconst_i32(544281451)), vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true), unconst_bool(false)));
  var vf83: vec4h = atanh(vec4h(f16(vp5[5][0].exp)));
  break;
}
  }
  vf77 = bitcast<vec2h>(vp5[unconst_u32(2600758278)][0].fract);
  let ptr57 = &vp7;
  var vf84: vec4f = mix(unpack4x8snorm(unconst_u32(1008385685)), vec4f(unconst_f32(-0.03742e-6), unconst_f32(0.1212e38), unconst_f32(0.06180), unconst_f32(0.2986e30)), vec4f(unconst_f32(0.2477e-3), unconst_f32(0.3274), unconst_f32(0.1153), unconst_f32(0.06934)));
  let ptr58: ptr<private, i32> = &vp5[5][0].exp;
  _ = sam6;
}

/* zero global variables used */
@compute @workgroup_size(1, 1, 1)
fn compute14(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) {
  let ptr59: ptr<private, vec3h> = &vp7.whole;
  var vf85: u32 = pack2x16float(vec2f(unconst_f32(0.01176e20), unconst_f32(0.00160e0)));
  vp6 = modf(vp6.fract);
  workgroupBarrier();
  vf85 >>= vec3u(cross(vec3f(unconst_f32(0.00881), unconst_f32(0.1728e-42), unconst_f32(0.2013e8)), vec3f(unconst_f32(0.1699), unconst_f32(0.1675), unconst_f32(0.2260))).bbb.yzy.brr).r;
  vp5[unconst_u32(325306806)][unconst_u32(382461390)].fract = bitcast<f32>(workgroup_id[unconst_u32(297617761)]);
}`,
});
let commandEncoder64 = device0.createCommandEncoder({});
let textureView74 = texture31.createView({dimension: '2d-array'});
try {
computePassEncoder24.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder17.setBindGroup(0, bindGroup6, new Uint32Array(1756), 136, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder26.setPipeline(pipeline5);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 3395, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 8 },
  flipY: true,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView75 = texture123.createView({arrayLayerCount: 1});
let texture127 = device1.createTexture({
  size: {width: 320, height: 1, depthOrArrayLayers: 168},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
try {
{ clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer5, 0); };
} catch {}
try {
computePassEncoder8.end();
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer22, 0, 9);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let videoFrame8 = new VideoFrame(offscreenCanvas3, {timestamp: 0});
let commandEncoder65 = device0.createCommandEncoder({});
let texture128 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 17},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView76 = texture84.createView({mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroupsIndirect(buffer7, 8); };
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup10, new Uint32Array(2195), 418, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer64, 'uint16', 2, 4);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline4);
} catch {}
let commandEncoder66 = device0.createCommandEncoder({});
try {
computePassEncoder0.setBindGroup(2, bindGroup5, new Uint32Array(501), 14, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer8, 1_120); };
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup6, new Uint32Array(389), 17, 0);
} catch {}
try {
renderPassEncoder6.setStencilReference(555);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup10, new Uint32Array(171), 38, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 1_856, new Float16Array(2700).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.847)), 529, 44);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 27}
*/
{
  source: videoFrame8,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture82,
  mipLevel: 0,
  origin: {x: 1, y: 13, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout17 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 24, hasDynamicOffset: false },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let textureView77 = texture113.createView({});
let texture129 = device1.createTexture({
  size: {width: 640, height: 1, depthOrArrayLayers: 14},
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
buffer13.unmap();
} catch {}
let commandEncoder67 = device1.createCommandEncoder({});
let renderPassEncoder7 = commandEncoder31.beginRenderPass({
  colorAttachments: [{
  view: textureView63,
  clearValue: { r: -662.2, g: 157.3, b: 48.12, a: -639.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let externalTexture8 = device1.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'});
try {
renderPassEncoder1.setIndexBuffer(buffer53, 'uint32', 8, 71);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer32, 4);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer53, 'uint16', 28, 27);
} catch {}
document.body.prepend(canvas1);
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470bg', transfer: 'bt2020_12bit'} });
try {
computePassEncoder16.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup0, new Uint32Array(1074), 106, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer53, 'uint32', 12, 80);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer21, 0, 21);
} catch {}
try {
computePassEncoder19.insertDebugMarker('\u5a16');
} catch {}
let bindGroup15 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout14,
  entries: [
    {binding: 103, resource: externalTexture1},
    {binding: 30, resource: {buffer: buffer62}},
    {binding: 13, resource: textureView51},
    {binding: 1, resource: textureView6},
    {binding: 9, resource: textureView5},
  ],
});
try {
renderBundleEncoder14.setBindGroup(0, bindGroup10);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 89, depthOrArrayLayers: 1}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture68,
  mipLevel: 4,
  origin: {x: 0, y: 15, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline9 = device0.createRenderPipeline({
  layout: pipelineLayout1,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule7,
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  vertex: {
    module: shaderModule10,
    constants: {},
    buffers: [
      {
        arrayStride: 16,
        attributes: [
          {format: 'float32x3', offset: 0, shaderLocation: 3},
          {format: 'unorm16x4', offset: 0, shaderLocation: 8},
          {format: 'sint16x2', offset: 4, shaderLocation: 11},
          {format: 'uint32', offset: 0, shaderLocation: 12},
          {format: 'snorm8x4', offset: 0, shaderLocation: 15},
          {format: 'float32x2', offset: 4, shaderLocation: 13},
          {format: 'float32x2', offset: 0, shaderLocation: 0},
          {format: 'uint16x4', offset: 0, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', unclippedDepth: true},
});
let commandEncoder68 = device0.createCommandEncoder();
let textureView78 = texture12.createView({dimension: '2d-array', format: 'astc-4x4-unorm', mipLevelCount: 1});
let externalTexture9 = device0.importExternalTexture({source: videoFrame8});
try {
renderPassEncoder5.setIndexBuffer(buffer4, 'uint32', 0, 44);
} catch {}
try {
buffer54.unmap();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup16 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 13, resource: textureView51},
    {binding: 30, resource: {buffer: buffer62}},
    {binding: 9, resource: textureView68},
    {binding: 103, resource: externalTexture4},
    {binding: 1, resource: textureView6},
  ],
});
let texture130 = device0.createTexture({
  size: {width: 848, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder18.setBindGroup(0, bindGroup15);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer8);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(7, buffer46, 564);
} catch {}
try {
commandEncoder29.copyBufferToBuffer(buffer7, 24, buffer3, 32, 0);
} catch {}
document.body.append(canvas1);
let buffer65 = device1.createBuffer({size: 144, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let texture131 = device1.createTexture({
  size: [102],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView79 = texture47.createView({dimension: '2d-array'});
try {
computePassEncoder20.setBindGroup(2, bindGroup0, new Uint32Array(840), 70, 0);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup2);
} catch {}
let texture132 = device1.createTexture({
  size: [102, 1, 67],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture133 = device1.createTexture({
  size: [408, 1, 65],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView80 = texture55.createView({aspect: 'all', mipLevelCount: 1});
try {
renderBundleEncoder9.setVertexBuffer(2, buffer33);
} catch {}
let veryExplicitBindGroupLayout18 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 294,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
    {binding: 354, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let buffer66 = device1.createBuffer({size: 85, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder69 = device1.createCommandEncoder({});
let texture134 = device1.createTexture({
  size: {width: 1280},
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder7.setBindGroup(3, bindGroup4);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup8);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(4, buffer33, 48, 1);
} catch {}
let buffer67 = device1.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder70 = device1.createCommandEncoder({});
let texture135 = device1.createTexture({
  size: {width: 320, height: 1, depthOrArrayLayers: 5},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder20.setBindGroup(1, bindGroup2, new Uint32Array(2321), 83, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(601), 108, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer53, 'uint16', 28, 16);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline6);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
try {
device1.queue.writeBuffer(buffer12, 52, new Uint32Array(16493).map((_, i) => i * 3), 7200, 0);
} catch {}
let buffer68 = device1.createBuffer({size: 216, usage: GPUBufferUsage.UNIFORM});
let texture136 = device1.createTexture({
  size: [320],
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView81 = texture134.createView({aspect: 'all'});
try {
renderPassEncoder1.setBlendConstant({ r: 387.2, g: -156.1, b: -440.1, a: -826.1, });
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer32, 'uint16', 4, 12);
} catch {}
let buffer69 = device1.createBuffer({size: 308, usage: GPUBufferUsage.UNIFORM});
let texture137 = device1.createTexture({
  size: [204],
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder7.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer32, 'uint32', 0, 78);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(6, buffer61, 0, 26);
} catch {}
let autogeneratedBindGroupLayout5 = pipeline6.getBindGroupLayout(2);
let bindGroup17 = device1.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 1, resource: {buffer: buffer50, size: 28}}],
});
let commandEncoder71 = device1.createCommandEncoder({});
let sampler11 = device1.createSampler({addressModeW: 'repeat', lodMaxClamp: 84.77, compare: 'always'});
let textureView82 = texture131.createView({dimension: '1d'});
let renderPassEncoder8 = commandEncoder70.beginRenderPass({
  colorAttachments: [{
  view: textureView80,
  clearValue: { r: -158.6, g: -634.8, b: 439.6, a: 900.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 45752878,
});
try {
renderPassEncoder8.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer22, 0, 7);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup4);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer53, 'uint32', 272, 22);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(1, buffer33, 24);
} catch {}
try {
gpuCanvasContext5.configure({device: device1, format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture114,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(175).fill(51), /* required buffer size: 175 */
{offset: 175, bytesPerRow: 70, rowsPerImage: 43}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline10 = await device1.createComputePipelineAsync({label: '\u81cb\u{1fa24}\u1e5f\u7eb3', layout: 'auto', compute: {module: shaderModule6}});
try {
renderBundleEncoder3.setBindGroup(1, bindGroup9);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 27}
*/
{
  source: offscreenCanvas3,
  origin: { x: 9, y: 0 },
  flipY: true,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 7, y: 2, z: 8},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 5, depthOrArrayLayers: 0});
} catch {}
let commandEncoder72 = device0.createCommandEncoder({});
let textureView83 = texture20.createView({dimension: '2d', mipLevelCount: 1, arrayLayerCount: 1});
try {
renderBundleEncoder16.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(7, buffer8);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 4, new DataView(new ArrayBuffer(71836)), 408, 0);
} catch {}
try {
adapter0.label = '\u{1fcf8}\u0aa1';
} catch {}
let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let buffer70 = device0.createBuffer({size: 120, usage: GPUBufferUsage.QUERY_RESOLVE});
let texture138 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 27},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder28 = commandEncoder19.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer0, 68); };
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer10, 'uint16', 104, 342);
} catch {}
try {
renderBundleEncoder14.setPipeline(pipeline4);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let buffer71 = device0.createBuffer({size: 14144, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint']});
try {
computePassEncoder17.end();
} catch {}
try {
computePassEncoder28.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(1, buffer46, 0, 229);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup10);
} catch {}
try {
computePassEncoder24.pushDebugGroup('\u4113');
} catch {}
let commandBuffer2 = commandEncoder20.finish();
let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder28.setBindGroup(0, bindGroup10, new Uint32Array(2300), 746, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer48, 'uint16', 6, 1);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer2);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 0, new Uint16Array(18036).map((_, i) => i + 3), 1485, 4);
} catch {}
let pipeline11 = device0.createRenderPipeline({
  layout: pipelineLayout4,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule8,
  constants: {override17: 1, override16: 1},
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'constant'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule7,
    constants: {},
    buffers: [
      {
        arrayStride: 632,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 388, shaderLocation: 0},
          {format: 'uint32x4', offset: 96, shaderLocation: 8},
          {format: 'sint32x4', offset: 52, shaderLocation: 11},
          {format: 'sint32x3', offset: 24, shaderLocation: 13},
          {format: 'sint32', offset: 92, shaderLocation: 2},
          {format: 'uint32x4', offset: 112, shaderLocation: 3},
          {format: 'snorm8x4', offset: 36, shaderLocation: 12},
          {format: 'sint8x2', offset: 2, shaderLocation: 4},
          {format: 'float32x2', offset: 48, shaderLocation: 9},
          {format: 'snorm8x2', offset: 28, shaderLocation: 6},
          {format: 'uint8x4', offset: 8, shaderLocation: 10},
          {format: 'float32x2', offset: 64, shaderLocation: 7},
          {format: 'uint32x3', offset: 196, shaderLocation: 5},
          {format: 'float16x2', offset: 56, shaderLocation: 14},
          {format: 'float32x2', offset: 40, shaderLocation: 15},
        ],
      },
      {arrayStride: 12, attributes: [{format: 'unorm8x2', offset: 0, shaderLocation: 1}]},
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let canvas2 = document.createElement('canvas');
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpteSt4281', transfer: 'bt1361ExtendedColourGamut'} });
let commandEncoder73 = device1.createCommandEncoder({});
let textureView84 = texture135.createView({dimension: '2d-array', arrayLayerCount: 2});
let textureView85 = texture28.createView({aspect: 'stencil-only', mipLevelCount: 1});
try {
renderBundleEncoder4.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup18 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout3,
  entries: [
    {binding: 0, resource: textureView19},
    {binding: 2, resource: {buffer: buffer50, size: 32}},
    {binding: 98, resource: textureView36},
  ],
});
let commandEncoder74 = device1.createCommandEncoder({});
let commandBuffer3 = commandEncoder12.finish();
let texture139 = device1.createTexture({
  size: {width: 204},
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder21.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup14, new Uint32Array(460), 59, 1);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup18, new Uint32Array(405), 89, 1);
} catch {}
let commandEncoder75 = device0.createCommandEncoder({});
let texture140 = device0.createTexture({size: [4], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
let computePassEncoder29 = commandEncoder35.beginComputePass();
try {
computePassEncoder3.setBindGroup(0, bindGroup13, new Uint32Array(1952), 37, 0);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup7, new Uint32Array(3725), 211, 0);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer8, 1_848);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer47, 'uint16', 44, 25);
} catch {}
try {
computePassEncoder24.popDebugGroup();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
adapter1.label = '\ubb9d\u050e\ubc91\u54e1\u{1ffa9}\u0f52\u7879\u{1facb}\u033b\u2082';
} catch {}
let buffer72 = device0.createBuffer({size: 109, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let commandEncoder76 = device0.createCommandEncoder({});
let texture141 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView86 = texture116.createView({arrayLayerCount: 1});
let renderPassEncoder9 = commandEncoder7.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 41.16, g: -691.7, b: -661.6, a: -90.13, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder29.setBindGroup(0, bindGroup6, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer49, 16); };
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer7, 8);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder2.setBindGroup(3, bindGroup12, new Uint32Array(428), 36, 0);
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt709', transfer: 'hlg'} });
let texture142 = device1.createTexture({
  size: {width: 19},
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder23.setBindGroup(0, bindGroup14, [0]);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline3);
} catch {}
let commandEncoder77 = device1.createCommandEncoder({});
let texture143 = device1.createTexture({
  size: [408, 1, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView87 = texture64.createView({});
let renderPassEncoder10 = commandEncoder15.beginRenderPass({colorAttachments: [{view: textureView57, loadOp: 'load', storeOp: 'store'}]});
try {
renderPassEncoder7.setBindGroup(1, bindGroup14, new Uint32Array(253), 3, 1);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer53, 'uint16', 4, 28);
} catch {}
let textureView88 = texture139.createView({arrayLayerCount: 1});
try {
computePassEncoder22.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(1, buffer22, 48);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 1, depthOrArrayLayers: 26}
*/
{
  source: imageBitmap0,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture58,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder78 = device0.createCommandEncoder({});
let textureView89 = texture31.createView({baseArrayLayer: 0, arrayLayerCount: 1});
let texture144 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 31},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView90 = texture98.createView({format: 'rgba16float', baseMipLevel: 0});
let renderBundleEncoder32 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
let sampler12 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMaxClamp: 67.59,
  compare: 'not-equal',
});
try {
renderPassEncoder5.draw(76, 2, 360_236_804, 0);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer0, 12);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline9);
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
let buffer73 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder79 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer0, 16); };
} catch {}
try {
renderPassEncoder5.draw(25, 1, 550_341_867);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup16);
} catch {}
let gpuCanvasContext6 = canvas2.getContext('webgpu');
try {
gpuCanvasContext5.unconfigure();
} catch {}
try {
externalTexture5.label = '\ucef2\uaad4\u7fed';
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup10, []);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer73, 0);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer0, 12);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer10, 'uint16', 238, 16);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer73, 'uint32', 0, 11);
} catch {}
let textureView91 = texture137.createView({});
let textureView92 = texture56.createView({aspect: 'all'});
try {
{ clearResourceUsages(device1, computePassEncoder21); computePassEncoder21.dispatchWorkgroupsIndirect(buffer51, 52); };
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup8, new Uint32Array(1647), 3, 0);
} catch {}
try {
renderBundleEncoder25.setBindGroup(0, bindGroup8);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(4, buffer31, 0);
} catch {}
try {
commandEncoder10.copyBufferToBuffer(buffer63, 52, buffer30, 508, 20);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder80 = device0.createCommandEncoder();
let texture145 = device0.createTexture({
  size: {width: 848},
  dimension: '1d',
  format: 'rgb9e5ufloat',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer49, 32); };
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer8, 1_112);
} catch {}
try {
renderBundleEncoder29.setBindGroup(3, bindGroup5, new Uint32Array(1110), 10, 0);
} catch {}
try {
commandEncoder78.resolveQuerySet(querySet1, 26, 2, buffer70, 0);
} catch {}
try {
computePassEncoder25.setBindGroup(2, bindGroup9, new Uint32Array(738), 488, 0);
} catch {}
try {
renderPassEncoder5.draw(198, 1, 469_120_374);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer46, 4, 353);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 80}
*/
{
  source: imageData6,
  origin: { x: 6, y: 18 },
  flipY: false,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 21},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer74 = device1.createBuffer({label: '', size: 9189, usage: GPUBufferUsage.STORAGE});
let commandEncoder81 = device1.createCommandEncoder({});
let textureView93 = texture143.createView({});
try {
renderBundleEncoder6.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder11.insertDebugMarker('\u1dc5');
} catch {}
try {
gpuCanvasContext4.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 156, height: 164, depthOrArrayLayers: 1}
*/
{
  source: videoFrame9,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture46,
  mipLevel: 0,
  origin: {x: 8, y: 51, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout6 = pipeline6.getBindGroupLayout(0);
let commandEncoder82 = device1.createCommandEncoder({});
let texture146 = device1.createTexture({
  size: [78, 82, 24],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView94 = texture131.createView({arrayLayerCount: 1});
let renderPassEncoder11 = commandEncoder59.beginRenderPass({
  colorAttachments: [{
  view: textureView57,
  clearValue: { r: -601.8, g: -587.3, b: 822.8, a: -376.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let externalTexture10 = device1.importExternalTexture({source: videoFrame7});
try {
computePassEncoder27.setBindGroup(1, bindGroup0, new Uint32Array(1991), 1_270, 0);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder21); computePassEncoder21.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline1);
} catch {}
let commandEncoder83 = device0.createCommandEncoder();
let texture147 = device0.createTexture({
  size: [1697, 1, 1],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderBundleEncoder33 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder4.setBindGroup(3, bindGroup6, new Uint32Array(2883), 874, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer47, 60); };
} catch {}
try {
renderPassEncoder5.draw(216, 1, 138_925_089, 1);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer8, 812);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer73, 'uint32', 0, 4);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let bindGroup19 = device1.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 0, resource: textureView25}]});
let buffer75 = device1.createBuffer({size: 48, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture148 = device1.createTexture({
  size: {width: 640, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView95 = texture89.createView({});
let computePassEncoder30 = commandEncoder63.beginComputePass();
try {
renderBundleEncoder19.setVertexBuffer(2, buffer61, 0);
} catch {}
document.body.prepend(canvas1);
let bindGroup20 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 1, resource: {buffer: buffer71}}]});
let commandEncoder84 = device0.createCommandEncoder({});
let computePassEncoder31 = commandEncoder66.beginComputePass();
try {
renderPassEncoder5.draw(41, 1, 427_920_441);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer47, 4);
} catch {}
try {
buffer73.unmap();
} catch {}
let buffer76 = device0.createBuffer({size: 435, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder85 = device0.createCommandEncoder();
try {
renderPassEncoder4.setIndexBuffer(buffer48, 'uint32', 0, 16);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
computePassEncoder29.setBindGroup(2, bindGroup5, new Uint32Array(407), 89, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(2); };
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer9, 'uint32', 0, 5);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(1, buffer46);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer77 = device1.createBuffer({
  size: 8352,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder86 = device1.createCommandEncoder({});
let renderPassEncoder12 = commandEncoder74.beginRenderPass({
  colorAttachments: [{
  view: textureView80,
  clearValue: { r: -65.05, g: 722.3, b: 265.7, a: 563.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder16.setBindGroup(2, bindGroup19, new Uint32Array(619), 81, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer22, 140, 22);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer32, 'uint32', 4, 19);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(7, buffer32, 0, 34);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let bindGroup21 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 0, resource: textureView25},
    {binding: 98, resource: textureView13},
    {binding: 2, resource: {buffer: buffer74, size: 208}},
  ],
});
let commandBuffer4 = commandEncoder16.finish({});
let texture149 = device1.createTexture({
  size: [51],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder32 = commandEncoder28.beginComputePass();
try {
computePassEncoder30.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup0);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer32, 'uint16', 38, 8);
} catch {}
try {
commandEncoder8.copyTextureToBuffer({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 19, y: 16, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4368 */
  offset: 4368,
  bytesPerRow: 768,
  buffer: buffer30,
}, {width: 3, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder86.insertDebugMarker('\u9d1f');
} catch {}
let pipeline12 = await device1.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x7a3c2a08},
  fragment: {
  module: shaderModule1,
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 1084, shaderLocation: 8},
          {format: 'unorm16x2', offset: 140, shaderLocation: 0},
          {format: 'unorm16x2', offset: 320, shaderLocation: 10},
          {format: 'unorm16x2', offset: 744, shaderLocation: 2},
          {format: 'sint32', offset: 116, shaderLocation: 14},
          {format: 'snorm8x4', offset: 164, shaderLocation: 4},
          {format: 'sint32x2', offset: 136, shaderLocation: 12},
          {format: 'uint32x2', offset: 172, shaderLocation: 9},
          {format: 'sint16x2', offset: 576, shaderLocation: 5},
          {format: 'sint32x4', offset: 488, shaderLocation: 6},
          {format: 'float32x2', offset: 524, shaderLocation: 7},
          {format: 'uint32x3', offset: 776, shaderLocation: 11},
          {format: 'float16x4', offset: 12, shaderLocation: 3},
          {format: 'float32x2', offset: 16, shaderLocation: 1},
          {format: 'uint32', offset: 1712, shaderLocation: 13},
        ],
      },
      {arrayStride: 20, attributes: [{format: 'float32', offset: 0, shaderLocation: 15}]},
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16'},
});
let texture150 = device0.createTexture({
  label: '\u{1fed8}\u{1fa6e}',
  size: [3395, 1, 132],
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView96 = texture31.createView({
  label: '\u5ffa\ubd30\u3815\u0f8a\u{1fd31}\u5a52\uc8f6',
  dimension: '2d-array',
  mipLevelCount: 1,
  arrayLayerCount: 1,
});
try {
computePassEncoder31.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder5.draw(159, 1, 70_501_981);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer47, 0);
} catch {}
try {
commandEncoder53.copyBufferToTexture({
  /* bytesInLastRow: 952 widthInBlocks: 119 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 32 */
  offset: 32,
  buffer: buffer48,
}, {
  texture: texture33,
  mipLevel: 1,
  origin: {x: 28, y: 0, z: 5},
  aspect: 'all',
}, {width: 119, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer3, 12, new Float16Array(15707).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.609)), 1340, 4);
} catch {}
document.body.append(img0);
let veryExplicitBindGroupLayout20 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true },
    },
    {
      binding: 98,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let computePassEncoder33 = commandEncoder86.beginComputePass();
try {
computePassEncoder27.setBindGroup(1, bindGroup19, new Uint32Array(160), 7, 0);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder10.setBindGroup(3, bindGroup1);
} catch {}
try {
commandEncoder45.resolveQuerySet(querySet0, 27, 1, buffer50, 0);
} catch {}
try {
device1.queue.submit([commandBuffer4]);
} catch {}
let buffer78 = device0.createBuffer({size: 304, usage: GPUBufferUsage.INDEX});
let commandEncoder87 = device0.createCommandEncoder({label: '\u9b2a\u07a7\u0df4\u06c6\ub7bb'});
try {
computePassEncoder24.setBindGroup(2, bindGroup20);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline11);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'unspecified'} });
let texture151 = device1.createTexture({
  size: {width: 1280, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder20.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder23.setBindGroup(2, bindGroup8, new Uint32Array(116), 5, 0);
} catch {}
try {
computePassEncoder21.end();
} catch {}
try {
computePassEncoder33.setPipeline(pipeline2);
} catch {}
await gc();
let texture152 = device0.createTexture({
  size: [424, 1, 32],
  mipLevelCount: 2,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder34 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true});
let sampler13 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 79.58,
  maxAnisotropy: 8,
});
try {
renderPassEncoder5.setBindGroup(0, bindGroup3, new Uint32Array(1237), 687, 0);
} catch {}
try {
renderPassEncoder5.draw(7, 1, 148_272_374);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline11);
} catch {}
let buffer79 = device0.createBuffer({
  size: 280,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture153 = device0.createTexture({size: [2], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC});
let externalTexture11 = device0.importExternalTexture({source: videoFrame5});
try {
computePassEncoder24.setBindGroup(2, bindGroup7);
} catch {}
try {
computePassEncoder1.setBindGroup(3, bindGroup11, new Uint32Array(3311), 340, 0);
} catch {}
try {
computePassEncoder0.end();
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup20);
} catch {}
try {
buffer10.unmap();
} catch {}
let veryExplicitBindGroupLayout21 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 294,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
    {binding: 354, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let bindGroup22 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [{binding: 294, resource: textureView79}, {binding: 354, resource: externalTexture10}],
});
let commandEncoder88 = device1.createCommandEncoder();
let renderPassEncoder13 = commandEncoder54.beginRenderPass({
  colorAttachments: [{
  view: textureView57,
  clearValue: { r: -859.5, g: -313.6, b: -174.2, a: -360.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
});
let externalTexture12 = device1.importExternalTexture({source: videoFrame8});
try {
renderPassEncoder12.setIndexBuffer(buffer32, 'uint32', 8, 8);
} catch {}
let buffer80 = device0.createBuffer({size: 220, usage: GPUBufferUsage.STORAGE});
let commandEncoder89 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(3, bindGroup16);
} catch {}
try {
computePassEncoder2.setBindGroup(0, bindGroup6, new Uint32Array(135), 28, 0);
} catch {}
try {
renderPassEncoder5.draw(67, 1, 781_023_480, 1);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline11);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 20, new DataView(new ArrayBuffer(15993)), 635, 8);
} catch {}
document.body.prepend(img0);
let veryExplicitBindGroupLayout22 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 3, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {binding: 4, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 7,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 14,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 39,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 78,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 124, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 160,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 161,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '2d-array' },
    },
    {binding: 185, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 236,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 495,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let commandEncoder90 = device1.createCommandEncoder();
let commandBuffer5 = commandEncoder18.finish();
try {
renderPassEncoder12.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(2, buffer33);
} catch {}
try {
commandEncoder40.resolveQuerySet(querySet0, 30, 1, buffer50, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer23, 16, new BigInt64Array(282).map((_, i) => BigInt(i - 9)), 4, 0);
} catch {}
let promise4 = device1.queue.onSubmittedWorkDone();
await gc();
let commandBuffer6 = commandEncoder10.finish();
let renderBundleEncoder35 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], stencilReadOnly: true});
try {
renderPassEncoder8.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer53, 'uint32', 148, 36);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline1);
} catch {}
try {
device1.queue.submit([commandBuffer5]);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 39, height: 41, depthOrArrayLayers: 1}
*/
{
  source: imageData5,
  origin: { x: 4, y: 0 },
  flipY: false,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 0, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 4, height: 14, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout23 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true },
    },
    {
      binding: 98,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer81 = device1.createBuffer({size: 96, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let commandEncoder91 = device1.createCommandEncoder();
try {
renderPassEncoder11.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer33, 12);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup8, new Uint32Array(1183), 296, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer53, 'uint16', 44, 200);
} catch {}
let pipeline13 = await device1.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {module: shaderModule6, constants: {}, targets: [{format: 'rgba16float'}]},
  vertex: {
    module: shaderModule6,
    constants: {},
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 148, shaderLocation: 6},
          {format: 'snorm8x2', offset: 34, shaderLocation: 14},
          {format: 'sint16x4', offset: 244, shaderLocation: 3},
          {format: 'uint32', offset: 312, shaderLocation: 10},
          {format: 'sint16x4', offset: 328, shaderLocation: 7},
          {format: 'unorm10-10-10-2', offset: 40, shaderLocation: 13},
          {format: 'uint32x3', offset: 236, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 144,
        attributes: [
          {format: 'unorm16x2', offset: 4, shaderLocation: 2},
          {format: 'uint16x4', offset: 0, shaderLocation: 1},
          {format: 'uint16x4', offset: 28, shaderLocation: 0},
          {format: 'sint8x2', offset: 4, shaderLocation: 9},
          {format: 'float32x3', offset: 16, shaderLocation: 11},
          {format: 'sint32x3', offset: 16, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw'},
});
try {
computePassEncoder32.setBindGroup(1, bindGroup2, []);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer50, 0, 12);
} catch {}
try {
device1.queue.submit([commandBuffer6, commandBuffer3]);
} catch {}
let buffer82 = device0.createBuffer({size: 8, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture154 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 9},
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderPassEncoder0.setBindGroup(1, bindGroup13);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer8, 1_000);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(2, buffer79);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup20);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(0, buffer8, 0, 334);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 0, new DataView(new ArrayBuffer(25376)), 596, 4);
} catch {}
let buffer83 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture155 = device0.createTexture({
  size: [1697],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer73, 8);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer8, 10_948);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer2, 0, 55);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline11);
} catch {}
try {
commandEncoder43.copyBufferToBuffer(buffer62, 0, buffer73, 8, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer72, 12, new BigInt64Array(2585).map((_, i) => BigInt(i - 6)), 425, 0);
} catch {}
let commandEncoder92 = device1.createCommandEncoder({});
let textureView97 = texture59.createView({});
let renderPassEncoder14 = commandEncoder88.beginRenderPass({
  colorAttachments: [{
  view: textureView63,
  clearValue: { r: 303.3, g: 393.8, b: 844.6, a: 744.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
document.body.append(img0);
let commandBuffer7 = commandEncoder8.finish({});
let computePassEncoder34 = commandEncoder69.beginComputePass();
try {
computePassEncoder34.setPipeline(pipeline10);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 156, height: 164, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture46,
  mipLevel: 0,
  origin: {x: 80, y: 53, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView98 = texture70.createView({});
let texture156 = device1.createTexture({
  size: {width: 320, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rg32float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(2854), 53, 0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer32, 0);
} catch {}
await gc();
let textureView99 = texture74.createView({aspect: 'all'});
try {
renderPassEncoder5.drawIndirect(buffer0, 28);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer2, 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 1_660, new Uint32Array(13918).map((_, i) => i * 9), 317, 136);
} catch {}
try {
  await promise4;
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'smpte170m'} });
let commandEncoder93 = device1.createCommandEncoder({});
let textureView100 = texture113.createView({format: 'r32uint'});
try {
renderPassEncoder11.setBindGroup(2, bindGroup14, new Uint32Array(476), 75, 1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer61, 8);
} catch {}
try {
renderBundleEncoder11.setBindGroup(0, bindGroup1);
} catch {}
document.body.prepend(img1);
let videoFrame14 = videoFrame1.clone();
let texture157 = device0.createTexture({size: [16, 16, 27], format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
try {
renderPassEncoder5.drawIndirect(buffer0, 8);
} catch {}
try {
renderBundleEncoder26.setIndexBuffer(buffer4, 'uint32', 0, 2);
} catch {}
let pipeline14 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, constants: {}}});
let texture158 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 27},
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder36 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 1});
try {
renderPassEncoder5.draw(324, 1, 950_937_359);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer47, 'uint16', 4, 27);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup3, []);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
offscreenCanvas3.width = 717;
let buffer84 = device1.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView101 = texture112.createView({format: 'r32uint', arrayLayerCount: 1});
let renderPassEncoder15 = commandEncoder73.beginRenderPass({colorAttachments: [{view: textureView63, loadOp: 'clear', storeOp: 'store'}]});
try {
renderPassEncoder7.setIndexBuffer(buffer53, 'uint16', 64, 108);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer53, 'uint16', 46, 92);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(7, buffer21);
} catch {}
try {
commandEncoder82.clearBuffer(buffer12);
} catch {}
try {
device1.queue.submit([commandBuffer7]);
} catch {}
let pipeline15 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}});
let computePassEncoder35 = commandEncoder40.beginComputePass();
try {
computePassEncoder19.setBindGroup(0, bindGroup21, [768]);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline6);
} catch {}
try {
device1.queue.writeBuffer(buffer30, 2_340, new Uint32Array(931).map((_, i) => i * 10));
} catch {}
let promise5 = device1.queue.onSubmittedWorkDone();
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'jedecP22Phosphors', transfer: 'smpteSt4281'} });
let veryExplicitBindGroupLayout24 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 18,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let buffer85 = device1.createBuffer({size: 142, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder94 = device1.createCommandEncoder({});
let textureView102 = texture45.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
let renderPassEncoder16 = commandEncoder93.beginRenderPass({
  colorAttachments: [{
  view: textureView63,
  clearValue: { r: 14.87, g: -361.9, b: 160.6, a: -972.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder35.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(70);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup4, new Uint32Array(5107), 741, 0);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'display-p3',
});
} catch {}
try {
device1.queue.writeBuffer(buffer23, 0, new Float32Array(9585).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.1660)), 624, 0);
} catch {}
let bindGroup23 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 1, resource: {buffer: buffer80}}]});
let commandEncoder95 = device0.createCommandEncoder({label: '\u297b\u07c1\u1834\u41b6\uf74b\u{1fa45}\u{1fa08}\u0279\ub288\u591f'});
try {
renderPassEncoder4.setPipeline(pipeline11);
} catch {}
try {
  await promise5;
} catch {}
await gc();
let bindGroup24 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: {buffer: buffer80, size: 76}}],
});
let texture159 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder32.setVertexBuffer(5, buffer8, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer82, 4, new Uint32Array(2916).map((_, i) => i * 8), 485, 0);
} catch {}
let buffer86 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let commandBuffer8 = commandEncoder1.finish();
let texture160 = device0.createTexture({
  size: [110, 790, 1],
  format: 'astc-10x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(2, 2); };
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer8, 0);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline3);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
try {
computePassEncoder16.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup18, [0]);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer32, 'uint16', 0, 15);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(1, buffer85, 0, 7);
} catch {}
try {
commandEncoder24.resolveQuerySet(querySet0, 80, 2, buffer85, 0);
} catch {}
let bindGroup25 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout14,
  entries: [
    {binding: 9, resource: textureView68},
    {binding: 13, resource: textureView51},
    {binding: 30, resource: {buffer: buffer62}},
    {binding: 103, resource: externalTexture9},
    {binding: 1, resource: textureView6},
  ],
});
let buffer87 = device0.createBuffer({size: 812, usage: GPUBufferUsage.VERTEX});
try {
renderPassEncoder5.setBindGroup(0, bindGroup3);
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'film', transfer: 'bt1361ExtendedColourGamut'} });
let texture161 = device0.createTexture({
  size: [16, 16, 27],
  format: 'r8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView103 = texture51.createView({dimension: '2d-array'});
try {
renderPassEncoder5.drawIndexedIndirect(buffer8, 480);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer73, 'uint32', 0, 63);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup26 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 0, resource: sampler1}]});
let textureView104 = texture86.createView({dimension: 'cube-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 12});
try {
commandEncoder58.resolveQuerySet(querySet1, 34, 35, buffer71, 0);
} catch {}
try {
device0.queue.submit([commandBuffer8]);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 12, new DataView(new ArrayBuffer(17928)), 52, 0);
} catch {}
let buffer88 = device1.createBuffer({size: 120, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let textureView105 = texture112.createView({aspect: 'all', baseMipLevel: 0});
let promise6 = device1.queue.onSubmittedWorkDone();
try {
  await promise6;
} catch {}
let bindGroup27 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 62, resource: textureView18},
    {binding: 31, resource: externalTexture7},
    {binding: 138, resource: sampler3},
    {binding: 0, resource: sampler11},
    {binding: 1, resource: textureView62},
    {binding: 120, resource: textureView65},
    {binding: 16, resource: sampler7},
    {binding: 2, resource: textureView100},
  ],
});
let commandEncoder96 = device1.createCommandEncoder({});
try {
renderPassEncoder12.beginOcclusionQuery(199);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(1, buffer22, 4);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup14, new Uint32Array(3133), 485, 1);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture29,
  mipLevel: 1,
  origin: {x: 2, y: 35, z: 0},
  aspect: 'all',
}, new Uint8Array(2_271).fill(105), /* required buffer size: 2_271 */
{offset: 47, bytesPerRow: 92, rowsPerImage: 9}, {width: 4, height: 7, depthOrArrayLayers: 3});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 156, height: 164, depthOrArrayLayers: 1}
*/
{
  source: videoFrame10,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture46,
  mipLevel: 0,
  origin: {x: 7, y: 23, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout1 = pipeline4.getBindGroupLayout(0);
let bindGroup28 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 1, resource: {buffer: buffer86}}]});
let textureView106 = texture161.createView({dimension: '2d', format: 'r8uint', baseArrayLayer: 2});
try {
computePassEncoder6.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer8, 712);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer10, 'uint16', 56, 113);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer87);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer10, 'uint16', 24, 32);
} catch {}
try {
renderPassEncoder3.insertDebugMarker('\u6820');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 27}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 7},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'hlg'} });
let bindGroup29 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 30, resource: {buffer: buffer79}},
    {binding: 13, resource: textureView104},
    {binding: 9, resource: textureView5},
    {binding: 103, resource: externalTexture11},
    {binding: 1, resource: textureView6},
  ],
});
let texture162 = device0.createTexture({
  size: {width: 848, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView107 = texture77.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder2.dispatchWorkgroupsIndirect(buffer7, 4);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer8, 0);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline9);
} catch {}
try {
commandEncoder56.resolveQuerySet(querySet1, 52, 0, buffer71, 1024);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 36, new DataView(new Uint8Array(29814).map((_, i) => i).buffer), 14753, 8);
} catch {}
let bindGroup30 = device0.createBindGroup({
  label: '\u8be7\u8b05\u{1fa67}\ua99c\ufc8f\u0787\u641e\u0125\u{1ff0e}\u0431',
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 9, resource: textureView68},
    {binding: 1, resource: textureView6},
    {binding: 13, resource: textureView104},
    {binding: 30, resource: {buffer: buffer71, size: 2856}},
    {binding: 103, resource: externalTexture11},
  ],
});
let buffer89 = device0.createBuffer({size: 104, usage: GPUBufferUsage.VERTEX});
let textureView108 = texture86.createView({dimension: 'cube-array', aspect: 'all', baseMipLevel: 0, baseArrayLayer: 11, arrayLayerCount: 6});
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 1, -1_430_953_224);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer73, 'uint16', 16, 8);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline11);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageBitmap1 = await createImageBitmap(imageData3);
let commandEncoder97 = device1.createCommandEncoder();
let texture163 = device1.createTexture({
  size: [640, 1, 5],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder10.setBindGroup(3, bindGroup0, new Uint32Array(2018), 331, 0);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline3);
} catch {}
let texture164 = device1.createTexture({
  size: [256, 256, 243],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler14 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.28,
  maxAnisotropy: 13,
});
try {
device1.pushErrorScope('validation');
} catch {}
try {
renderPassEncoder12.pushDebugGroup('\u4824');
} catch {}
document.body.append(canvas2);
let externalTexture13 = device1.importExternalTexture({label: '\u74ca', source: videoFrame1});
try {
renderPassEncoder16.setIndexBuffer(buffer53, 'uint32', 68, 98);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline13);
} catch {}
let pipeline16 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule1,
  targets: [{
  format: 'rgba16float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule9,
    constants: {override19: 1},
    buffers: [
      {
        arrayStride: 60,
        attributes: [
          {format: 'uint32x2', offset: 4, shaderLocation: 4},
          {format: 'float32x4', offset: 4, shaderLocation: 3},
          {format: 'sint32x3', offset: 4, shaderLocation: 5},
          {format: 'float16x4', offset: 4, shaderLocation: 7},
          {format: 'sint8x4', offset: 4, shaderLocation: 14},
          {format: 'unorm8x2', offset: 12, shaderLocation: 13},
          {format: 'sint32x3', offset: 4, shaderLocation: 11},
          {format: 'float32x2', offset: 0, shaderLocation: 12},
          {format: 'unorm16x2', offset: 8, shaderLocation: 10},
          {format: 'uint32x2', offset: 0, shaderLocation: 0},
          {format: 'sint8x2', offset: 0, shaderLocation: 15},
          {format: 'sint16x4', offset: 24, shaderLocation: 2},
          {format: 'snorm16x4', offset: 4, shaderLocation: 8},
          {format: 'uint32x4', offset: 0, shaderLocation: 9},
          {format: 'sint16x2', offset: 0, shaderLocation: 1},
          {format: 'uint32', offset: 36, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front'},
});
let bindGroup31 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 0, resource: {buffer: buffer74, size: 1300}},
    {binding: 18, resource: textureView18},
    {binding: 1, resource: {buffer: buffer74, size: 724}},
  ],
});
let buffer90 = device1.createBuffer({size: 186, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder98 = device1.createCommandEncoder({});
let textureView109 = texture135.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1});
let texture165 = device1.createTexture({
  size: {width: 51, height: 1, depthOrArrayLayers: 29},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView110 = texture99.createView({label: '\u1208\u6db1\u0c6d\u{1fa7e}\u0e79', dimension: '2d'});
try {
renderPassEncoder11.setIndexBuffer(buffer32, 'uint16', 4, 4);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer32, 'uint16', 6, 12);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline1);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(329).fill(201), /* required buffer size: 329 */
{offset: 329, rowsPerImage: 21}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
try {
renderPassEncoder7.setBindGroup(1, bindGroup4, new Uint32Array(2214), 931, 0);
} catch {}
try {
computePassEncoder33.pushDebugGroup('\u9a21');
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder99 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer49, 36); };
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer8, 3_044);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer54, 'uint32', 4, 0);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline9);
} catch {}
try {
commandEncoder79.clearBuffer(buffer7);
} catch {}
let buffer91 = device0.createBuffer({size: 58, usage: GPUBufferUsage.STORAGE});
let commandEncoder100 = device0.createCommandEncoder({});
let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthStencilFormat: 'depth32float', depthReadOnly: true});
let externalTexture14 = device0.importExternalTexture({source: videoFrame2});
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer49, 16); };
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder9.drawIndexed(2, 0, 1, 312_134_665);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline9);
} catch {}
document.body.append(img1);
let bindGroup32 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 30, resource: {buffer: buffer79}},
    {binding: 1, resource: textureView6},
    {binding: 103, resource: externalTexture2},
    {binding: 9, resource: textureView5},
    {binding: 13, resource: textureView104},
  ],
});
let texture166 = device0.createTexture({
  size: [848, 1, 3],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder5.setBindGroup(2, bindGroup28);
} catch {}
try {
renderPassEncoder5.draw(94, 1, 201_658_822, 1);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer0, 8);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline4);
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture153,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture115,
  mipLevel: 0,
  origin: {x: 322, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer46, 140, new Float32Array(11731).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.870)), 1646, 32);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let buffer92 = device0.createBuffer({size: 272, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder101 = device0.createCommandEncoder();
let texture167 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder5.draw(156, 1, 901_189_453);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer7, 16);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer7, 12);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup20, new Uint32Array(1390), 40, 0);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer78, 'uint16', 282, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer93 = device1.createBuffer({size: 276, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let texture168 = device1.createTexture({
  size: {width: 1280, height: 1, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder30.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer81, 'uint32', 16, 25);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 25, height: 1, depthOrArrayLayers: 26}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture58,
  mipLevel: 1,
  origin: {x: 9, y: 0, z: 8},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout25 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 68,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 174, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 236,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 379,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let textureView111 = texture108.createView({arrayLayerCount: 1});
try {
renderPassEncoder15.setVertexBuffer(6, buffer31, 0, 23);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(6, buffer32, 4);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
let veryExplicitBindGroupLayout26 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true },
    },
    {
      binding: 98,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer94 = device1.createBuffer({size: 1780, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let commandEncoder102 = device1.createCommandEncoder({});
let texture169 = device1.createTexture({
  size: {width: 156, height: 164, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView112 = texture24.createView({});
try {
computePassEncoder27.setBindGroup(0, bindGroup19, new Uint32Array(1922), 20, 0);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer53, 'uint16', 72, 111);
} catch {}
offscreenCanvas0.height = 2267;
let commandEncoder103 = device1.createCommandEncoder();
let computePassEncoder36 = commandEncoder92.beginComputePass();
let externalTexture15 = device1.importExternalTexture({source: videoFrame9});
try {
computePassEncoder32.setBindGroup(1, bindGroup1, new Uint32Array(2646), 414, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroup33 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout26,
  entries: [
    {binding: 2, resource: {buffer: buffer67}},
    {binding: 98, resource: textureView36},
    {binding: 0, resource: textureView15},
  ],
});
let commandEncoder104 = device1.createCommandEncoder({});
let textureView113 = texture56.createView({});
try {
computePassEncoder22.setBindGroup(0, bindGroup21, [2048]);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup21, new Uint32Array(5), 0, 1);
} catch {}
try {
commandEncoder96.copyTextureToTexture({
  texture: texture104,
  mipLevel: 0,
  origin: {x: 200, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture105,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder14.insertDebugMarker('\u{1ffb3}');
} catch {}
try {
device1.queue.writeTexture({
  texture: texture146,
  mipLevel: 0,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(1_469).fill(139), /* required buffer size: 1_469 */
{offset: 17, bytesPerRow: 52, rowsPerImage: 4}, {width: 6, height: 4, depthOrArrayLayers: 7});
} catch {}
let bindGroup34 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 9, resource: textureView68},
    {binding: 13, resource: textureView104},
    {binding: 103, resource: externalTexture0},
    {binding: 30, resource: {buffer: buffer91, size: 24}},
    {binding: 1, resource: textureView6},
  ],
});
let buffer95 = device0.createBuffer({size: 68, usage: GPUBufferUsage.STORAGE});
let texture170 = device0.createTexture({
  size: [848, 1, 1],
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture16 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer8, 1_372);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 32, new DataView(new Uint8Array(39232).map((_, i) => i).buffer), 16170, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 27}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture82,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData8 = new ImageData(12, 132);
let autogeneratedBindGroupLayout7 = pipeline8.getBindGroupLayout(0);
let buffer96 = device0.createBuffer({size: 236, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder105 = device0.createCommandEncoder({});
let texture171 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView114 = texture90.createView({dimension: '2d', baseArrayLayer: 2});
try {
computePassEncoder29.setBindGroup(2, bindGroup15);
} catch {}
try {
renderPassEncoder5.draw(162, 1, 195_578_459);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(2, buffer8);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
document.body.append(img0);
try {
externalTexture14.label = '\u0531\u{1fdbf}\u24b9\u64e8\u5392\u58d8\u0707\u{1fd50}\u0f4b';
} catch {}
let autogeneratedBindGroupLayout8 = pipeline5.getBindGroupLayout(0);
let buffer97 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer9, 'uint32', 0, 7);
} catch {}
try {
renderBundleEncoder29.setBindGroup(3, bindGroup10);
} catch {}
await gc();
let commandEncoder106 = device0.createCommandEncoder({});
let computePassEncoder37 = commandEncoder85.beginComputePass();
try {
computePassEncoder37.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup26);
} catch {}
try {
renderPassEncoder5.draw(5, 303, 2, 212_142_575);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer73, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer92, 'uint16', 0, 16);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup16);
} catch {}
let pipeline17 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule8,
  constants: {override16: 1, override17: 1},
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'add', srcFactor: 'src', dstFactor: 'src-alpha'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule7,
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint32x4', offset: 516, shaderLocation: 11},
          {format: 'uint8x2', offset: 0, shaderLocation: 8},
          {format: 'float32', offset: 688, shaderLocation: 12},
          {format: 'unorm8x4', offset: 420, shaderLocation: 15},
          {format: 'unorm16x4', offset: 28, shaderLocation: 14},
          {format: 'unorm16x2', offset: 400, shaderLocation: 1},
          {format: 'uint32', offset: 968, shaderLocation: 10},
          {format: 'float16x4', offset: 340, shaderLocation: 9},
          {format: 'uint8x4', offset: 200, shaderLocation: 5},
          {format: 'sint8x2', offset: 396, shaderLocation: 13},
          {format: 'uint32', offset: 544, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 368, shaderLocation: 0},
          {format: 'float32x4', offset: 460, shaderLocation: 7},
          {format: 'unorm8x4', offset: 196, shaderLocation: 6},
          {format: 'sint16x4', offset: 288, shaderLocation: 4},
        ],
      },
      {arrayStride: 44, attributes: [{format: 'sint16x4', offset: 28, shaderLocation: 2}]},
    ],
  },
});
let videoFrame18 = new VideoFrame(offscreenCanvas1, {timestamp: 0});
let bindGroup35 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 1, resource: {buffer: buffer95}}]});
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer8, 180); };
} catch {}
try {
renderBundleEncoder33.setPipeline(pipeline9);
} catch {}
let promise7 = shaderModule2.getCompilationInfo();
try {
device0.queue.writeBuffer(buffer7, 12, new DataView(new ArrayBuffer(65084)), 845, 0);
} catch {}
let pipeline18 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, constants: {}}});
let imageData9 = new ImageData(4, 8);
let commandEncoder107 = device1.createCommandEncoder({});
let externalTexture17 = device1.importExternalTexture({source: videoFrame12});
try {
computePassEncoder35.setBindGroup(3, bindGroup0, new Uint32Array(313), 40, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(1, bindGroup33, new Uint32Array(2936), 2_579, 1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer22, 0, 35);
} catch {}
try {
commandEncoder107.copyBufferToBuffer(buffer52, 0, buffer30, 2320, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer31, 0, new Float32Array(648).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.677)), 6, 0);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let commandEncoder108 = device1.createCommandEncoder({});
let texture172 = device1.createTexture({
  size: [320, 1, 1],
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView115 = texture110.createView({mipLevelCount: 2});
try {
{ clearResourceUsages(device1, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(0); };
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer90);
} catch {}
try {
commandEncoder71.copyTextureToTexture({
  texture: texture149,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture129,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.submit([]);
} catch {}
document.body.prepend(img0);
try {
computePassEncoder27.end();
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup19);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder8.setBindGroup(1, bindGroup19);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(1, buffer85, 32, 11);
} catch {}
try {
commandEncoder96.copyTextureToTexture({
  texture: texture58,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture106,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 2},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 4});
} catch {}
let pipeline19 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rgba16float', writeMask: 0}]},
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex5',
    constants: {override19: 1},
    buffers: [
      {
        arrayStride: 72,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 28, shaderLocation: 9},
          {format: 'uint16x4', offset: 4, shaderLocation: 6},
          {format: 'uint32x3', offset: 4, shaderLocation: 4},
          {format: 'snorm8x4', offset: 4, shaderLocation: 8},
          {format: 'sint8x2', offset: 12, shaderLocation: 14},
          {format: 'snorm16x4', offset: 28, shaderLocation: 3},
          {format: 'uint8x2', offset: 2, shaderLocation: 0},
          {format: 'float16x2', offset: 4, shaderLocation: 13},
          {format: 'sint8x4', offset: 8, shaderLocation: 2},
          {format: 'sint16x4', offset: 0, shaderLocation: 1},
          {format: 'sint16x4', offset: 0, shaderLocation: 5},
          {format: 'float32x4', offset: 0, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 64,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 4, shaderLocation: 10},
          {format: 'sint8x4', offset: 4, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7},
          {format: 'sint32x3', offset: 24, shaderLocation: 15},
        ],
      },
    ],
  },
});
let bindGroup36 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 13, resource: textureView108},
    {binding: 1, resource: textureView6},
    {binding: 9, resource: textureView68},
    {binding: 30, resource: {buffer: buffer79}},
    {binding: 103, resource: externalTexture6},
  ],
});
let texture173 = device0.createTexture({
  size: [16, 16, 167],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView116 = texture141.createView({dimension: '2d-array', format: 'rgb10a2uint', baseMipLevel: 1, mipLevelCount: 1});
try {
renderPassEncoder5.draw(4, 5, 2, 1_442_409_325);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(6, buffer89, 0, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer32, 'uint16', 0, 33);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(2, buffer22, 0);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 156, height: 164, depthOrArrayLayers: 1}
*/
{
  source: canvas2,
  origin: { x: 20, y: 22 },
  flipY: false,
}, {
  texture: texture46,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 45, height: 12, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let bindGroup37 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 103, resource: externalTexture6},
    {binding: 30, resource: {buffer: buffer71}},
    {binding: 13, resource: textureView108},
    {binding: 1, resource: textureView6},
    {binding: 9, resource: textureView68},
  ],
});
let texture174 = device0.createTexture({
  size: [3395, 1, 1],
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture18 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder28.setBindGroup(0, bindGroup10);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder5.drawIndexed(4, 309, 1, 100_930_882, 165_827_313);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer73, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer89);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let commandEncoder109 = device1.createCommandEncoder({});
let textureView117 = texture97.createView({});
let computePassEncoder38 = commandEncoder46.beginComputePass();
try {
computePassEncoder38.setBindGroup(2, bindGroup33, [0]);
} catch {}
try {
computePassEncoder20.setPipeline(pipeline10);
} catch {}
try {
computePassEncoder38.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup21, new Uint32Array(2001), 158, 1);
} catch {}
try {
renderBundleEncoder10.setBindGroup(0, bindGroup21, new Uint32Array(2575), 1_188, 1);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline3);
} catch {}
try {
commandEncoder109.copyTextureToBuffer({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1200 */
  offset: 1200,
  bytesPerRow: 768,
  buffer: buffer30,
}, {width: 1, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture129,
  mipLevel: 0,
  origin: {x: 46, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(154).fill(192), /* required buffer size: 154 */
{offset: 154, bytesPerRow: 176, rowsPerImage: 126}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise8 = device1.queue.onSubmittedWorkDone();
let buffer98 = device1.createBuffer({size: 404, usage: GPUBufferUsage.INDEX});
let commandEncoder110 = device1.createCommandEncoder();
let computePassEncoder39 = commandEncoder34.beginComputePass();
let renderBundle0 = renderBundleEncoder10.finish({});
let sampler15 = device1.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest'});
try {
computePassEncoder38.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder15.setBindGroup(1, bindGroup0, new Uint32Array(310), 20, 0);
} catch {}
try {
renderPassEncoder12.setStencilReference(781);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer90, 0, 10);
} catch {}
let pipeline20 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule6, entryPoint: 'compute8'}});
let bindGroup38 = device0.createBindGroup({layout: autogeneratedBindGroupLayout8, entries: [{binding: 0, resource: sampler0}]});
let buffer99 = device0.createBuffer({size: 468, usage: GPUBufferUsage.INDIRECT});
let textureView118 = texture173.createView({});
try {
computePassEncoder18.setBindGroup(0, bindGroup38);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer47, 16); };
} catch {}
try {
renderPassEncoder5.drawIndexed(5, 106, 0, 88_109_663, 192_182_123);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer47, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer47, 0);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup5);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer46, 500, new BigInt64Array(20966).map((_, i) => BigInt(i - 4)), 3537, 28);
} catch {}
let bindGroup39 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 1, resource: {buffer: buffer71}}]});
let buffer100 = device0.createBuffer({size: 63, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let texture175 = device0.createTexture({
  size: {width: 4, height: 712, depthOrArrayLayers: 1},
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView119 = texture90.createView({dimension: '2d', baseArrayLayer: 30});
let computePassEncoder40 = commandEncoder44.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup37, []);
} catch {}
try {
renderPassEncoder5.drawIndexed(4, 180, 0, 1_452_886_003, 100_417_762);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer9, 'uint16', 4, 5);
} catch {}
let buffer101 = device1.createBuffer({size: 4, usage: GPUBufferUsage.INDEX});
let commandEncoder111 = device1.createCommandEncoder({});
let texture176 = device1.createTexture({
  size: {width: 19, height: 20, depthOrArrayLayers: 14},
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder39.setPipeline(pipeline20);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let buffer102 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST});
let textureView120 = texture175.createView({dimension: '2d-array', mipLevelCount: 1});
let textureView121 = texture80.createView({dimension: '2d'});
try {
computePassEncoder40.setBindGroup(0, bindGroup28);
} catch {}
try {
computePassEncoder37.setBindGroup(0, bindGroup16, new Uint32Array(1968), 416, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer99, 20); };
} catch {}
try {
computePassEncoder40.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup24, new Uint32Array(132), 1, 0);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer0, 36);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer73, 0);
} catch {}
try {
renderBundleEncoder34.setIndexBuffer(buffer78, 'uint32', 24, 29);
} catch {}
try {
buffer73.unmap();
} catch {}
let commandEncoder112 = device0.createCommandEncoder({});
let texture177 = device0.createTexture({
  size: {width: 1697},
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView122 = texture166.createView({dimension: '3d', format: 'rgb10a2uint', mipLevelCount: 1});
let renderPassEncoder17 = commandEncoder72.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: -386.4, g: 195.3, b: -101.4, a: -167.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder31.setBindGroup(2, bindGroup25, []);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer7, 8);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer92, 'uint32', 184, 1);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer4, 'uint32', 4, 9);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
document.body.prepend(img1);
let texture178 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 27},
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder41 = commandEncoder43.beginComputePass();
try {
computePassEncoder28.setBindGroup(1, bindGroup25, new Uint32Array(443), 71, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer99, 108); };
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer64, 'uint16', 0, 3);
} catch {}
let pipeline21 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule7}});
try {
  await promise7;
} catch {}
let textureView123 = texture177.createView({aspect: 'all', baseArrayLayer: 0});
let texture179 = device0.createTexture({
  size: [848, 1, 298],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder40.setBindGroup(0, bindGroup38);
} catch {}
try {
computePassEncoder1.setBindGroup(0, bindGroup38, new Uint32Array(5668), 1_027, 0);
} catch {}
try {
computePassEncoder41.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder9.draw(0, 18, 0, 332_379_694);
} catch {}
try {
renderPassEncoder5.drawIndexed(3, 116, 1, 727_994_461, 25_785_277);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer10, 'uint32', 24, 4);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer1, 'uint32', 52, 40);
} catch {}
try {
commandEncoder80.pushDebugGroup('\uf681');
} catch {}
try {
device0.queue.writeBuffer(buffer86, 8, new DataView(new Uint8Array(10661).map((_, i) => i).buffer), 2281, 0);
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
let bindGroup40 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 9, resource: textureView68},
    {binding: 13, resource: textureView108},
    {binding: 1, resource: textureView6},
    {binding: 103, resource: externalTexture1},
    {binding: 30, resource: {buffer: buffer80}},
  ],
});
let texture180 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 19},
  dimension: '2d',
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture181 = device0.createTexture({
  size: [848, 1, 7],
  mipLevelCount: 3,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup9, new Uint32Array(1673), 225, 0);
} catch {}
try {
renderPassEncoder5.drawIndexed(4, 55, 7, 2_147_483_647, 939_669_591);
} catch {}
let bindGroup41 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 103, resource: externalTexture4},
    {binding: 13, resource: textureView108},
    {binding: 1, resource: textureView6},
    {binding: 9, resource: textureView68},
    {binding: 30, resource: {buffer: buffer49, size: 24}},
  ],
});
let texture182 = device0.createTexture({
  size: [1, 178, 1],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture183 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 34},
  mipLevelCount: 2,
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer49, 8); };
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup26, []);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup23, new Uint32Array(1469), 193, 0);
} catch {}
try {
commandEncoder112.clearBuffer(buffer79);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 424, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture184 = device0.createTexture({
  size: {width: 8, height: 1424, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'r32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView124 = texture12.createView({dimension: '2d-array', format: 'astc-4x4-unorm', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup20);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup35, new Uint32Array(1057), 10, 0);
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer99, 188);
} catch {}
try {
device0.queue.writeBuffer(buffer79, 136, new Float32Array(587).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.860)), 97, 8);
} catch {}
let bindGroup42 = device1.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 1, resource: {buffer: buffer67}}]});
let commandEncoder113 = device1.createCommandEncoder({});
let texture185 = device1.createTexture({
  size: {width: 408, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder42 = commandEncoder38.beginComputePass();
try {
computePassEncoder42.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer61, 0, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(3, bindGroup27, new Uint32Array(1004), 128, 0);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer98, 'uint16', 94, 164);
} catch {}
let commandEncoder114 = device1.createCommandEncoder({});
let textureView125 = texture185.createView({dimension: '2d', baseMipLevel: 0});
try {
renderPassEncoder1.setVertexBuffer(4, buffer90, 8, 16);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline19);
} catch {}
try {
buffer50.unmap();
} catch {}
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
  await promise9;
} catch {}
let buffer103 = device1.createBuffer({size: 168, usage: GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder38.setBindGroup(0, bindGroup2, new Uint32Array(1409), 552, 0);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup33, [0]);
} catch {}
try {
renderPassEncoder8.setStencilReference(270);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer53, 'uint16', 34, 20);
} catch {}
try {
device1.lost.then(r => { console.log('device1 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device1.queue.writeBuffer(buffer31, 12, new Uint16Array(3113).map((_, i) => i + 5), 159, 4);
} catch {}
try {
adapter1.label = '\u94fb\u07c2';
} catch {}
let bindGroup43 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 9, resource: textureView5},
    {binding: 1, resource: textureView6},
    {binding: 13, resource: textureView104},
    {binding: 30, resource: {buffer: buffer49, size: 56}},
    {binding: 103, resource: externalTexture5},
  ],
});
let commandEncoder115 = device0.createCommandEncoder({});
let textureView126 = texture178.createView({dimension: '2d'});
let texture186 = device0.createTexture({
  size: {width: 848, height: 1, depthOrArrayLayers: 1},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView127 = texture171.createView({dimension: '2d-array', aspect: 'depth-only', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder41.setBindGroup(0, bindGroup35, new Uint32Array(2627), 157, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer73, 8); };
} catch {}
try {
renderPassEncoder5.drawIndexedIndirect(buffer47, 4);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer47, 12);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 32, new BigInt64Array(23214).map((_, i) => BigInt(i - 5)), 4243, 0);
} catch {}
let bindGroup44 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 0, resource: sampler0}]});
let texture187 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 43},
  mipLevelCount: 2,
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder26.setBindGroup(0, bindGroup44);
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup39);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer87, 144, 27);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup3, new Uint32Array(220), 151, 0);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(2, buffer8, 0);
} catch {}
let textureView128 = texture110.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder1.setIndexBuffer(buffer81, 'uint32', 4, 1);
} catch {}
let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'gamma28curve'} });
let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup45 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 9, resource: textureView5},
    {binding: 103, resource: externalTexture9},
    {binding: 13, resource: textureView108},
    {binding: 1, resource: textureView6},
    {binding: 30, resource: {buffer: buffer71}},
  ],
});
let buffer104 = device0.createBuffer({size: 92, usage: GPUBufferUsage.COPY_DST});
let commandEncoder116 = device0.createCommandEncoder();
let textureView129 = texture138.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 9});
let textureView130 = texture87.createView({dimension: '1d', arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 1_688_251_428, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer8, 5_788);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(2, buffer89, 0, 24);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 20, new DataView(new ArrayBuffer(51320)), 3185, 0);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder117 = device0.createCommandEncoder({});
let commandBuffer9 = commandEncoder47.finish();
let texture188 = device0.createTexture({
  size: {width: 1697},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture189 = device0.createTexture({
  size: [2, 356, 57],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder43 = commandEncoder48.beginComputePass();
let renderBundleEncoder38 = device0.createRenderBundleEncoder({
  colorFormats: ['rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder31.setBindGroup(1, bindGroup34, new Uint32Array(5413), 432, 0);
} catch {}
try {
computePassEncoder43.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer8, 2_108);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer99, 24);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline11);
} catch {}
try {
commandEncoder115.copyTextureToBuffer({
  texture: texture115,
  mipLevel: 0,
  origin: {x: 1085, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 15552 widthInBlocks: 1944 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1656 */
  offset: 1656,
  buffer: buffer46,
}, {width: 1944, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer105 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let commandEncoder118 = device0.createCommandEncoder({});
let textureView131 = texture186.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder29.setBindGroup(0, bindGroup20);
} catch {}
try {
computePassEncoder28.setBindGroup(3, bindGroup32, new Uint32Array(631), 282, 0);
} catch {}
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer73, 16);
} catch {}
try {
device0.queue.submit([commandBuffer9]);
} catch {}
try {
device0.queue.writeBuffer(buffer72, 0, new Uint16Array(5713).map((_, i) => i + 7), 4326, 8);
} catch {}
try {
  await promise8;
} catch {}
document.body.prepend(img1);
try {
{ clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer90, 4); };
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer85, 40);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup18, [0]);
} catch {}
try {
device1.queue.submit([]);
} catch {}
let textureView132 = texture45.createView({dimension: '2d'});
try {
renderBundleEncoder12.setBindGroup(3, bindGroup22);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(0, buffer88, 0);
} catch {}
try {
buffer50.unmap();
} catch {}
try {
commandEncoder90.copyBufferToBuffer(buffer52, 12, buffer94, 172, 4);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture108,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(15).fill(221), /* required buffer size: 15 */
{offset: 15, bytesPerRow: 157, rowsPerImage: 41}, {width: 0, height: 3, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout28 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 74, hasDynamicOffset: true },
    },
    {binding: 6, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 86,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 114, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 121,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 146,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {
      binding: 210,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 250,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'float', multisampled: false },
    },
    {binding: 396, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }},
  ],
});
let bindGroup46 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout2,
  entries: [
    {binding: 9, resource: textureView5},
    {binding: 30, resource: {buffer: buffer80}},
    {binding: 1, resource: textureView6},
    {binding: 13, resource: textureView104},
    {binding: 103, resource: externalTexture18},
  ],
});
let commandEncoder119 = device0.createCommandEncoder({});
let textureView133 = texture82.createView({dimension: 'cube', format: 'rgba16float', baseArrayLayer: 4});
let textureView134 = texture130.createView({});
let renderPassEncoder18 = commandEncoder56.beginRenderPass({
  label: '',
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 224.8, g: 913.8, b: -759.5, a: -390.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  timestampWrites: {querySet: querySet1},
  maxDrawCount: 312756293,
});
try {
renderPassEncoder9.draw(0, 0, 0);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(6, buffer79, 0, 18);
} catch {}
try {
device0.queue.writeBuffer(buffer86, 16, new Uint32Array(26077).map((_, i) => i * 2), 3418, 4);
} catch {}
let imageData10 = new ImageData(24, 80);
let textureView135 = texture188.createView({});
try {
computePassEncoder18.end();
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup9, new Uint32Array(2271), 49, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 287_201_879, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer7, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer7, 12);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer8);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline17);
} catch {}
try {
commandEncoder99.copyTextureToTexture({
  texture: texture67,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture67,
  mipLevel: 1,
  origin: {x: 81, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer86, 12, new Uint32Array(14337).map((_, i) => i * 8), 398, 0);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let bindGroup47 = device1.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 2, resource: {buffer: buffer63}}]});
let texture190 = gpuCanvasContext3.getCurrentTexture();
let textureView136 = texture176.createView({dimension: '3d'});
try {
{ clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer51, 40); };
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup22, new Uint32Array(3769), 484, 0);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer32, 'uint16', 10, 7);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
let texture191 = device0.createTexture({
  size: {width: 2, height: 356, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView137 = texture12.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder9.drawIndexedIndirect(buffer7, 36);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer73, 16);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer78, 'uint16', 92, 2);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer89, 60, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup6);
} catch {}
try {
renderBundleEncoder30.setBindGroup(1, bindGroup35, new Uint32Array(419), 95, 0);
} catch {}
try {
buffer104.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer104, 8, new Uint32Array(2523).map((_, i) => i * 6), 255, 0);
} catch {}
let imageData11 = new ImageData(24, 16);
let textureView138 = texture173.createView({baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder0.setBindGroup(0, bindGroup10, new Uint32Array(195), 42, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 403_013_983);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer92, 'uint32', 12, 15);
} catch {}
try {
renderBundleEncoder31.setIndexBuffer(buffer47, 'uint32', 16, 6);
} catch {}
try {
commandEncoder89.copyBufferToBuffer(buffer62, 0, buffer105, 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer72, 24, new BigInt64Array(15892).map((_, i) => BigInt(i - 9)), 5918, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 10, z: 0},
  aspect: 'all',
}, new Uint8Array(361).fill(85), /* required buffer size: 361 */
{offset: 361, bytesPerRow: 20}, {width: 0, height: 127, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline22 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule8, constants: {override16: 1, override17: 1}}});
let imageData12 = new ImageData(48, 16);
let commandEncoder120 = device0.createCommandEncoder({});
try {
computePassEncoder6.setBindGroup(0, bindGroup38, new Uint32Array(3311), 17, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup23, new Uint32Array(3229), 43, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer87, 0, 116);
} catch {}
try {
buffer48.unmap();
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let commandEncoder121 = device1.createCommandEncoder();
let textureView139 = texture185.createView({dimension: '2d', baseArrayLayer: 0});
let texture192 = device1.createTexture({
  size: {width: 39, height: 41, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder12.setBindGroup(3, bindGroup17);
} catch {}
try {
commandEncoder51.copyBufferToBuffer(buffer67, 12, buffer30, 5092, 20);
} catch {}
let commandEncoder122 = device0.createCommandEncoder({});
try {
computePassEncoder2.setBindGroup(0, bindGroup3, []);
} catch {}
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 494_243_360);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder40.pushDebugGroup('\ue099');
} catch {}
try {
device0.queue.writeBuffer(buffer82, 4, new BigInt64Array(40786).map((_, i) => BigInt(i - 6)), 5848, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture193 = device0.createTexture({
  size: [848, 1, 87],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer99, 12);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer99, 132);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(6, buffer8);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer48, 'uint16', 16, 8);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1697, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture6,
  mipLevel: 1,
  origin: {x: 48, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline23 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule8,
  entryPoint: 'fragment5',
  constants: {override17: 1, override16: 1},
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'dst-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  vertex: {
    module: shaderModule12,
    constants: {},
    buffers: [
      {
        arrayStride: 60,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 8, shaderLocation: 10},
          {format: 'snorm8x2', offset: 14, shaderLocation: 15},
          {format: 'unorm16x2', offset: 4, shaderLocation: 13},
          {format: 'sint32', offset: 24, shaderLocation: 14},
          {format: 'unorm8x4', offset: 8, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 56,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 4, shaderLocation: 4},
          {format: 'sint32', offset: 0, shaderLocation: 5},
          {format: 'snorm8x4', offset: 4, shaderLocation: 6},
          {format: 'float16x4', offset: 0, shaderLocation: 3},
        ],
      },
      {arrayStride: 20, attributes: [{format: 'float16x2', offset: 4, shaderLocation: 12}]},
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true},
});
document.body.prepend(img0);
let textureView140 = texture135.createView({dimension: '2d'});
let textureView141 = texture156.createView({dimension: '2d-array', format: 'rg32float', mipLevelCount: 1});
try {
renderBundleEncoder5.setIndexBuffer(buffer98, 'uint32', 40, 53);
} catch {}
try {
commandEncoder103.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 464 */
  offset: 464,
  buffer: buffer77,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteSt4281', transfer: 'logSqrt'} });
let autogeneratedBindGroupLayout9 = pipeline19.getBindGroupLayout(3);
let commandEncoder123 = device1.createCommandEncoder({});
let textureView142 = texture50.createView({dimension: '2d-array', format: 'rgba16uint'});
let texture194 = device1.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 12},
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView143 = texture151.createView({mipLevelCount: 1});
try {
renderPassEncoder1.setIndexBuffer(buffer98, 'uint16', 60, 35);
} catch {}
let pipeline24 = await device1.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule9,
  constants: {},
  targets: [{format: 'rgba16uint', writeMask: 0}, {format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule9,
    constants: {override19: 1},
    buffers: [
      {
        arrayStride: 28,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint32x3', offset: 0, shaderLocation: 15},
          {format: 'sint16x2', offset: 12, shaderLocation: 11},
          {format: 'sint32', offset: 4, shaderLocation: 14},
          {format: 'sint32x2', offset: 12, shaderLocation: 1},
          {format: 'snorm16x2', offset: 4, shaderLocation: 8},
          {format: 'uint16x4', offset: 0, shaderLocation: 4},
          {format: 'float16x2', offset: 4, shaderLocation: 13},
          {format: 'uint8x4', offset: 8, shaderLocation: 6},
          {format: 'unorm16x4', offset: 0, shaderLocation: 10},
          {format: 'sint8x4', offset: 0, shaderLocation: 5},
          {format: 'sint32x4', offset: 0, shaderLocation: 2},
          {format: 'float16x2', offset: 0, shaderLocation: 7},
          {format: 'uint8x4', offset: 0, shaderLocation: 9},
          {format: 'float32x2', offset: 0, shaderLocation: 12},
          {format: 'uint32x4', offset: 8, shaderLocation: 0},
          {format: 'unorm16x2', offset: 0, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'front'},
});
let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470m', transfer: 'smpte170m'} });
let buffer106 = device1.createBuffer({
  size: 256,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
try {
{ clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer66, 0); };
} catch {}
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteRp431', transfer: 'hlg'} });
let recycledExplicitBindGroupLayout2 = pipeline9.getBindGroupLayout(0);
let bindGroup48 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 13, resource: textureView108},
    {binding: 30, resource: {buffer: buffer91, size: 16}},
    {binding: 103, resource: externalTexture11},
    {binding: 9, resource: textureView5},
    {binding: 1, resource: textureView6},
  ],
});
let commandEncoder124 = device0.createCommandEncoder({});
let textureView144 = texture34.createView({dimension: '2d-array'});
let renderBundleEncoder39 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 1, depthReadOnly: true});
try {
computePassEncoder25.setBindGroup(3, bindGroup41);
} catch {}
try {
computePassEncoder2.setBindGroup(0, bindGroup20, new Uint32Array(3190), 134, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer8, 3_496);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(4, buffer8, 0, 3_350);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup28);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(0, buffer89, 0, 6);
} catch {}
try {
computePassEncoder29.insertDebugMarker('\u{1fadc}');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup49 = device1.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView29}]});
try {
{ clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer67, 0); };
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder21.setBindGroup(1, bindGroup8);
} catch {}
try {
  await promise10;
} catch {}
document.body.append(canvas1);
let textureView145 = texture152.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 8});
let renderPassEncoder19 = commandEncoder95.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 563.4, g: 776.7, b: -778.9, a: 760.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 4294967295},
});
try {
{ clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 48_057_855);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer73, 4);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer99, 92);
} catch {}
try {
commandEncoder36.copyBufferToBuffer(buffer48, 36, buffer7, 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer73, 20, new DataView(new ArrayBuffer(52720)), 2808, 0);
} catch {}
try {
adapter0.label = '\u01ba\u26be\u0b23\u{1ff97}\u05ca\u0d26\u0b4d\u03f6';
} catch {}
let textureView146 = texture86.createView({baseArrayLayer: 5, arrayLayerCount: 4});
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 1_017_810_752);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer76, 'uint16', 14, 32);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(7, buffer87, 0, 63);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup28);
} catch {}
let imageData13 = new ImageData(104, 8);
try {
computePassEncoder22.setBindGroup(3, bindGroup47, new Uint32Array(2589), 315, 0);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroups(2, 1); };
} catch {}
try {
computePassEncoder38.end();
} catch {}
try {
computePassEncoder42.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup18, new Uint32Array(2935), 134, 1);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder22.insertDebugMarker('\ub6c4');
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 39, height: 41, depthOrArrayLayers: 1}
*/
{
  source: imageData11,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 14, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer32, 'uint32', 12, 7);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline13);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(0, buffer94, 0, 126);
} catch {}
document.body.append(img1);
let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'bt709'} });
let bindGroup50 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout14,
  entries: [
    {binding: 103, resource: externalTexture9},
    {binding: 9, resource: textureView68},
    {binding: 30, resource: {buffer: buffer71}},
    {binding: 1, resource: textureView6},
    {binding: 13, resource: textureView104},
  ],
});
let texture195 = device0.createTexture({
  size: [4, 712, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder44 = commandEncoder50.beginComputePass({timestampWrites: {querySet: querySet1}});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer8, 0, 5_077);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
try {
computePassEncoder28.insertDebugMarker('\u0d88');
} catch {}
let imageData14 = new ImageData(28, 12);
let commandEncoder125 = device0.createCommandEncoder({});
let textureView147 = texture87.createView({aspect: 'all'});
let computePassEncoder45 = commandEncoder87.beginComputePass();
let externalTexture19 = device0.importExternalTexture({source: videoFrame10});
try {
renderPassEncoder17.setBindGroup(0, bindGroup38, new Uint32Array(760), 138, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer0, 4);
} catch {}
try {
buffer6.unmap();
} catch {}
try {
commandEncoder80.popDebugGroup();
} catch {}
let commandEncoder126 = device1.createCommandEncoder();
let commandBuffer10 = commandEncoder46.finish();
let renderBundleEncoder40 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float']});
let sampler16 = device1.createSampler({addressModeV: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 96.45});
try {
device1.queue.submit([commandBuffer10]);
} catch {}
let texture196 = device1.createTexture({
  size: {width: 39, height: 41, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg32float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView148 = texture50.createView({});
let renderBundleEncoder41 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder14.setStencilReference(147);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer101, 'uint32', 0, 1);
} catch {}
try {
commandEncoder104.copyTextureToTexture({
  texture: texture165,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture97,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let pipelineLayout6 = device1.createPipelineLayout({
  bindGroupLayouts: [veryExplicitBindGroupLayout6, veryExplicitBindGroupLayout18, veryExplicitBindGroupLayout17, veryExplicitBindGroupLayout9],
});
let buffer107 = device1.createBuffer({
  size: 112,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
  mappedAtCreation: false,
});
let commandEncoder127 = device1.createCommandEncoder({});
let texture197 = device1.createTexture({
  size: [256],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView149 = texture151.createView({label: '\u5f60', mipLevelCount: 1});
let computePassEncoder46 = commandEncoder102.beginComputePass();
try {
renderPassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(265), 25, 0);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(0, buffer61, 0, 45);
} catch {}
let buffer108 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let textureView150 = texture2.createView({format: 'rgba16float'});
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 12_706_611, 0);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup28);
} catch {}
try {
renderBundleEncoder17.setBindGroup(1, bindGroup15, new Uint32Array(326), 131, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 4, height: 712, depthOrArrayLayers: 1}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 0, y: 205, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder44.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 1_027_693_339);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder32.setVertexBuffer(7, buffer89);
} catch {}
try {
buffer102.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 424, height: 1, depthOrArrayLayers: 14}
*/
{
  source: videoFrame8,
  origin: { x: 11, y: 1 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 106, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 1});
} catch {}
let bindGroup51 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [{binding: 354, resource: externalTexture8}, {binding: 294, resource: textureView31}],
});
let commandEncoder128 = device1.createCommandEncoder({});
let textureView151 = texture62.createView({});
try {
renderPassEncoder16.setIndexBuffer(buffer81, 'uint32', 20, 0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline12);
} catch {}
try {
device1.queue.writeBuffer(buffer30, 6_456, new DataView(new Uint8Array(9444).map((_, i) => i).buffer), 68);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 51, height: 1, depthOrArrayLayers: 26}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture58,
  mipLevel: 0,
  origin: {x: 38, y: 0, z: 10},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte170m', transfer: 'gamma22curve'} });
let buffer109 = device0.createBuffer({size: 222, usage: GPUBufferUsage.INDEX});
let commandEncoder129 = device0.createCommandEncoder({});
let commandBuffer11 = commandEncoder17.finish();
let computePassEncoder47 = commandEncoder76.beginComputePass();
try {
computePassEncoder45.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup7, new Uint32Array(2840), 196, 0);
} catch {}
let texture198 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float'],
});
try {
computePassEncoder47.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder9.draw(0, 117, 0, 1_768_089_290);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer7, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(5, buffer46, 0);
} catch {}
try {
renderBundleEncoder28.setBindGroup(1, bindGroup39, new Uint32Array(2599), 1_390, 0);
} catch {}
let commandEncoder130 = device1.createCommandEncoder({});
let texture199 = device1.createTexture({
  size: {width: 39, height: 41, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder18.setIndexBuffer(buffer107, 'uint32', 8, 55);
} catch {}
try {
commandEncoder96.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 560 */
  offset: 560,
  bytesPerRow: 5376,
  buffer: buffer77,
}, {
  texture: texture113,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder90.clearBuffer(buffer23);
} catch {}
let bindGroup52 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout17,
  entries: [{binding: 0, resource: {buffer: buffer67}}, {binding: 2, resource: {buffer: buffer74, size: 3124}}],
});
let textureView152 = texture124.createView({baseMipLevel: 0});
let externalTexture20 = device1.importExternalTexture({source: videoFrame7});
try {
computePassEncoder23.setBindGroup(2, bindGroup17);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer107, 'uint32', 8, 26);
} catch {}
try {
commandEncoder130.resolveQuerySet(querySet0, 12, 1, buffer66, 0);
} catch {}
try {
computePassEncoder46.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer53, 'uint16', 48, 25);
} catch {}
try {
renderBundleEncoder40.setVertexBuffer(2, buffer32);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 39, height: 41, depthOrArrayLayers: 1}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 6, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise11 = device1.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule9,
  targets: [{format: 'rgba16uint'}, {format: 'rg32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 112,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 4, shaderLocation: 15},
          {format: 'sint32', offset: 40, shaderLocation: 5},
          {format: 'sint16x2', offset: 24, shaderLocation: 6},
          {format: 'sint8x4', offset: 8, shaderLocation: 12},
          {format: 'uint32x2', offset: 0, shaderLocation: 9},
          {format: 'float16x4', offset: 4, shaderLocation: 2},
          {format: 'snorm16x4', offset: 24, shaderLocation: 4},
          {format: 'uint32', offset: 24, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 288,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 28, shaderLocation: 7},
          {format: 'sint8x4', offset: 116, shaderLocation: 8},
          {format: 'float16x2', offset: 24, shaderLocation: 1},
          {format: 'unorm10-10-10-2', offset: 68, shaderLocation: 10},
          {format: 'sint16x4', offset: 40, shaderLocation: 14},
          {format: 'float16x2', offset: 56, shaderLocation: 0},
          {format: 'uint32', offset: 72, shaderLocation: 11},
          {format: 'float32', offset: 184, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front'},
});
let bindGroup53 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout17,
  entries: [{binding: 0, resource: {buffer: buffer107}}, {binding: 2, resource: {buffer: buffer74, size: 1776}}],
});
let buffer110 = device1.createBuffer({size: 19768, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let texture200 = device1.createTexture({
  size: [256, 256, 31],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView153 = texture92.createView({baseArrayLayer: 0});
try {
computePassEncoder46.setBindGroup(1, bindGroup51, new Uint32Array(556), 455, 0);
} catch {}
try {
renderBundleEncoder35.setBindGroup(0, bindGroup19, new Uint32Array(2738), 326, 0);
} catch {}
try {
device1.queue.submit([]);
} catch {}
let veryExplicitBindGroupLayout29 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 24, hasDynamicOffset: false },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let commandEncoder131 = device1.createCommandEncoder();
let texture201 = device1.createTexture({
  size: [408],
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView154 = texture45.createView({dimension: '2d-array'});
let sampler17 = device1.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', minFilter: 'nearest', lodMaxClamp: 89.41});
try {
computePassEncoder19.setBindGroup(3, bindGroup19, new Uint32Array(102), 31, 0);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline16);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 25, height: 1, depthOrArrayLayers: 26}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture58,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer111 = device0.createBuffer({size: 28, usage: GPUBufferUsage.UNIFORM});
try {
computePassEncoder40.setBindGroup(1, bindGroup12);
} catch {}
try {
computePassEncoder29.end();
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer7, 4);
} catch {}
try {
renderBundleEncoder37.setIndexBuffer(buffer10, 'uint32', 84, 47);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(7, buffer87);
} catch {}
try {
commandEncoder120.copyTextureToBuffer({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 111, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1952 widthInBlocks: 244 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2312 */
  offset: 2312,
  rowsPerImage: 189,
  buffer: buffer46,
}, {width: 244, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let bindGroup54 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 30, resource: {buffer: buffer80}},
    {binding: 13, resource: textureView104},
    {binding: 103, resource: externalTexture18},
    {binding: 9, resource: textureView5},
    {binding: 1, resource: textureView6},
  ],
});
let commandEncoder132 = device0.createCommandEncoder();
let textureView155 = texture175.createView({dimension: '2d-array', format: 'rgba32uint', arrayLayerCount: 1});
let textureView156 = texture93.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer0, 20);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer79, 68, 35);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer64, 'uint32', 20, 0);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(1, buffer87, 220, 164);
} catch {}
try {
commandEncoder35.insertDebugMarker('\u026a');
} catch {}
try {
device0.queue.writeBuffer(buffer79, 0, new Uint32Array(7507).map((_, i) => i * 4), 1818, 8);
} catch {}
let textureView157 = texture183.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder48 = commandEncoder64.beginComputePass({
  timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 146},
});
try {
computePassEncoder48.setBindGroup(0, bindGroup38);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1, 1, 2); };
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup39);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer100, 'uint32', 4, 2);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer89, 0, 27);
} catch {}
try {
renderBundleEncoder33.setBindGroup(0, bindGroup3, new Uint32Array(833), 14, 0);
} catch {}
try {
renderBundleEncoder3.draw(2, 73, 0, 200_980_972);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer109, 'uint16', 26, 33);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture167,
  mipLevel: 0,
  origin: {x: 0, y: 48, z: 0},
  aspect: 'all',
}, new Uint8Array(255).fill(37), /* required buffer size: 255 */
{offset: 255, bytesPerRow: 149}, {width: 0, height: 53, depthOrArrayLayers: 0});
} catch {}
try {
adapter1.label = '\u8cfb\u5b01\u{1f63b}\u7e25';
} catch {}
let commandEncoder133 = device0.createCommandEncoder();
let renderPassEncoder20 = commandEncoder89.beginRenderPass({
  colorAttachments: [{view: textureView122, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}],
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 239},
});
try {
computePassEncoder44.setBindGroup(2, bindGroup48, new Uint32Array(74), 5, 0);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup25);
} catch {}
try {
renderPassEncoder3.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer7, 4);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer92, 'uint16', 112, 2);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(1, buffer89, 72, 1);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline17);
} catch {}
try {
commandEncoder100.clearBuffer(buffer3);
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout27,
  entries: [{binding: 2, resource: {buffer: buffer76, size: 124}}],
});
let commandEncoder134 = device0.createCommandEncoder({});
let texture202 = device0.createTexture({
  size: {width: 4, height: 712, depthOrArrayLayers: 113},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder4.setBindGroup(0, bindGroup38, new Uint32Array(1614), 167, 0);
} catch {}
try {
renderPassEncoder0.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer99, 148);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer73, 20);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline23);
} catch {}
try {
buffer111.unmap();
} catch {}
try {
commandEncoder78.resolveQuerySet(querySet1, 59, 13, buffer71, 3072);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup56 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 30, resource: {buffer: buffer79}},
    {binding: 103, resource: externalTexture3},
    {binding: 9, resource: textureView68},
    {binding: 13, resource: textureView104},
    {binding: 1, resource: textureView6},
  ],
});
let buffer112 = device0.createBuffer({size: 137, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
try {
computePassEncoder40.setBindGroup(0, bindGroup44);
} catch {}
try {
computePassEncoder2.end();
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer4, 'uint16', 4, 1);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(7, buffer112, 0);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer86, 0, new Uint32Array(16014).map((_, i) => i * 6), 1582, 0);
} catch {}
let textureView158 = texture122.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 5});
try {
computePassEncoder48.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer73, 8);
} catch {}
try {
renderBundleEncoder0.insertDebugMarker('\ufecb');
} catch {}
let pipeline25 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout4,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {module: shaderModule7, targets: [{format: 'rgba16float', writeMask: 0}]},
  vertex: {
    module: shaderModule8,
    entryPoint: 'vertex4',
    constants: {},
    buffers: [
      {
        arrayStride: 8,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 0, shaderLocation: 0},
          {format: 'sint32x2', offset: 0, shaderLocation: 5},
          {format: 'float32', offset: 0, shaderLocation: 3},
          {format: 'sint32x2', offset: 0, shaderLocation: 9},
          {format: 'uint16x4', offset: 0, shaderLocation: 7},
          {format: 'uint16x2', offset: 0, shaderLocation: 8},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'unorm8x2', offset: 0, shaderLocation: 2},
          {format: 'snorm16x4', offset: 0, shaderLocation: 12},
          {format: 'snorm8x2', offset: 0, shaderLocation: 13},
          {format: 'sint32x2', offset: 0, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'unorm8x4', offset: 364, shaderLocation: 14},
          {format: 'float16x2', offset: 4, shaderLocation: 15},
          {format: 'sint16x2', offset: 420, shaderLocation: 6},
          {format: 'unorm16x2', offset: 24, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let bindGroup57 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 103, resource: externalTexture6},
    {binding: 1, resource: textureView6},
    {binding: 30, resource: {buffer: buffer49, size: 20}},
    {binding: 13, resource: textureView104},
    {binding: 9, resource: textureView5},
  ],
});
let textureView159 = texture86.createView({
  label: '\u3ba5\u0eea\ucd17\ucc9f\ua980\u01d0\u8785\uf66b\ue250\u09d2',
  baseArrayLayer: 3,
  arrayLayerCount: 1,
});
try {
renderPassEncoder3.draw(0, 0);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer7, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer99, 92);
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer9, 'uint32', 4, 1);
} catch {}
try {
commandEncoder106.copyTextureToTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 43, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture77,
  mipLevel: 1,
  origin: {x: 0, y: 6, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder20.insertDebugMarker('\u61ac');
} catch {}
let bindGroup58 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout21,
  entries: [{binding: 354, resource: externalTexture17}, {binding: 294, resource: textureView28}],
});
let textureView160 = texture201.createView({arrayLayerCount: 1});
try {
renderPassEncoder13.setIndexBuffer(buffer101, 'uint32', 0, 0);
} catch {}
try {
buffer11.unmap();
} catch {}
try {
device1.queue.writeBuffer(buffer31, 12, new Float64Array(5497).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/5495)), 536, 0);
} catch {}
let veryExplicitBindGroupLayout30 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' },
    },
    {binding: 59, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 139,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let renderPassEncoder21 = commandEncoder27.beginRenderPass({
  colorAttachments: [{
  view: textureView57,
  clearValue: { r: -597.7, g: -474.7, b: 390.2, a: 269.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 73545525,
});
try {
computePassEncoder39.setBindGroup(3, bindGroup47);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder23.setBindGroup(1, bindGroup2, []);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup17, new Uint32Array(99), 15, 0);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(1, buffer85);
} catch {}
let shaderModule13 = device0.createShaderModule({
  code: `
requires packed_4x8_integer_dot_product;

diagnostic(info, xyz);

enable f16;

requires unrestricted_pointer_parameters;

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

@group(0) @binding(16) var st13: texture_storage_2d_array<r32sint, read_write>;

/* used global variables: sam8, tex18 */
fn fn2() -> vec2<bool> {
  var out: vec2<bool>;
  out = vec2<bool>(vp8[unconst_u32(832105926)].whole.yz);
  var vf92: vec2u = textureDimensions(tex18);
  let vf93: u32 = override26;
  let vf94: vec2i = (vec2i(unconst_i32(168221582), unconst_i32(645078143)) >> vec2u(unconst_u32(784197145), unconst_u32(767132373)));
  vf92 = vec2u(vp8[3].fract.zz.xx);
  vf92 += bitcast<vec2u>(textureSampleGrad(tex18, sam8, vec2f(unconst_f32(0.08723e-23), unconst_f32(0.6000e-42)), vec2f(unconst_f32(0.5140), unconst_f32(0.1593e-34)), vec2f(unconst_f32(0.2874e17), unconst_f32(0.3715))).xy);
  return out;
  _ = override26;
  _ = tex18;
  _ = sam8;
}

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

/* used global variables: sam8 */
@must_use 
fn fn0(a0: texture_2d<f32>, a1: ptr<function, array<array<f16, 1>, 1>>) -> array<vec4h, 1> {
  var out: array<vec4h, 1>;
  let vf86: vec4<bool> = (vec4h(unconst_f16(1787.5), unconst_f16(-2236.9), unconst_f16(19308.9), unconst_f16(4935.6)) > vec4h(unconst_f16(-12116.2), unconst_f16(9663.1), unconst_f16(16400.7), unconst_f16(8279.1)));
  let vf87: vec3i = firstTrailingBit(vec3i(unconst_i32(145564940), unconst_i32(658697161), unconst_i32(88327445)));
  out[unconst_u32(55321925)] = vec4h(textureGather(3049878252 % 4, a0, sam8, vec2f(unconst_f32(0.1819e9), unconst_f32(0.02256))));
  let vf88: mat2x4h = (mat2x4h(unconst_f16(-24195.6), unconst_f16(314.6), unconst_f16(825.5), unconst_f16(7918.6), unconst_f16(24215.7), unconst_f16(9008.2), unconst_f16(18827.8), unconst_f16(23682.7)) * mat2x2h(unconst_f16(5378.0), unconst_f16(18403.9), unconst_f16(1489.4), unconst_f16(8577.6)));
  return out;
  _ = sam8;
}

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

var<private> vp8 = array(modf(vec3f(0.09878e-38, 0.2676, 0.04346)), modf(vec3f(0.1351e18, 0.08071, 0.2495)), modf(vec3f(0.6335, 0.2326e-32, 0.1026e-23)), modf(vec3f(-0.1456e28, 0.4491, 0.03939)));

struct VertexInput36 {
  @location(6) location_6: vec2h,
  @location(11) location_11: f32,
  @location(4) location_4: vec2h,
  @location(3) @interpolate(flat, center) location_3: vec2i,
  @location(10) @interpolate(linear, sample) location_10: vec2f,
}

struct VertexInput38 {
  @location(12) location_12: vec2h,
}

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

struct VertexInput34 {
  @location(0) @interpolate(flat) location_0: vec4i,
}

@group(1) @binding(0) var sam8: sampler;

struct FragmentInput21 {
  @location(0) @interpolate(flat, sample) location_0: vec4h,
}

@id(8983) override override26: u32;

struct FragmentInput19 {
  @location(7) location_7: i32,
}

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

struct FragmentOutput7 {
  @builtin(sample_mask) sample_mask: u32,
  @location(0) @interpolate(flat) location_0: vec4u,
  @location(7) @interpolate(flat) location_7: vec2u,
}

struct FragmentInput17 {
  @invariant @builtin(position) position: vec4f,
  @location(6) location_6: vec4i,
  @location(1) @interpolate(flat, center) location_1: vec2i,
  @location(15) location_15: vec2u,
}

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

/* used global variables: sam8, tex18 */
fn fn1() -> array<vec2h, 1> {
  var out: array<vec2h, 1>;
  {
  vp8[unconst_u32(1719614510)].fract = vec3f(out[unconst_u32(1054123092)].xxx.xxy.ggg.rbr);
  vp8[unconst_u32(421297187)] = vp8[unconst_u32(526357057)];
  let vf89: f16 = length(vec3h(unconst_f16(23658.8), unconst_f16(13770.1), unconst_f16(827.8)));
  vp8[u32(saturate(vec3f(unconst_f32(0.01283), unconst_f32(0.1176e-42), unconst_f32(0.1292)))[0])].fract = vec3f(f32(pack2x16float(vec2f(unconst_f32(0.04636e14), unconst_f32(0.1470e-38)))));
}
  let vf90: u32 = pack4xU8(vec4u(unconst_u32(309615500), unconst_u32(313548085), unconst_u32(441184373), unconst_u32(104011407)));
  let ptr60: ptr<function, array<vec2h, 1>> = &out;
  for (var jj79=0u; jj79<3; jj79++) { out[jj79] = vec2h(out[0][unconst_u32(157345829)]); }
  vp8[unconst_u32(63715434)] = modf(vec3f(f32(override26)));
  let vf91: vec4f = textureSampleGrad(tex18, sam8, vec2f(unconst_f32(0.1017), unconst_f32(0.1687)), vec2f(unconst_f32(0.02349e4), unconst_f32(0.04806e-9)), vec2f(unconst_f32(0.07945e-19), unconst_f32(0.1231)));
  out[unconst_u32(560002301)] = vec2h((*ptr60)[0][unconst_u32(326776003)]);
  return out;
  _ = override26;
  _ = sam8;
  _ = tex18;
}

var<private> vp9: vec4u = vec4u(468017230, 1770869621, 1306882354, 1128612659);

var<workgroup> vw27: atomic<i32>;

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

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

struct VertexInput37 {
  @location(14) location_14: vec2i,
}

struct T0 {
  f0: array<vec4<bool>>,
}

struct T5 {
  f0: array<u32>,
}

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

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

@group(0) @binding(19) var<uniform> buffer113: array<array<vec4u, 203>, 2>;

@group(0) @binding(20) var sam7: sampler;

alias vec3b = vec3<bool>;

struct VertexInput35 {
  @location(9) @interpolate(flat, sample) location_9: vec4u,
  @location(1) location_1: vec4f,
}

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

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

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

struct FragmentInput18 {
  @location(14) @interpolate(perspective, sample) location_14: vec2h,
  @builtin(front_facing) front_facing: bool,
  @builtin(sample_mask) sample_mask: u32,
  @location(12) @interpolate(linear, centroid) location_12: vec2f,
  @location(9) @interpolate(flat, center) location_9: vec4u,
  @location(10) @interpolate(perspective, center) location_10: vec2h,
  @location(13) location_13: vec4h,
  @location(3) @interpolate(flat, first) location_3: vec2f,
}

struct FragmentInput20 {
  @location(4) @interpolate(flat, centroid) location_4: vec2i,
}

/* used global variables: buffer113, sam8, tex18 */
@vertex
fn vertex8(a0: VertexInput34, @location(15) location_15: vec2i, a2: VertexInput35, @location(5) @interpolate(flat) location_5: vec4u, @location(2) @interpolate(perspective) location_2: f32, @location(8) location_8: f16, @location(7) @interpolate(flat) location_7: vec2f, a7: VertexInput36, a8: VertexInput37, @location(13) location_13: vec2h, a10: VertexInput38, @builtin(instance_index) instance_index: u32, @builtin(vertex_index) vertex_index: u32) -> VertexOutput4 {
  var out: VertexOutput4;
  let ptr61: ptr<uniform, array<array<vec4u, 203>, 2>> = &(*&buffer113);
  out.location_9 = bitcast<vec4u>(select(vec3f(unconst_f32(0.03714e24), unconst_f32(0.2844e-15), unconst_f32(0.07298)), vec3f(unconst_f32(0.07599e30), unconst_f32(-0.08460), unconst_f32(0.1484e-18)), vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false))).xyxy.rabb.brgr);
  let ptr62: ptr<uniform, array<vec4u, 203>> = &buffer113[1];
  out.location_4 -= vec2i(select(vec3f(unconst_f32(0.04030), unconst_f32(0.1907), unconst_f32(0.05084e-35)), vec3f(unconst_f32(0.05800), unconst_f32(0.01344e-2), unconst_f32(0.00209e-21)), vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false))).yy);
  vp9 <<= vec4u(a7.location_4.yxxy);
  if bool(textureSampleGrad(tex18, sam8, vec2f(unconst_f32(0.09600e-8), unconst_f32(0.00526)), vec2f(unconst_f32(0.8399), unconst_f32(0.1533e14)), vec2f(unconst_f32(-0.02591), unconst_f32(0.5369e26)))[1]) {
  let vf95: u32 = vertex_index;
  return out;
}
  var vf96: vec2h = a7.location_4;
  fn2();
  return out;
  _ = override26;
  _ = sam8;
  _ = tex18;
  _ = buffer113;
}

/* used global variables: buffer113, sam8, tex18 */
@fragment
fn fragment9(@location(11) location_11: vec4i, @location(2) location_2: f32, a2: FragmentInput17, @builtin(sample_index) sample_index: u32, a4: FragmentInput18, @location(5) location_5: vec2i, a6: FragmentInput19, a7: FragmentInput20, a8: FragmentInput21, @location(8) location_8: u32) -> FragmentOutput7 {
  var out: FragmentOutput7;
  let ptr63: ptr<uniform, vec4u> = &(*&buffer113)[1][unconst_u32(321781230)];
  var vf97 = fn2();
  var vf98 = fn2();
  while bool(pack4xU8Clamp(vp9)) {
  let ptr64: ptr<function, vec4u> = &out.location_0;
  break;
}
  return out;
  _ = override26;
  _ = sam8;
  _ = tex18;
  _ = buffer113;
}

/* used global variables: sam7, sam8, st13, tex18 */
@compute @workgroup_size(1, 1, 1)
fn compute15(@builtin(global_invocation_id) global_invocation_id: vec3u, a1: ComputeInput21, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) {
  if bool(textureGather(1582123240 % 4, tex18, sam7, vec2f(unconst_f32(0.08326e-23), unconst_f32(0.4191))).y) {
  let vf99: u32 = pack4xU8Clamp(vec4u(unconst_u32(703567102), unconst_u32(107182204), unconst_u32(9383223), unconst_u32(1158222260)));
  for (var it3=u32(transpose(mat3x2h(vec2h(vp8[3].fract.br.rg), vec2h(vp8[3].fract.zz.yy), vec2h(vp8[3].fract.rr)))[unconst_i32(0)].r); it3<(u32(all((vec2h(unconst_f16(6009.7), unconst_f16(-1394.0)) != vec2h(unconst_f16(3153.4), unconst_f16(4796.1))))) & 0xfff); it3++) {
  vp8[pack4xU8(bitcast<vec4u>(textureSampleGrad(tex18, sam8, vec2f(unconst_f32(-0.3975e-13), unconst_f32(0.00217e24)), vec2f(unconst_f32(0.09121e-34), unconst_f32(0.1452e-3)), vec2f(unconst_f32(0.07666e0), unconst_f32(0.07799))).aara))] = modf(vec3f(sin(vec3h(unconst_f16(4874.1), unconst_f16(11279.6), unconst_f16(2018.8)))));
  textureStore(st13, vec2i(unconst_i32(407006250), unconst_i32(213234037)), unconst_i32(-127239486), vec4i(vec4i(unconst_i32(557195362), unconst_i32(460574723), unconst_i32(227908240), unconst_i32(362979059))));
  return;
  _ = sam8;
  _ = st13;
  _ = tex18;
}
  textureStore(st13, vec2i(unconst_i32(442327822), unconst_i32(95947427)), unconst_i32(270996064), vec4i(vec4i(unconst_i32(142838145), unconst_i32(280315311), unconst_i32(196595683), unconst_i32(292111554))));
  vp8[pack4xU8(textureDimensions(tex18, unconst_i32(1429559892)).grrr)].whole = vec3f(vec3f(unconst_f32(0.3635e29), unconst_f32(0.2997), unconst_f32(0.1859e-20)));
  var vf100: f16 = cosh(unconst_f16(22515.3));
  var vf101 = fn2();
  _ = override26;
  _ = tex18;
  _ = st13;
  _ = sam8;
}
  fn1();
  vp9 = bitcast<vec4u>(vp8[3].whole.xzzx);
  switch vec4i(textureSampleBaseClampToEdge(tex18, sam7, vec2f(unconst_f32(0.06154), unconst_f32(0.2028e23))).bbgg.wzxy)[1] { 
  default {
  _ = fn2();
  _ = override26;
  _ = tex18;
  _ = sam8;
}
  }
  atomicMin(&vw27, unconst_i32(403975138));
  textureStore(st13, vec2i(unconst_i32(1906546658), unconst_i32(1307546676)), unconst_i32(11517660), vec4i(vec4i(unconst_i32(202946297), unconst_i32(466099226), unconst_i32(76038009), unconst_i32(210768458))));
  _ = fn2();
  var vf102 = fn1();
  textureStore(st13, vec2i(unconst_i32(142127690), unconst_i32(840959088)), unconst_i32(439064915), vec4i(vec4i(unconst_i32(404019771), unconst_i32(53974161), unconst_i32(142314912), unconst_i32(611249979))));
  let ptr65: ptr<function, array<vec2h, 1>> = &vf102;
  let vf103: vec4f = textureSampleLevel(tex18, sam8, vec2f(unconst_f32(0.3558), unconst_f32(0.05924)), unconst_f32(0.1334));
  _ = override26;
  _ = st13;
  _ = sam7;
  _ = tex18;
  _ = sam8;
}`,
});
let bindGroup59 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: sampler8}]});
let textureView161 = texture86.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 1});
try {
computePassEncoder5.setBindGroup(0, bindGroup44, new Uint32Array(4106), 1_149, 0);
} catch {}
try {
computePassEncoder1.end();
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer47, 20);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(1, buffer8);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 178, depthOrArrayLayers: 1}
*/
{
  source: videoFrame20,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture94,
  mipLevel: 0,
  origin: {x: 0, y: 10, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer114 = device0.createBuffer({size: 56, usage: GPUBufferUsage.STORAGE, mappedAtCreation: true});
let commandEncoder135 = device0.createCommandEncoder({});
let texture203 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 63},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup59);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer8, 284); };
} catch {}
try {
renderPassEncoder3.draw(0, 0);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer108, 4);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer92, 'uint32', 20, 13);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(1, buffer79, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer86, 0, new Float16Array(1288).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.111)), 10, 16);
} catch {}
let buffer115 = device1.createBuffer({
  size: 16,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture204 = device1.createTexture({
  size: {width: 1280},
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView162 = texture18.createView({dimension: '2d-array'});
try {
renderBundleEncoder23.setPipeline(pipeline1);
} catch {}
try {
commandEncoder127.resolveQuerySet(querySet0, 9, 5, buffer5, 0);
} catch {}
let buffer116 = device1.createBuffer({size: 88, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder136 = device1.createCommandEncoder();
let texture205 = device1.createTexture({
  size: [204, 1, 24],
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture206 = gpuCanvasContext0.getCurrentTexture();
let textureView163 = texture63.createView({});
try {
computePassEncoder20.setBindGroup(0, bindGroup49);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup17, new Uint32Array(671), 79, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup49, new Uint32Array(1339), 215, 0);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(0, buffer85, 8);
} catch {}
try {
buffer67.unmap();
} catch {}
try {
renderPassEncoder12.popDebugGroup();
} catch {}
let commandEncoder137 = device1.createCommandEncoder({});
try {
renderPassEncoder8.setIndexBuffer(buffer53, 'uint16', 48, 46);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer81, 'uint16', 0, 18);
} catch {}
let texture207 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder4.setBindGroup(2, bindGroup40, new Uint32Array(292), 113, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder41); computePassEncoder41.dispatchWorkgroupsIndirect(buffer0, 16); };
} catch {}
let commandEncoder138 = device0.createCommandEncoder({});
try {
computePassEncoder41.end();
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup13, new Uint32Array(933), 115, 0);
} catch {}
try {
renderPassEncoder3.drawIndexed(1, 0, 0, 260_140_976);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer108, 16);
} catch {}
try {
computePassEncoder40.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer102, 8, new Float32Array(28116).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.312)), 9568, 4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup60 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: {buffer: buffer49, size: 64}}],
});
let commandEncoder139 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder9.draw(0, 70, 0, 252_365_483);
} catch {}
try {
renderPassEncoder3.drawIndexed(1, 0, 0, 2_116_110_142);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(5, buffer89);
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup24, new Uint32Array(2870), 513, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder133.clearBuffer(buffer79);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer117 = device1.createBuffer({
  size: 48,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE,
});
let commandEncoder140 = device1.createCommandEncoder();
let texture208 = device1.createTexture({
  size: [2560],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder32.setBindGroup(0, bindGroup21, [0]);
} catch {}
let computePassEncoder49 = commandEncoder108.beginComputePass();
let renderPassEncoder22 = commandEncoder109.beginRenderPass({
  colorAttachments: [{
  view: textureView63,
  clearValue: { r: -203.8, g: 396.4, b: 226.3, a: 413.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder49.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder13.setBlendConstant({ r: -412.3, g: 277.2, b: -317.6, a: -42.22, });
} catch {}
try {
computePassEncoder33.popDebugGroup();
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
computePassEncoder40.end();
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer73, 0);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer108, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer109, 'uint32', 8, 20);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(6, buffer46);
} catch {}
try {
commandEncoder2.copyBufferToBuffer(buffer83, 24, buffer7, 4, 8);
} catch {}
try {
device0.queue.submit([commandBuffer11]);
} catch {}
let bindGroup61 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout23,
  entries: [
    {binding: 0, resource: textureView112},
    {binding: 2, resource: {buffer: buffer117}},
    {binding: 98, resource: textureView93},
  ],
});
let textureView164 = texture148.createView({});
let texture209 = device1.createTexture({
  label: '\u0a64\u{1fdc8}\u3b11\u380b\u020b\ufddf',
  size: [256, 256, 12],
  mipLevelCount: 5,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView165 = texture54.createView({aspect: 'all'});
try {
renderPassEncoder13.setBindGroup(3, bindGroup33, new Uint32Array(2676), 82, 1);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup2, new Uint32Array(1076), 93, 0);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline3);
} catch {}
try {
device1.queue.writeBuffer(buffer23, 0, new Float32Array(586).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.2998)), 21, 0);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 51, height: 1, depthOrArrayLayers: 26}
*/
{
  source: imageData7,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture58,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder141 = device1.createCommandEncoder({});
try {
computePassEncoder42.setBindGroup(1, bindGroup1, new Uint32Array(874), 417, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup51, new Uint32Array(107), 13, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(6, buffer90, 0, 5);
} catch {}
try {
buffer93.unmap();
} catch {}
try {
device1.queue.writeBuffer(buffer75, 0, new Float32Array(3970).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.698)), 124, 0);
} catch {}
let bindGroup62 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 1, resource: {buffer: buffer90, size: 12}},
    {binding: 0, resource: {buffer: buffer110}},
    {binding: 18, resource: textureView18},
  ],
});
let querySet2 = device1.createQuerySet({type: 'occlusion', count: 124});
let textureView166 = texture194.createView({dimension: 'cube', baseArrayLayer: 1});
let texture210 = device1.createTexture({size: [256, 256, 181], dimension: '3d', format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING});
try {
computePassEncoder20.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup21, [1536]);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup52, new Uint32Array(2892), 1_848, 0);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder35.setBindGroup(3, bindGroup31, new Uint32Array(269), 20, 0);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer98, 'uint16', 140, 65);
} catch {}
let bindGroup63 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [
    {binding: 1, resource: {buffer: buffer107}},
    {binding: 18, resource: textureView17},
    {binding: 0, resource: {buffer: buffer74, offset: 0, size: 724}},
  ],
});
let commandEncoder142 = device1.createCommandEncoder({});
let textureView167 = texture23.createView({baseMipLevel: 0});
let renderPassEncoder23 = commandEncoder96.beginRenderPass({
  colorAttachments: [{
  view: textureView102,
  clearValue: { r: -50.75, g: 345.1, b: 578.3, a: 218.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder39.setBindGroup(1, bindGroup17);
} catch {}
try {
renderBundleEncoder21.setBindGroup(3, bindGroup18, [0]);
} catch {}
try {
renderBundleEncoder35.setPipeline(pipeline3);
} catch {}
let imageData15 = new ImageData(84, 20);
let commandEncoder143 = device1.createCommandEncoder({});
let querySet3 = device1.createQuerySet({type: 'occlusion', count: 199});
try {
renderPassEncoder22.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder11.setBindGroup(2, bindGroup31);
} catch {}
try {
computePassEncoder16.insertDebugMarker('\ue49d');
} catch {}
try {
renderPassEncoder8.insertDebugMarker('\u90f2');
} catch {}
let texture211 = device0.createTexture({
  size: {width: 848, height: 1, depthOrArrayLayers: 25},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView168 = texture193.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer7, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer9, 'uint16', 4, 0);
} catch {}
try {
commandEncoder112.copyBufferToBuffer(buffer64, 0, buffer105, 16, 16);
} catch {}
document.body.append(canvas1);
let texture212 = device0.createTexture({size: [4, 712, 1], mipLevelCount: 3, format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder0.setBindGroup(1, bindGroup50);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup13, new Uint32Array(76), 0, 0);
} catch {}
try {
renderPassEncoder9.draw(0, 55, 0, 570_069_623);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer73, 16);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer46, 320, 1_656);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup10, new Uint32Array(5498), 214, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 424, height: 1, depthOrArrayLayers: 14}
*/
{
  source: imageData4,
  origin: { x: 2, y: 0 },
  flipY: true,
}, {
  texture: texture3,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let renderBundleEncoder42 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder4.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer8, 2_300);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(1, buffer2, 0, 113);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpte170m', transfer: 'smpte170m'} });
let bindGroup64 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout25,
  entries: [
    {binding: 0, resource: textureView111},
    {binding: 379, resource: {buffer: buffer110, offset: 0}},
    {binding: 1, resource: textureView18},
    {binding: 6, resource: textureView97},
    {binding: 68, resource: textureView45},
    {binding: 174, resource: sampler3},
    {binding: 3, resource: {buffer: buffer81}},
    {binding: 236, resource: textureView47},
  ],
});
let commandEncoder144 = device1.createCommandEncoder({});
let texture213 = device1.createTexture({
  size: [19],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView169 = texture62.createView({dimension: '3d'});
let computePassEncoder50 = commandEncoder110.beginComputePass();
try {
renderPassEncoder11.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder13.setBindGroup(2, bindGroup62);
} catch {}
try {
commandEncoder91.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 576 */
  offset: 576,
  bytesPerRow: 31488,
  rowsPerImage: 92,
  buffer: buffer77,
}, {
  texture: texture151,
  mipLevel: 1,
  origin: {x: 114, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 39, height: 41, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture15.label = '\u0070\u06e2\u08d7\u01c8\u0212';
} catch {}
try {
computePassEncoder33.setBindGroup(0, bindGroup49);
} catch {}
try {
computePassEncoder50.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer116, 'uint16', 4, 1);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer117, 'uint32', 12, 10);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let bindGroup65 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 0, resource: sampler0}]});
let buffer118 = device0.createBuffer({size: 700, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let commandEncoder145 = device0.createCommandEncoder({});
let externalTexture21 = device0.importExternalTexture({source: videoFrame16});
try {
computePassEncoder47.setBindGroup(0, bindGroup39);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer47, 20); };
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer54, 'uint16', 0, 11);
} catch {}
try {
renderBundleEncoder32.setVertexBuffer(4, buffer79);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
});
} catch {}
try {
computePassEncoder24.setBindGroup(0, bindGroup59);
} catch {}
try {
computePassEncoder3.setBindGroup(0, bindGroup38, new Uint32Array(1503), 283, 0);
} catch {}
try {
computePassEncoder28.end();
} catch {}
try {
renderPassEncoder0.drawIndexed(1, 0, 0, 795_586_299);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder29.setBindGroup(2, bindGroup36, new Uint32Array(5460), 1_471, 0);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer9, 'uint16', 4, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
await gc();
let bindGroup66 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 30, resource: {buffer: buffer79}},
    {binding: 13, resource: textureView108},
    {binding: 1, resource: textureView6},
    {binding: 103, resource: externalTexture2},
    {binding: 9, resource: textureView68},
  ],
});
let buffer119 = device0.createBuffer({size: 34, usage: GPUBufferUsage.UNIFORM});
let textureView170 = texture183.createView({format: 'r32sint', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 4});
let externalTexture22 = device0.importExternalTexture({source: videoFrame15});
try {
computePassEncoder47.setBindGroup(0, bindGroup24, new Uint32Array(277), 54, 0);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer73, 8);
} catch {}
try {
renderBundleEncoder16.drawIndirect(buffer7, 0);
} catch {}
try {
commandEncoder125.copyBufferToTexture({
  /* bytesInLastRow: 1120 widthInBlocks: 140 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 304 */
  offset: 304,
  buffer: buffer118,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 171, y: 0, z: 0},
  aspect: 'all',
}, {width: 140, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 0, new DataView(new ArrayBuffer(49236)), 755, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup67 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 1, resource: {buffer: buffer108}}]});
let commandEncoder146 = device0.createCommandEncoder({});
let textureView171 = texture174.createView({format: 'r32float'});
let texture214 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView172 = texture167.createView({});
try {
computePassEncoder48.setBindGroup(0, bindGroup59, new Uint32Array(50), 16, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, -987_246_902);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer8, 4_904);
} catch {}
try {
renderBundleEncoder16.draw(1, 1, 0, 1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let texture215 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 44},
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView173 = texture16.createView({dimension: '3d', mipLevelCount: 1});
let computePassEncoder51 = commandEncoder65.beginComputePass();
try {
computePassEncoder37.setBindGroup(1, bindGroup6);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder51.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 265_331_558);
} catch {}
try {
renderPassEncoder0.drawIndexedIndirect(buffer99, 12);
} catch {}
try {
renderPassEncoder0.drawIndirect(buffer7, 0);
} catch {}
try {
renderBundleEncoder16.drawIndexedIndirect(buffer73, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 0, new DataView(new ArrayBuffer(15100)), 1285, 4);
} catch {}
let texture216 = device0.createTexture({
  size: {width: 8, height: 1424, depthOrArrayLayers: 41},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
computePassEncoder24.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder0.end();
} catch {}
try {
renderPassEncoder9.draw(136, 0, 823_434_764);
} catch {}
try {
renderBundleEncoder16.draw(1, 2);
} catch {}
try {
renderBundleEncoder16.drawIndexedIndirect(buffer99, 124);
} catch {}
try {
renderBundleEncoder38.setIndexBuffer(buffer1, 'uint16', 10, 113);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture98,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(251).fill(3), /* required buffer size: 251 */
{offset: 251}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'unspecified', transfer: 'logSqrt'} });
let commandEncoder147 = device0.createCommandEncoder({});
let commandBuffer12 = commandEncoder43.finish();
let textureView174 = texture138.createView({label: '\u{1fcfa}\u4f58\u365b\ua230\u05cf\u6aa7\u{1fd4b}\ue064', dimension: 'cube', mipLevelCount: 1});
let texture217 = device0.createTexture({size: {width: 4}, dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.TEXTURE_BINDING});
let renderBundleEncoder43 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: false});
let renderBundle1 = renderBundleEncoder16.finish({});
let externalTexture23 = device0.importExternalTexture({source: videoFrame6});
try {
renderPassEncoder3.setBindGroup(0, bindGroup10, new Uint32Array(529), 10, 0);
} catch {}
try {
renderPassEncoder9.draw(256, 0, 587_368_990, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer8, 2_620);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer108, 0);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer64, 'uint32', 0, 3);
} catch {}
try {
renderBundleEncoder14.setBindGroup(1, bindGroup11);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture218 = device0.createTexture({
  size: {width: 1720, height: 176, depthOrArrayLayers: 1},
  format: 'astc-5x4-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView175 = texture174.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder52 = commandEncoder19.beginComputePass();
let renderBundle2 = renderBundleEncoder3.finish({});
try {
computePassEncoder5.setBindGroup(2, bindGroup20, []);
} catch {}
try {
computePassEncoder52.setPipeline(pipeline8);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(5, buffer8);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer48, 'uint16', 2, 0);
} catch {}
let texture219 = device0.createTexture({
  size: [424, 1, 1339],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView176 = texture175.createView({dimension: '2d-array', aspect: 'all'});
let computePassEncoder53 = commandEncoder100.beginComputePass();
try {
computePassEncoder53.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer112, 0, 24);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(337).fill(0), /* required buffer size: 337 */
{offset: 337, bytesPerRow: 45, rowsPerImage: 87}, {width: 0, height: 45, depthOrArrayLayers: 0});
} catch {}
let buffer120 = device0.createBuffer({size: 105, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder148 = device0.createCommandEncoder({});
try {
renderPassEncoder6.setBindGroup(1, bindGroup13, new Uint32Array(2021), 740, 0);
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, 47_794_392);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer0, 16);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer8, 144);
} catch {}
try {
renderBundleEncoder37.setBindGroup(3, bindGroup37, []);
} catch {}
let textureView177 = texture86.createView({format: 'rgba32sint', baseArrayLayer: 2, arrayLayerCount: 6});
try {
renderPassEncoder3.drawIndexed(0, 0, 0, 331_701_795);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer0, 0);
} catch {}
let commandEncoder149 = device1.createCommandEncoder({});
let textureView178 = texture143.createView({});
let texture220 = device1.createTexture({
  size: {width: 640, height: 1, depthOrArrayLayers: 75},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
renderBundleEncoder24.setBindGroup(2, bindGroup27);
} catch {}
let commandEncoder150 = device1.createCommandEncoder({});
let pipeline26 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule6,
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'src', dstFactor: 'dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}],
},
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex5',
    constants: {override19: 1},
    buffers: [
      {
        arrayStride: 32,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 0, shaderLocation: 15},
          {format: 'float16x4', offset: 4, shaderLocation: 12},
          {format: 'sint32', offset: 4, shaderLocation: 14},
          {format: 'uint16x4', offset: 4, shaderLocation: 6},
          {format: 'uint8x4', offset: 0, shaderLocation: 9},
          {format: 'sint8x2', offset: 2, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 8},
          {format: 'snorm16x2', offset: 20, shaderLocation: 3},
          {format: 'float32x2', offset: 0, shaderLocation: 13},
          {format: 'uint32', offset: 0, shaderLocation: 0},
          {format: 'float16x2', offset: 0, shaderLocation: 10},
          {format: 'snorm16x4', offset: 0, shaderLocation: 7},
          {format: 'sint8x2', offset: 8, shaderLocation: 2},
          {format: 'sint8x2', offset: 0, shaderLocation: 1},
          {format: 'uint16x4', offset: 4, shaderLocation: 4},
          {format: 'sint16x4', offset: 0, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front'},
});
try {
gpuCanvasContext5.unconfigure();
} catch {}
let img2 = await imageWithData(20, 110, '#10101010', '#20202020');
let buffer121 = device0.createBuffer({size: 464, usage: GPUBufferUsage.UNIFORM});
let commandEncoder151 = device0.createCommandEncoder();
try {
computePassEncoder24.setBindGroup(0, bindGroup48);
} catch {}
try {
computePassEncoder47.setBindGroup(1, bindGroup65, new Uint32Array(270), 7, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer108, 0); };
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup13, new Uint32Array(1333), 209, 0);
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, 304_918_838, 0);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer7, 16);
} catch {}
try {
renderBundleEncoder43.setIndexBuffer(buffer105, 'uint32', 12, 2);
} catch {}
try {
renderBundleEncoder32.setPipeline(pipeline9);
} catch {}
try {
buffer72.unmap();
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let commandEncoder152 = device1.createCommandEncoder({});
let texture221 = device1.createTexture({
  size: {width: 19, height: 20, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView179 = texture194.createView({dimension: '2d', baseArrayLayer: 1, arrayLayerCount: 1});
let externalTexture24 = device1.importExternalTexture({source: videoFrame0});
try {
computePassEncoder16.setBindGroup(0, bindGroup8, new Uint32Array(5446), 2_135, 0);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(4, buffer33);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte170m', transfer: 'iec6196624'} });
let bindGroup68 = device1.createBindGroup({
  label: '\u7b91\u{1fba6}',
  layout: veryExplicitBindGroupLayout26,
  entries: [
    {binding: 2, resource: {buffer: buffer110}},
    {binding: 98, resource: textureView13},
    {binding: 0, resource: textureView25},
  ],
});
let commandEncoder153 = device1.createCommandEncoder();
let sampler18 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 8,
});
try {
renderPassEncoder21.setIndexBuffer(buffer81, 'uint16', 26, 3);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device1.queue.writeBuffer(buffer115, 0, new DataView(new ArrayBuffer(3992)), 291, 0);
} catch {}
document.body.prepend(canvas2);
let bindGroup69 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [{binding: 294, resource: textureView79}, {binding: 354, resource: externalTexture15}],
});
let commandEncoder154 = device1.createCommandEncoder({});
let texture222 = device1.createTexture({
  size: [320, 1, 11],
  mipLevelCount: 5,
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let sampler19 = device1.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'});
try {
renderPassEncoder13.setVertexBuffer(4, buffer31);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(2, buffer31, 8);
} catch {}
try {
commandEncoder144.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1344 */
  offset: 1344,
  bytesPerRow: 5888,
  rowsPerImage: 311,
  buffer: buffer77,
}, {
  texture: texture169,
  mipLevel: 1,
  origin: {x: 5, y: 7, z: 0},
  aspect: 'all',
}, {width: 15, height: 44, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer12, 28, new Uint16Array(210).map((_, i) => i + 3), 2, 4);
} catch {}
let bindGroup70 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 0, resource: sampler8}]});
let commandEncoder155 = device0.createCommandEncoder({label: '\uaa8f\ub2d6\u90d7\u26d7\u{1f925}'});
let texture223 = device0.createTexture({
  size: [848, 1, 37],
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder48.setBindGroup(3, bindGroup39);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderBundleEncoder36.setIndexBuffer(buffer92, 'uint32', 8, 111);
} catch {}
let arrayBuffer0 = buffer114.getMappedRange();
try {
device0.queue.submit([commandBuffer12]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder156 = device0.createCommandEncoder({});
let texture224 = device0.createTexture({
  size: {width: 424, height: 1, depthOrArrayLayers: 9},
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView180 = texture175.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer99, 84); };
} catch {}
try {
renderPassEncoder9.draw(47, 0, 126_358_929);
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, -2_060_196_073);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer0, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer73, 4);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(1, buffer46, 20, 2_715);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 212, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData8,
  origin: { x: 0, y: 5 },
  flipY: true,
}, {
  texture: texture10,
  mipLevel: 1,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let commandBuffer13 = commandEncoder44.finish({});
let textureView181 = texture86.createView({format: 'rgba32sint', arrayLayerCount: 3});
let computePassEncoder54 = commandEncoder112.beginComputePass({timestampWrites: {querySet: querySet1}});
try {
renderPassEncoder9.drawIndexedIndirect(buffer0, 60);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer8, 532);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer112, 28);
} catch {}
try {
renderBundleEncoder2.drawIndirect(buffer8, 7_408);
} catch {}
try {
commandEncoder84.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 564 */
  offset: 564,
  bytesPerRow: 15872,
  buffer: buffer118,
}, {
  texture: texture167,
  mipLevel: 0,
  origin: {x: 0, y: 15, z: 0},
  aspect: 'all',
}, {width: 0, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder20.insertDebugMarker('\u0de7');
} catch {}
let bindGroup71 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 30, resource: {buffer: buffer95}},
    {binding: 1, resource: textureView6},
    {binding: 13, resource: textureView104},
    {binding: 9, resource: textureView68},
    {binding: 103, resource: externalTexture9},
  ],
});
let commandEncoder157 = device0.createCommandEncoder({});
let texture225 = device0.createTexture({
  size: [1362, 12, 20],
  mipLevelCount: 5,
  format: 'astc-6x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture226 = device0.createTexture({
  size: {width: 848},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView182 = texture75.createView({format: 'rgba16sint'});
try {
computePassEncoder54.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder2.drawIndexedIndirect(buffer99, 16);
} catch {}
try {
commandEncoder41.copyBufferToBuffer(buffer48, 0, buffer104, 0, 8);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let pipeline27 = device0.createComputePipeline({layout: pipelineLayout4, compute: {module: shaderModule0, entryPoint: 'compute2'}});
document.body.prepend(img0);
let imageBitmap2 = await createImageBitmap(videoFrame17);
let bindGroup72 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [
    {binding: 18, resource: textureView17},
    {binding: 1, resource: {buffer: buffer50, size: 8}},
    {binding: 0, resource: {buffer: buffer74, size: 1932}},
  ],
});
let commandEncoder158 = device1.createCommandEncoder({});
let texture227 = device1.createTexture({
  size: [1280, 1, 485],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView183 = texture99.createView({baseMipLevel: 0});
let sampler20 = device1.createSampler({mipmapFilter: 'linear', lodMaxClamp: 72.39});
try {
renderPassEncoder22.beginOcclusionQuery(60);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, buffer22);
} catch {}
try {
buffer77.unmap();
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let commandEncoder159 = device0.createCommandEncoder({});
let textureView184 = texture138.createView({dimension: 'cube-array', format: 'rgba16float', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 6});
try {
renderPassEncoder3.drawIndexedIndirect(buffer73, 4);
} catch {}
try {
renderBundleEncoder2.drawIndexedIndirect(buffer7, 24);
} catch {}
let commandEncoder160 = device1.createCommandEncoder({});
let texture228 = device1.createTexture({
  size: [51],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16sint'],
});
let computePassEncoder55 = commandEncoder77.beginComputePass();
try {
computePassEncoder55.setPipeline(pipeline15);
} catch {}
document.body.append(canvas0);
try {
computePassEncoder33.setBindGroup(0, bindGroup49, new Uint32Array(2803), 111, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer85, 0, 11);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let buffer122 = device1.createBuffer({size: 259, usage: GPUBufferUsage.STORAGE});
try {
renderPassEncoder13.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder40.setVertexBuffer(0, buffer22, 0, 99);
} catch {}
let commandEncoder161 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroupsIndirect(buffer0, 12); };
} catch {}
try {
renderPassEncoder9.draw(26, 0, 60_173_539);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer0, 24);
} catch {}
let autogeneratedBindGroupLayout10 = pipeline20.getBindGroupLayout(2);
let textureView185 = texture58.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 3});
let renderPassEncoder24 = commandEncoder128.beginRenderPass({
  colorAttachments: [{
  view: textureView57,
  clearValue: { r: 737.8, g: -626.9, b: 809.3, a: 492.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler21 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
computePassEncoder33.setBindGroup(0, bindGroup51, []);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup68, [0]);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup47);
} catch {}
try {
commandEncoder98.copyTextureToTexture({
  texture: texture58,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 12},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 3, y: 5, z: 147},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
canvas1.height = 991;
let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt2020', transfer: 'smpteSt4281'} });
try {
adapter0.label = '\u0ab0\u067e\u{1f712}';
} catch {}
let sampler22 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  lodMaxClamp: 61.79,
});
try {
computePassEncoder25.end();
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer47, 16);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(buffer112, 'uint16', 24, 3);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer123 = device1.createBuffer({size: 86, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder162 = device1.createCommandEncoder({});
let renderPassEncoder25 = commandEncoder114.beginRenderPass({colorAttachments: [{view: textureView63, loadOp: 'load', storeOp: 'store'}]});
let externalTexture25 = device1.importExternalTexture({source: videoFrame5});
try {
renderBundleEncoder23.setBindGroup(1, bindGroup61, [0]);
} catch {}
let commandEncoder163 = device0.createCommandEncoder({});
let textureView186 = texture225.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1});
let renderBundle3 = renderBundleEncoder2.finish({});
try {
computePassEncoder52.setBindGroup(0, bindGroup59, new Uint32Array(136), 5, 0);
} catch {}
try {
renderPassEncoder4.draw(0, 0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer47, 8);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 308, new Float32Array(5831).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7787)), 1424, 120);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup73 = device0.createBindGroup({
  label: '\u0034\u{1f6ab}\u387f',
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 103, resource: externalTexture2},
    {binding: 13, resource: textureView104},
    {binding: 30, resource: {buffer: buffer91, size: 16}},
    {binding: 1, resource: textureView6},
    {binding: 9, resource: textureView68},
  ],
});
let texture229 = device0.createTexture({size: [8, 1424, 1], format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_DST});
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer0, 204); };
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup26, new Uint32Array(375), 82, 0);
} catch {}
try {
renderPassEncoder9.draw(330, 0, 1_290_989_166);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer8, 2_544);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(1, buffer87);
} catch {}
let textureView187 = texture135.createView({dimension: '2d', baseArrayLayer: 0});
let texture230 = device1.createTexture({
  size: {width: 78, height: 82, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder11.setIndexBuffer(buffer32, 'uint16', 8, 0);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(6, buffer94, 108, 229);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 32, height: 32, depthOrArrayLayers: 12}
*/
{
  source: videoFrame22,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture209,
  mipLevel: 3,
  origin: {x: 8, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData16 = new ImageData(76, 4);
let textureView188 = texture127.createView({dimension: '3d'});
try {
computePassEncoder20.setBindGroup(3, bindGroup42);
} catch {}
try {
renderBundleEncoder40.setBindGroup(3, bindGroup17);
} catch {}
let bindGroup74 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: sampler1}]});
let buffer124 = device0.createBuffer({size: 48, usage: GPUBufferUsage.UNIFORM});
let commandBuffer14 = commandEncoder41.finish();
let textureView189 = texture158.createView({dimension: 'cube-array', baseArrayLayer: 0, arrayLayerCount: 6});
try {
computePassEncoder5.setBindGroup(2, bindGroup40);
} catch {}
try {
computePassEncoder5.setBindGroup(1, bindGroup12, new Uint32Array(5219), 841, 0);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline27);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup55, new Uint32Array(720), 300, 0);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer8, 864);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup10, new Uint32Array(1148), 186, 0);
} catch {}
try {
renderBundleEncoder7.draw(0, 0);
} catch {}
try {
renderBundleEncoder31.setIndexBuffer(buffer78, 'uint16', 8, 64);
} catch {}
try {
device0.queue.submit([commandBuffer14, commandBuffer13]);
} catch {}
let veryExplicitBindGroupLayout31 = device1.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 130,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 192,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 213,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 368,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 575,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
  ],
});
let buffer125 = device1.createBuffer({size: 248, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder164 = device1.createCommandEncoder({});
let texture231 = device1.createTexture({
  size: {width: 102},
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder23.setBindGroup(3, bindGroup64, new Uint32Array(1945), 238, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer31, 28, new Float32Array(1478).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.8319)), 136, 0);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 39, height: 41, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 1, y: 10 },
  flipY: true,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 25, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 4, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout32 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 68,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 174, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 236,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 379,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let bindGroup75 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout31,
  entries: [
    {binding: 13, resource: {buffer: buffer110}},
    {binding: 130, resource: textureView93},
    {binding: 368, resource: textureView140},
    {binding: 192, resource: textureView84},
    {binding: 575, resource: textureView91},
    {binding: 213, resource: textureView40},
    {binding: 0, resource: {buffer: buffer117}},
  ],
});
let texture232 = device1.createTexture({
  size: {width: 78, height: 82, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView190 = texture230.createView({format: 'rgba16float'});
try {
renderPassEncoder22.setIndexBuffer(buffer101, 'uint32', 0, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer22);
} catch {}
try {
buffer85.unmap();
} catch {}
try {
device1.queue.writeBuffer(buffer117, 4, new Float16Array(39149).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.08343)), 16053, 0);
} catch {}
let pipeline28 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {module: shaderModule6, targets: [{format: 'rgba16float'}]},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 48,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 0, shaderLocation: 9},
          {format: 'snorm16x4', offset: 4, shaderLocation: 7},
          {format: 'sint16x2', offset: 4, shaderLocation: 6},
          {format: 'sint8x4', offset: 4, shaderLocation: 5},
          {format: 'sint32x4', offset: 0, shaderLocation: 8},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 3},
          {format: 'unorm16x2', offset: 0, shaderLocation: 15},
          {format: 'sint32x3', offset: 8, shaderLocation: 12},
          {format: 'snorm16x4', offset: 8, shaderLocation: 1},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4},
          {format: 'sint8x4', offset: 0, shaderLocation: 14},
          {format: 'float32x2', offset: 0, shaderLocation: 2},
          {format: 'float16x4', offset: 4, shaderLocation: 10},
          {format: 'float32x2', offset: 8, shaderLocation: 0},
          {format: 'uint32x4', offset: 0, shaderLocation: 11},
          {format: 'uint32x2', offset: 0, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front'},
});
try {
computePassEncoder31.setBindGroup(0, bindGroup74, new Uint32Array(75), 8, 0);
} catch {}
try {
computePassEncoder6.end();
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, 529_574_013);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline23);
} catch {}
try {
commandEncoder133.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 460 */
  offset: 460,
  bytesPerRow: 22272,
  buffer: buffer46,
}, {width: 0, height: 78, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder79.copyTextureToTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 0, y: 108, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer118, 16, new Uint32Array(1358).map((_, i) => i * 1), 42, 4);
} catch {}
let commandEncoder165 = device1.createCommandEncoder({});
let texture233 = device1.createTexture({
  label: '\u3d77\u{1fbbb}\u{1fb5a}\ud5bd\u08a0\u0ccf\u{1f6aa}',
  size: [19, 20, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder50.setBindGroup(0, bindGroup63, []);
} catch {}
try {
renderPassEncoder23.setBindGroup(2, bindGroup0, []);
} catch {}
try {
commandEncoder123.resolveQuerySet(querySet2, 3, 2, buffer125, 0);
} catch {}
let promise12 = device1.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {mask: 0x6e363c9e},
  fragment: {
  module: shaderModule9,
  constants: {},
  targets: [{
  format: 'rgba16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg32float'}],
},
  vertex: {
    module: shaderModule9,
    constants: {override19: 1},
    buffers: [
      {
        arrayStride: 4,
        attributes: [
          {format: 'uint16x2', offset: 0, shaderLocation: 9},
          {format: 'uint32', offset: 0, shaderLocation: 6},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'snorm8x4', offset: 0, shaderLocation: 8},
          {format: 'float16x2', offset: 0, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 3},
          {format: 'uint8x4', offset: 0, shaderLocation: 0},
          {format: 'sint8x2', offset: 0, shaderLocation: 1},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12},
          {format: 'sint8x4', offset: 0, shaderLocation: 15},
          {format: 'sint32', offset: 0, shaderLocation: 14},
          {format: 'sint8x4', offset: 0, shaderLocation: 2},
          {format: 'float32', offset: 0, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 124,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x2', offset: 16, shaderLocation: 5},
          {format: 'sint32x2', offset: 12, shaderLocation: 11},
          {format: 'uint32x3', offset: 40, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'},
});
let bindGroup76 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 1, resource: {buffer: buffer80}}]});
let commandEncoder166 = device0.createCommandEncoder();
let texture234 = device0.createTexture({
  size: [848, 1, 1],
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture235 = gpuCanvasContext1.getCurrentTexture();
let textureView191 = texture181.createView({aspect: 'all', mipLevelCount: 2, arrayLayerCount: 1});
let renderBundle4 = renderBundleEncoder7.finish();
try {
computePassEncoder3.end();
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 0, 0, 82_174_223);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer0, 28);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(4, buffer46, 0);
} catch {}
try {
buffer8.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer105, 0, new Uint32Array(7116).map((_, i) => i * 10), 1268, 0);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
try {
adapter1.label = '\u1199\u764f\u{1fd13}\u71e0\u0ece\u51d0\u0818\uf826\u{1fba4}\u74f2';
} catch {}
let texture236 = device1.createTexture({
  size: {width: 640, height: 1, depthOrArrayLayers: 438},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView192 = texture63.createView({});
try {
renderPassEncoder25.setBindGroup(0, bindGroup69);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 19, height: 20, depthOrArrayLayers: 1}
*/
{
  source: videoFrame27,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture233,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture8.label = '\u{1fe3f}\u42ec\ue133\u7eb0\u0c3b\u0879\u{1fa74}\u4251';
} catch {}
let textureView193 = texture204.createView({label: '\u0362\u{1f6d8}\u6268', dimension: '1d', baseMipLevel: 0});
try {
renderPassEncoder22.endOcclusionQuery();
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline16);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer32);
} catch {}
try {
commandEncoder150.copyTextureToTexture({
  texture: texture146,
  mipLevel: 0,
  origin: {x: 0, y: 11, z: 0},
  aspect: 'all',
},
{
  texture: texture172,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 32, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer110, 7_336, new Uint32Array(23607).map((_, i) => i * 4), 7176, 300);
} catch {}
let textureView194 = texture108.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1});
try {
renderBundleEncoder19.setBindGroup(3, bindGroup62);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer32, 'uint16', 20, 8);
} catch {}
try {
device1.pushErrorScope('internal');
} catch {}
try {
device1.queue.writeBuffer(buffer65, 48, new Float32Array(20180).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.487)), 3557, 0);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(31); };
} catch {}
let autogeneratedBindGroupLayout11 = pipeline1.getBindGroupLayout(0);
let bindGroup77 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout18,
  entries: [{binding: 354, resource: externalTexture8}, {binding: 294, resource: textureView31}],
});
let commandEncoder167 = device1.createCommandEncoder({});
try {
computePassEncoder36.setBindGroup(1, bindGroup47);
} catch {}
try {
renderPassEncoder25.setBindGroup(2, bindGroup58, new Uint32Array(604), 67, 0);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer53, 'uint32', 180, 61);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer21);
} catch {}
try {
buffer69.unmap();
} catch {}
try {
commandEncoder127.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 54, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture135,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(2).fill(200), /* required buffer size: 2 */
{offset: 2}, {width: 94, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 19, height: 20, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas2,
  origin: { x: 78, y: 4 },
  flipY: true,
}, {
  texture: texture233,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
let bindGroup78 = device1.createBindGroup({layout: autogeneratedBindGroupLayout9, entries: [{binding: 98, resource: textureView179}]});
let renderBundleEncoder44 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float']});
try {
renderPassEncoder1.setPipeline(pipeline19);
} catch {}
try {
adapter0.label = '\u{1f65d}\u0f2f';
} catch {}
let commandEncoder168 = device0.createCommandEncoder({});
let renderPassEncoder26 = commandEncoder58.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: -679.0, g: 715.6, b: -583.3, a: -964.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
  timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 261},
});
try {
computePassEncoder52.setBindGroup(3, bindGroup48);
} catch {}
try {
renderPassEncoder3.draw(0, 0);
} catch {}
try {
renderPassEncoder4.drawIndexed(0, 0, 0, 30_882_928);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer73, 0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer0, 28);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer92, 'uint16', 14, 25);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(0, buffer79, 0, 1);
} catch {}
let commandEncoder169 = device1.createCommandEncoder();
try {
renderPassEncoder21.setIndexBuffer(buffer98, 'uint32', 20, 198);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(2, buffer33);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer101, 'uint32', 0, 0);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
try {
gpuCanvasContext4.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
let commandEncoder170 = device1.createCommandEncoder({});
let texture237 = device1.createTexture({
  size: {width: 204, height: 1, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder56 = commandEncoder162.beginComputePass();
try {
computePassEncoder49.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline15);
} catch {}
try {
buffer116.unmap();
} catch {}
try {
device1.queue.writeBuffer(buffer84, 8, new Float32Array(6372).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.689)), 1565, 0);
} catch {}
let imageBitmap3 = await createImageBitmap(videoFrame25);
let commandEncoder171 = device0.createCommandEncoder();
let texture238 = device0.createTexture({
  size: [1697, 1, 88],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let texture239 = gpuCanvasContext1.getCurrentTexture();
try {
{ clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroupsIndirect(buffer47, 0); };
} catch {}
try {
computePassEncoder5.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer0, 56);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer109, 'uint16', 122, 39);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(1, buffer46, 408, 297);
} catch {}
try {
renderBundleEncoder28.setBindGroup(0, bindGroup34, new Uint32Array(215), 15, 0);
} catch {}
try {
renderBundleEncoder22.draw(46, 0, 507_183_169);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(12); };
} catch {}
document.body.append(canvas2);
document.body.prepend(canvas0);
let buffer126 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView195 = texture3.createView({arrayLayerCount: 5});
let texture240 = device0.createTexture({size: [848, 1, 15], format: 'depth32float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView196 = texture202.createView({aspect: 'all', mipLevelCount: 1});
let renderPassEncoder27 = commandEncoder168.beginRenderPass({
  colorAttachments: [{
  view: textureView122,
  depthSlice: 1,
  clearValue: { r: -679.8, g: 768.7, b: -393.9, a: -722.7, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 49450184,
});
try {
renderPassEncoder9.setBindGroup(0, bindGroup24);
} catch {}
try {
renderPassEncoder6.draw(11, 0, 648_683_593);
} catch {}
try {
renderPassEncoder4.drawIndexed(7, 262, 0, 482_490_510, 1_557_977_451);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(0, buffer89, 0, 4);
} catch {}
try {
renderBundleEncoder39.setVertexBuffer(3, buffer8);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup79 = device1.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 2, resource: {buffer: buffer63}}]});
let commandEncoder172 = device1.createCommandEncoder({});
let textureView197 = texture110.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
renderBundleEncoder44.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(5, buffer61, 20);
} catch {}
try {
buffer31.unmap();
} catch {}
let commandEncoder173 = device1.createCommandEncoder({});
let textureView198 = texture50.createView({});
try {
renderPassEncoder10.setVertexBuffer(1, buffer22, 0, 56);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(4, buffer88, 0, 30);
} catch {}
try {
commandEncoder113.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3464 */
  offset: 3464,
  bytesPerRow: 49920,
  buffer: buffer77,
}, {
  texture: texture232,
  mipLevel: 1,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 32, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer30, 14_124, new DataView(new Uint8Array(7571).map((_, i) => i).buffer), 1030, 336);
} catch {}
document.body.append(canvas0);
try {
adapter1.label = '\u{1f64f}\u{1fd69}\ub937\u5648\u{1fa66}\uc114\u1131\ud2f3\u0139\u09d9';
} catch {}
let commandEncoder174 = device1.createCommandEncoder({});
try {
renderBundleEncoder25.setIndexBuffer(buffer32, 'uint32', 4, 10);
} catch {}
try {
device1.queue.writeBuffer(buffer65, 36, new DataView(new Uint8Array(32251).map((_, i) => i).buffer), 731, 4);
} catch {}
let imageData17 = new ImageData(12, 48);
let commandEncoder175 = device0.createCommandEncoder({});
let textureView199 = texture182.createView({});
try {
computePassEncoder24.setBindGroup(0, bindGroup3, new Uint32Array(1913), 168, 0);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer7, 28);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer10, 'uint16', 96, 9);
} catch {}
try {
renderBundleEncoder22.drawIndirect(buffer47, 12);
} catch {}
try {
computePassEncoder24.insertDebugMarker('\u{1fc18}');
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer73, 4);
} catch {}
try {
  await shaderModule7.getCompilationInfo();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 80}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 1, y: 6, z: 11},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView200 = texture39.createView({aspect: 'all', format: 'rgba16float', baseMipLevel: 0});
try {
{ clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer99, 56); };
} catch {}
try {
renderPassEncoder6.drawIndexed(2, 0, 0, 281_678_204);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer8, 7_080);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup45, new Uint32Array(783), 23, 0);
} catch {}
try {
buffer119.unmap();
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
let texture241 = device1.createTexture({
  size: [19, 20, 1],
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView201 = texture221.createView({baseArrayLayer: 0});
try {
computePassEncoder42.setBindGroup(0, bindGroup4, new Uint32Array(685), 229, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, buffer88);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture114,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(139).fill(31), /* required buffer size: 139 */
{offset: 139, bytesPerRow: 245}, {width: 22, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpte240m', transfer: 'logSqrt'} });
let commandEncoder176 = device0.createCommandEncoder({});
try {
computePassEncoder48.setBindGroup(0, bindGroup74, new Uint32Array(722), 179, 0);
} catch {}
try {
renderPassEncoder4.draw(0, 250, 0, 2_372_713_297);
} catch {}
try {
renderPassEncoder4.drawIndexed(6, 322, 0, 761_688_802, 556_418_606);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer99, 32);
} catch {}
try {
renderBundleEncoder39.setBindGroup(1, bindGroup44);
} catch {}
try {
renderBundleEncoder22.draw(178, 0, 441_811_125);
} catch {}
try {
renderBundleEncoder22.drawIndirect(buffer73, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer79, 40, new BigInt64Array(19623).map((_, i) => BigInt(i - 9)), 1711, 8);
} catch {}
let bindGroup80 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: sampler0}]});
let commandEncoder177 = device0.createCommandEncoder({});
let textureView202 = texture223.createView({aspect: 'depth-only', baseArrayLayer: 4, arrayLayerCount: 2});
try {
computePassEncoder44.setBindGroup(3, bindGroup29);
} catch {}
try {
renderPassEncoder3.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1, 0, 0, 56_411_675);
} catch {}
try {
renderBundleEncoder22.drawIndexedIndirect(buffer47, 16);
} catch {}
try {
renderBundleEncoder22.drawIndirect(buffer99, 12);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let pipeline29 = device0.createRenderPipeline({
  layout: pipelineLayout4,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {module: shaderModule7, targets: [{format: 'rgba16float'}]},
  vertex: {
    module: shaderModule12,
    entryPoint: 'vertex7',
    constants: {},
    buffers: [
      {
        arrayStride: 20,
        attributes: [
          {format: 'sint16x4', offset: 0, shaderLocation: 14},
          {format: 'snorm8x4', offset: 4, shaderLocation: 3},
          {format: 'sint16x2', offset: 0, shaderLocation: 5},
          {format: 'snorm16x4', offset: 0, shaderLocation: 6},
          {format: 'snorm16x4', offset: 0, shaderLocation: 12},
          {format: 'float32x3', offset: 0, shaderLocation: 9},
          {format: 'unorm16x2', offset: 0, shaderLocation: 15},
          {format: 'unorm16x4', offset: 0, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back'},
});
let veryExplicitBindGroupLayout33 = device1.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 49,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 65,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 77, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 371,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let texture242 = device1.createTexture({
  size: {width: 19, height: 20, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder45 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], stencilReadOnly: true});
try {
computePassEncoder56.setBindGroup(2, bindGroup1, new Uint32Array(1241), 303, 0);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer117, 'uint32', 0, 2);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer33, 0);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(0, buffer32);
} catch {}
let commandEncoder178 = device0.createCommandEncoder({});
try {
renderPassEncoder4.drawIndexedIndirect(buffer8, 1_428);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer7, 32);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup74);
} catch {}
try {
renderBundleEncoder22.drawIndirect(buffer108, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer105, 8, new Float32Array(2793).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6947)), 230, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture183,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(1_857_383).fill(141), /* required buffer size: 1_857_383 */
{offset: 87, bytesPerRow: 721, rowsPerImage: 161}, {width: 176, height: 0, depthOrArrayLayers: 17});
} catch {}
let commandEncoder179 = device1.createCommandEncoder({});
let sampler23 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 92.99,
  compare: 'never',
});
try {
{ clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroupsIndirect(buffer115, 0); };
} catch {}
try {
renderPassEncoder21.insertDebugMarker('\u42e5');
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let bindGroup81 = device0.createBindGroup({layout: autogeneratedBindGroupLayout8, entries: [{binding: 0, resource: sampler1}]});
try {
{ clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroupsIndirect(buffer73, 0); };
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer108, 0);
} catch {}
try {
renderBundleEncoder22.drawIndirect(buffer47, 32);
} catch {}
try {
commandEncoder157.insertDebugMarker('\u02c6');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer79, 4, new Float64Array(4038).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/4035)), 132, 8);
} catch {}
let bindGroup82 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 31, resource: externalTexture13},
    {binding: 120, resource: textureView65},
    {binding: 138, resource: sampler20},
    {binding: 0, resource: sampler23},
    {binding: 2, resource: textureView101},
    {binding: 16, resource: sampler17},
    {binding: 62, resource: textureView185},
    {binding: 1, resource: textureView62},
  ],
});
let buffer127 = device1.createBuffer({size: 218, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture243 = device1.createTexture({
  size: [19],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder42.setBindGroup(0, bindGroup2, []);
} catch {}
try {
renderBundleEncoder40.setPipeline(pipeline24);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture243,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(95).fill(138), /* required buffer size: 95 */
{offset: 95}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup83 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 1, resource: {buffer: buffer86}}]});
let textureView203 = texture75.createView({});
try {
renderPassEncoder9.draw(254, 0, 84_426_101);
} catch {}
try {
renderPassEncoder4.drawIndexed(9, 39, 0, 383_479_704, 1_166_179_339);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer0, 140);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer108, 0);
} catch {}
try {
renderBundleEncoder26.setBindGroup(2, bindGroup39);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(2, buffer89, 0, 56);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let bindGroup84 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout14,
  entries: [
    {binding: 1, resource: textureView195},
    {binding: 13, resource: textureView104},
    {binding: 30, resource: {buffer: buffer49, size: 44}},
    {binding: 9, resource: textureView68},
    {binding: 103, resource: externalTexture23},
  ],
});
let buffer128 = device0.createBuffer({size: 101, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
let commandBuffer15 = commandEncoder60.finish({});
let texture244 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST,
});
try {
renderPassEncoder4.drawIndirect(buffer99, 20);
} catch {}
try {
renderBundleEncoder22.draw(30, 0, 227_311_008);
} catch {}
try {
renderBundleEncoder32.setVertexBuffer(0, buffer2, 0, 1);
} catch {}
let bindGroup85 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 1, resource: {buffer: buffer71}}]});
let commandEncoder180 = device0.createCommandEncoder({});
let textureView204 = texture98.createView({format: 'rgba16float', baseMipLevel: 0});
let renderBundle5 = renderBundleEncoder22.finish();
try {
computePassEncoder5.setBindGroup(0, bindGroup32);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup60, new Uint32Array(3950), 1_063, 0);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer108, 0);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer73, 12);
} catch {}
try {
renderBundleEncoder33.setBindGroup(3, bindGroup80);
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 27}
*/
{
  source: img2,
  origin: { x: 0, y: 8 },
  flipY: true,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
let commandEncoder181 = device0.createCommandEncoder({});
let renderBundleEncoder46 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']});
try {
computePassEncoder45.setBindGroup(1, bindGroup32, new Uint32Array(6491), 1_640, 0);
} catch {}
try {
renderPassEncoder6.draw(62, 0, 4_294_967_233);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 0, 0, 53_593_609);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer9, 'uint32', 0, 6);
} catch {}
try {
renderBundleEncoder33.setBindGroup(1, bindGroup13);
} catch {}
try {
renderBundleEncoder32.setIndexBuffer(buffer4, 'uint16', 6, 5);
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let texture245 = device1.createTexture({
  size: {width: 320, height: 1, depthOrArrayLayers: 1},
  format: 'rg32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let texture246 = gpuCanvasContext0.getCurrentTexture();
let sampler24 = device1.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'equal',
  maxAnisotropy: 6,
});
try {
renderPassEncoder21.setBindGroup(3, bindGroup77);
} catch {}
let buffer129 = device0.createBuffer({
  size: 420,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView205 = texture234.createView({});
let texture247 = device0.createTexture({
  size: [4, 712, 1],
  mipLevelCount: 2,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder31.setBindGroup(2, bindGroup71);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroupsIndirect(buffer108, 4); };
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup34, new Uint32Array(2623), 161, 0);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle4, renderBundle1]);
} catch {}
try {
renderPassEncoder9.draw(162, 0, 1_114_075_679);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer108, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer4, 'uint32', 4, 1);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer129, 'uint16', 92, 43);
} catch {}
try {
renderBundleEncoder37.setVertexBuffer(4, buffer2, 8, 55);
} catch {}
try {
device0.queue.writeBuffer(buffer104, 8, new Float64Array(32830).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/32827)), 2831, 0);
} catch {}
let veryExplicitBindGroupLayout34 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 155,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 56, hasDynamicOffset: true },
    },
    {
      binding: 264,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder182 = device1.createCommandEncoder({});
let textureView206 = texture139.createView({});
let textureView207 = texture220.createView({format: 'rgba16float', mipLevelCount: 1});
try {
computePassEncoder22.setBindGroup(0, bindGroup33, [0]);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder24.setVertexBuffer(7, buffer33, 4, 19);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
  await promise14;
} catch {}
document.body.prepend(img1);
try {
globalThis.someLabel = commandEncoder47.label;
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer7, 0); };
} catch {}
try {
computePassEncoder9.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder4.draw(0, 613, 0, 149_367_355);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer73, 0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer108, 28);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline23);
} catch {}
try {
renderBundleEncoder29.setBindGroup(2, bindGroup10, []);
} catch {}
try {
renderBundleEncoder42.setPipeline(pipeline17);
} catch {}
try {
commandEncoder180.copyBufferToBuffer(buffer129, 60, buffer104, 4, 12);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.submit([commandBuffer15]);
} catch {}
document.body.append(canvas1);
let commandEncoder183 = device1.createCommandEncoder({});
let textureView208 = texture131.createView({baseArrayLayer: 0});
try {
renderPassEncoder12.setIndexBuffer(buffer81, 'uint32', 12, 4);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(2, buffer32, 4, 10);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup78);
} catch {}
offscreenCanvas0.height = 246;
let veryExplicitBindGroupLayout35 = device1.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 13,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 130,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 192,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 213,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 368,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 575,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' },
    },
  ],
});
let bindGroup86 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout17,
  entries: [{binding: 0, resource: {buffer: buffer63}}, {binding: 2, resource: {buffer: buffer110, offset: 7680}}],
});
let buffer130 = device1.createBuffer({size: 560, usage: GPUBufferUsage.QUERY_RESOLVE});
let texture248 = device1.createTexture({
  label: '\u7301\u06af\u{1fdd2}\u09d0\u0399\u6f96\ub247\uca22\u1318',
  size: {width: 102, height: 1, depthOrArrayLayers: 690},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder14.setBindGroup(0, bindGroup42, new Uint32Array(3866), 583, 0);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(2, buffer94, 72);
} catch {}
let commandEncoder184 = device1.createCommandEncoder({});
let textureView209 = texture194.createView({dimension: 'cube', baseArrayLayer: 0});
try {
computePassEncoder46.setBindGroup(1, bindGroup78, new Uint32Array(301), 35, 0);
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline26);
} catch {}
try {
device1.queue.writeBuffer(buffer115, 8, new DataView(new ArrayBuffer(94300)), 19, 0);
} catch {}
try {
  await promise13;
} catch {}
document.body.append(canvas0);
let bindGroup87 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [{binding: 354, resource: externalTexture24}, {binding: 294, resource: textureView31}],
});
let commandEncoder185 = device1.createCommandEncoder({});
try {
renderPassEncoder12.setBindGroup(0, bindGroup47, new Uint32Array(383), 81, 0);
} catch {}
try {
renderBundleEncoder40.setPipeline(pipeline24);
} catch {}
try {
commandEncoder103.copyBufferToTexture({
  /* bytesInLastRow: 744 widthInBlocks: 93 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 520 */
  offset: 520,
  bytesPerRow: 4864,
  buffer: buffer77,
}, {
  texture: texture135,
  mipLevel: 0,
  origin: {x: 146, y: 0, z: 1},
  aspect: 'all',
}, {width: 93, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer115, 8, new DataView(new ArrayBuffer(86344)), 1520, 0);
} catch {}
document.body.append(canvas0);
await gc();
let bindGroup88 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout4,
  entries: [
    {binding: 1, resource: textureView6},
    {binding: 103, resource: externalTexture3},
    {binding: 9, resource: textureView68},
    {binding: 13, resource: textureView108},
    {binding: 30, resource: {buffer: buffer91, size: 20}},
  ],
});
let commandEncoder186 = device0.createCommandEncoder({});
let texture249 = device0.createTexture({
  size: [4, 712, 1],
  mipLevelCount: 4,
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
renderPassEncoder2.setBindGroup(0, bindGroup20);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup15, new Uint32Array(3202), 415, 0);
} catch {}
try {
renderPassEncoder3.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 0, 0, 35_558_182);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer73, 24);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline23);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(0, buffer2, 0, 23);
} catch {}
try {
bindGroup60.label = '';
} catch {}
let bindGroup89 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 1, resource: textureView6},
    {binding: 13, resource: textureView51},
    {binding: 30, resource: {buffer: buffer91, size: 20}},
    {binding: 103, resource: externalTexture16},
    {binding: 9, resource: textureView68},
  ],
});
let querySet4 = device0.createQuerySet({type: 'occlusion', count: 1283});
let textureView210 = texture179.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder17.setBindGroup(2, bindGroup37, new Uint32Array(4489), 1_171, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 0, 0, 448_397_125);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer73, 'uint32', 20, 23);
} catch {}
try {
buffer108.unmap();
} catch {}
try {
commandEncoder176.resolveQuerySet(querySet4, 135, 3, buffer1, 0);
} catch {}
let commandEncoder187 = device0.createCommandEncoder({});
let texture250 = device0.createTexture({size: [1697], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING});
try {
computePassEncoder54.setBindGroup(1, bindGroup43);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 0, 0, 853_171_354, 0);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer8, 552);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer108, 8);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer64, 'uint16', 0, 25);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline11);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 356, depthOrArrayLayers: 1}
*/
{
  source: imageData13,
  origin: { x: 38, y: 2 },
  flipY: false,
}, {
  texture: texture17,
  mipLevel: 0,
  origin: {x: 0, y: 39, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer131 = device1.createBuffer({
  size: 44,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder188 = device1.createCommandEncoder();
let texture251 = device1.createTexture({
  size: {width: 320, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView211 = texture97.createView({aspect: 'all', baseArrayLayer: 0});
try {
{ clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroupsIndirect(buffer51, 64); };
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(4, buffer31, 0);
} catch {}
let buffer132 = device1.createBuffer({
  label: '\u{1f8ab}\u313a\u0585\uaefe\u{1fc7d}\u78a7\ufcde\u0fb4\u{1fcb6}',
  size: 4,
  usage: GPUBufferUsage.INDEX,
});
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
try {
computePassEncoder54.setBindGroup(3, bindGroup84, new Uint32Array(430), 3, 0);
} catch {}
try {
renderPassEncoder3.draw(0, 0);
} catch {}
try {
renderPassEncoder3.drawIndexed(0, 0, 0, 447_753_555);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(0, buffer89);
} catch {}
try {
renderBundleEncoder32.setPipeline(pipeline29);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(0, buffer112, 0, 35);
} catch {}
try {
commandEncoder181.copyTextureToTexture({
  texture: texture126,
  mipLevel: 0,
  origin: {x: 436, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture152,
  mipLevel: 1,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
},
{width: 135, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder189 = device1.createCommandEncoder({});
let texture252 = device1.createTexture({
  size: {width: 51},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder42.end();
} catch {}
try {
computePassEncoder36.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup8);
} catch {}
let commandEncoder190 = device1.createCommandEncoder({});
try {
renderPassEncoder13.setVertexBuffer(0, buffer50, 0, 20);
} catch {}
try {
renderBundleEncoder18.setBindGroup(3, bindGroup58, new Uint32Array(1929), 30, 0);
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
let imageBitmap4 = await createImageBitmap(videoFrame6);
let autogeneratedBindGroupLayout12 = pipeline14.getBindGroupLayout(0);
let buffer133 = device0.createBuffer({size: 352, usage: GPUBufferUsage.COPY_DST});
let commandEncoder191 = device0.createCommandEncoder({});
let texture253 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder3.drawIndexedIndirect(buffer8, 1_556);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer7, 52);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup24);
} catch {}
let commandEncoder192 = device0.createCommandEncoder({});
let textureView212 = texture219.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroupsIndirect(buffer49, 44); };
} catch {}
try {
renderPassEncoder20.setBindGroup(3, bindGroup41);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer99, 56);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer73, 'uint32', 12, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer72, 4, new Uint32Array(1809).map((_, i) => i * 10), 32, 0);
} catch {}
let texture254 = device0.createTexture({
  size: {width: 2, height: 356, depthOrArrayLayers: 1},
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder57 = commandEncoder29.beginComputePass();
try {
computePassEncoder57.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup6, new Uint32Array(1303), 345, 0);
} catch {}
try {
renderPassEncoder4.draw(0, 104, 0, 676_558_939);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer73, 'uint16', 0, 8);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer89, 0);
} catch {}
let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470bg', transfer: 'iec61966-2-1'} });
let autogeneratedBindGroupLayout13 = pipeline13.getBindGroupLayout(0);
let commandEncoder193 = device1.createCommandEncoder({});
let textureView213 = texture248.createView({});
let computePassEncoder58 = commandEncoder174.beginComputePass();
try {
computePassEncoder58.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer81, 'uint16', 38, 4);
} catch {}
let commandBuffer16 = commandEncoder35.finish();
let texture255 = device0.createTexture({
  size: [1],
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView214 = texture3.createView({dimension: '2d', baseArrayLayer: 0});
try {
renderPassEncoder26.setBindGroup(0, bindGroup6);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer99, 48);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer128, 8);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline11);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(461).fill(53), /* required buffer size: 461 */
{offset: 461, rowsPerImage: 84}, {width: 150, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap5 = await createImageBitmap(canvas0);
let texture256 = device0.createTexture({
  label: '\u19b1\u{1fde2}\u0871\u051b\u{1f91c}\u0867',
  size: {width: 16, height: 16, depthOrArrayLayers: 27},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder18.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer0, 8);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let bindGroup90 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 1, resource: {buffer: buffer91, size: 48}}],
});
let buffer134 = device0.createBuffer({size: 268, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder194 = device0.createCommandEncoder({});
let textureView215 = texture254.createView({label: '\u{1fb2e}\u3357\u19f8\u{1f872}', arrayLayerCount: 1});
let texture257 = device0.createTexture({
  size: {width: 2, height: 356, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder31.setBindGroup(0, bindGroup74, new Uint32Array(2579), 330, 0);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer108, 0);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(1, buffer89, 0, 13);
} catch {}
try {
device0.queue.writeBuffer(buffer73, 68, new DataView(new ArrayBuffer(8964)), 179, 0);
} catch {}
let externalTexture26 = device1.importExternalTexture({source: videoFrame0});
try {
computePassEncoder33.setBindGroup(1, bindGroup58);
} catch {}
try {
renderBundleEncoder40.setIndexBuffer(buffer101, 'uint16', 0, 0);
} catch {}
let pipeline30 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule1,
  constants: {},
  targets: [{format: 'rgba16float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule6,
    constants: {},
    buffers: [
      {
        arrayStride: 92,
        attributes: [
          {format: 'unorm16x4', offset: 4, shaderLocation: 14},
          {format: 'sint8x2', offset: 8, shaderLocation: 9},
          {format: 'sint8x2', offset: 78, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 24, shaderLocation: 13},
          {format: 'uint8x2', offset: 16, shaderLocation: 6},
          {format: 'unorm8x2', offset: 6, shaderLocation: 11},
          {format: 'sint8x2', offset: 8, shaderLocation: 7},
          {format: 'uint32x4', offset: 12, shaderLocation: 0},
          {format: 'uint32x2', offset: 4, shaderLocation: 1},
          {format: 'uint32x2', offset: 0, shaderLocation: 15},
          {format: 'snorm8x2', offset: 18, shaderLocation: 2},
        ],
      },
      {
        arrayStride: 608,
        attributes: [
          {format: 'sint16x2', offset: 8, shaderLocation: 3},
          {format: 'uint16x2', offset: 260, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list'},
});
document.body.prepend(img2);
let buffer135 = device1.createBuffer({size: 128, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM});
let commandEncoder195 = device1.createCommandEncoder({});
try {
renderPassEncoder24.setPipeline(pipeline16);
} catch {}
let buffer136 = device0.createBuffer({size: 15604, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let texture258 = device0.createTexture({
  size: {width: 4, height: 712, depthOrArrayLayers: 1},
  format: 'rgba32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder9.drawIndexedIndirect(buffer128, 28);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer0, 8);
} catch {}
try {
renderBundleEncoder27.setBindGroup(0, bindGroup60, new Uint32Array(31), 1, 0);
} catch {}
let pipeline31 = device0.createRenderPipeline({
  layout: pipelineLayout1,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule8,
  constants: {override16: 1, override17: 1},
  targets: [{format: 'rgba16float', writeMask: 0}],
},
  vertex: {
    module: shaderModule12,
    constants: {},
    buffers: [
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 0, shaderLocation: 5},
          {format: 'unorm8x2', offset: 4, shaderLocation: 15},
          {format: 'float32x3', offset: 0, shaderLocation: 4},
          {format: 'float32x3', offset: 0, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 6},
          {format: 'sint16x4', offset: 0, shaderLocation: 14},
          {format: 'snorm16x4', offset: 0, shaderLocation: 10},
          {format: 'snorm16x2', offset: 4, shaderLocation: 13},
          {format: 'float32', offset: 0, shaderLocation: 3},
          {format: 'unorm8x2', offset: 4, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
document.body.prepend(canvas2);
let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpte240m', transfer: 'linear'} });
let textureView216 = texture255.createView({baseMipLevel: 0});
let computePassEncoder59 = commandEncoder3.beginComputePass();
try {
renderPassEncoder2.drawIndexedIndirect(buffer108, 8);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer7, 0);
} catch {}
try {
renderBundleEncoder27.draw(1, 59, 0, 181_225_572);
} catch {}
try {
buffer83.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer46, 316, new Uint16Array(1674).map((_, i) => i + 6));
} catch {}
try {
externalTexture17.label = '\u7838\u0c67\u{1f750}\u0968\u7915\ub7e2';
} catch {}
let commandEncoder196 = device1.createCommandEncoder({});
let texture259 = device1.createTexture({
  size: [1280],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let externalTexture27 = device1.importExternalTexture({source: videoFrame30});
try {
renderPassEncoder25.setBindGroup(0, bindGroup2);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
device1.queue.submit([]);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 20, new Float32Array(22102).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.077)), 1374, 4);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let imageBitmap6 = await createImageBitmap(videoFrame11);
let commandEncoder197 = device0.createCommandEncoder();
let textureView217 = texture254.createView({mipLevelCount: 1});
let texture260 = gpuCanvasContext2.getCurrentTexture();
let renderBundleEncoder47 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthStencilFormat: 'depth32float', stencilReadOnly: true});
let sampler25 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 12.96,
});
try {
computePassEncoder31.setBindGroup(0, bindGroup59, []);
} catch {}
try {
renderPassEncoder3.draw(0, 0);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer47, 12);
} catch {}
try {
renderBundleEncoder27.draw(1, 183, 0, 91_675_202);
} catch {}
try {
renderBundleEncoder28.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(6, buffer2, 0, 17);
} catch {}
try {
commandEncoder187.copyBufferToBuffer(buffer64, 0, buffer86, 0, 0);
} catch {}
try {
renderBundleEncoder34.insertDebugMarker('\u872d');
} catch {}
try {
device0.queue.writeBuffer(buffer129, 44, new Uint32Array(9075).map((_, i) => i * 9), 1429, 4);
} catch {}
try {
externalTexture9.label = '';
} catch {}
let textureView218 = texture256.createView({label: '\ua8cc\u066c\u1571\u5c47\uff81\u{1fba7}\u{1f987}\u0d15', dimension: '2d'});
let textureView219 = texture181.createView({dimension: '2d', format: 'rgb10a2uint', mipLevelCount: 1, baseArrayLayer: 0});
let sampler26 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 38.19,
  compare: 'less-equal',
});
try {
{ clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder5.setPipeline(pipeline18);
} catch {}
try {
computePassEncoder59.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder26.draw(0, 0);
} catch {}
try {
renderBundleEncoder27.drawIndirect(buffer49, 44);
} catch {}
try {
device0.queue.writeBuffer(buffer72, 4, new BigInt64Array(8426).map((_, i) => BigInt(i - 0)), 725, 0);
} catch {}
let pipeline32 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout0,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule7,
  targets: [{
  format: 'rgba16float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule7,
    entryPoint: 'vertex3',
    constants: {},
    buffers: [
      {
        arrayStride: 28,
        attributes: [
          {format: 'float32', offset: 4, shaderLocation: 9},
          {format: 'uint16x2', offset: 0, shaderLocation: 10},
          {format: 'uint16x2', offset: 0, shaderLocation: 3},
          {format: 'uint16x2', offset: 0, shaderLocation: 8},
          {format: 'float32', offset: 0, shaderLocation: 12},
          {format: 'float32x3', offset: 4, shaderLocation: 0},
          {format: 'snorm16x4', offset: 0, shaderLocation: 7},
          {format: 'unorm8x4', offset: 8, shaderLocation: 15},
          {format: 'snorm16x4', offset: 0, shaderLocation: 1},
          {format: 'float32x4', offset: 0, shaderLocation: 6},
          {format: 'sint32', offset: 0, shaderLocation: 4},
          {format: 'sint16x4', offset: 0, shaderLocation: 2},
          {format: 'uint32x4', offset: 4, shaderLocation: 5},
          {format: 'unorm16x2', offset: 16, shaderLocation: 14},
          {format: 'sint32x4', offset: 0, shaderLocation: 11},
          {format: 'sint32x2', offset: 4, shaderLocation: 13},
        ],
      },
    ],
  },
});
try {
gpuCanvasContext6.unconfigure();
} catch {}
let bindGroup91 = device1.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 0, resource: textureView19}]});
let texture261 = device1.createTexture({
  size: {width: 51, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let externalTexture28 = device1.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
renderPassEncoder24.setBindGroup(2, bindGroup79, new Uint32Array(4271), 139, 0);
} catch {}
try {
renderBundleEncoder18.setBindGroup(1, bindGroup49, []);
} catch {}
try {
commandEncoder121.copyTextureToTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture63,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 151},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 128, height: 128, depthOrArrayLayers: 12}
*/
{
  source: imageData4,
  origin: { x: 16, y: 0 },
  flipY: true,
}, {
  texture: texture209,
  mipLevel: 1,
  origin: {x: 30, y: 19, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
let imageData18 = new ImageData(24, 40);
let commandEncoder198 = device0.createCommandEncoder({});
let texture262 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let externalTexture29 = device0.importExternalTexture({source: videoFrame31});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer134, 184); };
} catch {}
try {
renderPassEncoder26.drawIndexed(1, 0, 0, 352_135_543);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer108, 0);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer47, 'uint32', 0, 22);
} catch {}
try {
commandEncoder117.copyTextureToBuffer({
  texture: texture175,
  mipLevel: 0,
  origin: {x: 0, y: 44, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 160 */
  offset: 160,
  bytesPerRow: 6656,
  buffer: buffer79,
}, {width: 2, height: 291, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder192.pushDebugGroup('\u0728');
} catch {}
try {
device0.queue.submit([commandBuffer16]);
} catch {}
let pipeline33 = await device0.createRenderPipelineAsync({
  label: '\u2ac3\uf705\u067a\ud1e6\u0508\u0e08\u5b83\u09ac',
  layout: 'auto',
  multisample: {mask: 0x1cc24a9e},
  fragment: {
  module: shaderModule13,
  constants: {8_983: 1},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule13,
    constants: {8_983: 1},
    buffers: [
      {
        arrayStride: 12,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 0, shaderLocation: 10},
          {format: 'sint16x4', offset: 0, shaderLocation: 14},
          {format: 'snorm16x4', offset: 0, shaderLocation: 12},
          {format: 'snorm16x4', offset: 0, shaderLocation: 11},
          {format: 'uint16x2', offset: 0, shaderLocation: 9},
          {format: 'sint32x3', offset: 0, shaderLocation: 0},
          {format: 'snorm8x2', offset: 0, shaderLocation: 4},
          {format: 'sint8x2', offset: 0, shaderLocation: 15},
          {format: 'float32x3', offset: 0, shaderLocation: 1},
          {format: 'float16x4', offset: 0, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 80,
        attributes: [
          {format: 'unorm16x4', offset: 4, shaderLocation: 13},
          {format: 'float16x4', offset: 12, shaderLocation: 8},
          {format: 'sint8x4', offset: 0, shaderLocation: 3},
          {format: 'float32', offset: 12, shaderLocation: 2},
          {format: 'uint32x2', offset: 0, shaderLocation: 5},
        ],
      },
      {arrayStride: 24, attributes: [{format: 'unorm10-10-10-2', offset: 0, shaderLocation: 6}]},
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let videoFrame32 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} });
let bindGroup92 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout29,
  entries: [{binding: 2, resource: {buffer: buffer110}}, {binding: 0, resource: {buffer: buffer127, size: 28}}],
});
let buffer137 = device1.createBuffer({size: 56, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder199 = device1.createCommandEncoder({});
try {
renderBundleEncoder4.setBindGroup(3, bindGroup82, new Uint32Array(246), 7, 0);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline12);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture213,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(246).fill(248), /* required buffer size: 246 */
{offset: 246}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView220 = texture71.createView({mipLevelCount: 1});
try {
renderPassEncoder14.setBindGroup(3, bindGroup52, new Uint32Array(2015), 96, 0);
} catch {}
try {
renderBundleEncoder35.setBindGroup(0, bindGroup22, new Uint32Array(8476), 249, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(1, buffer32, 28, 0);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; });
} catch {}
try {
device1.lost.then(r => { console.log('device1 lost!'); console.log(r.message, r.reason); });
} catch {}
let texture263 = device1.createTexture({
  size: {width: 1280, height: 1, depthOrArrayLayers: 22},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder60 = commandEncoder173.beginComputePass();
let sampler27 = device1.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 69.74,
});
try {
computePassEncoder60.setPipeline(pipeline0);
} catch {}
let textureView221 = texture254.createView({});
let textureView222 = texture147.createView({});
try {
renderPassEncoder3.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder4.draw(0, 0);
} catch {}
try {
renderPassEncoder4.drawIndexedIndirect(buffer8, 17_976);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline17);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(7, buffer112, 40, 41);
} catch {}
try {
adapter1.label = '\u843b\u0adc\u7f99\u00b8\ua764\u4446\ua36a\u0e6c';
} catch {}
let commandEncoder200 = device1.createCommandEncoder({});
let texture264 = device1.createTexture({
  size: [39],
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder23.setBindGroup(2, bindGroup53);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer131, 'uint16', 8, 1);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline24);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 640, height: 1, depthOrArrayLayers: 438}
*/
{
  source: videoFrame14,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture236,
  mipLevel: 0,
  origin: {x: 56, y: 0, z: 34},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder11.setBindGroup(2, bindGroup69, new Uint32Array(432), 152, 0);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline12);
} catch {}
let textureView223 = texture262.createView({});
let texture265 = device0.createTexture({
  size: [8, 1424, 56],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView224 = texture5.createView({dimension: '2d', baseArrayLayer: 3});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer0, 16); };
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 0, 0, 309_742_869);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer8, 5_044);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer87);
} catch {}
try {
renderBundleEncoder47.setBindGroup(0, bindGroup16, new Uint32Array(2377), 61, 0);
} catch {}
try {
commandEncoder192.popDebugGroup();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let autogeneratedBindGroupLayout14 = pipeline1.getBindGroupLayout(1);
let commandBuffer17 = commandEncoder38.finish();
let textureView225 = texture245.createView({dimension: '2d-array', baseMipLevel: 0});
try {
renderPassEncoder1.setPipeline(pipeline28);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup8, new Uint32Array(3124), 118, 0);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline12);
} catch {}
try {
device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder188.copyTextureToBuffer({
  texture: texture54,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1408 */
  offset: 1408,
  bytesPerRow: 6144,
  rowsPerImage: 218,
  buffer: buffer110,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder201 = device1.createCommandEncoder({});
let imageData19 = new ImageData(244, 12);
let pipelineLayout7 = device1.createPipelineLayout({
  bindGroupLayouts: [autogeneratedBindGroupLayout6, autogeneratedBindGroupLayout2, veryExplicitBindGroupLayout35, autogeneratedBindGroupLayout1],
});
try {
computePassEncoder60.setBindGroup(0, bindGroup8, new Uint32Array(69), 3, 0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer132, 'uint32', 0, 0);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer88, 12, 12);
} catch {}
document.body.append(img2);
let commandEncoder202 = device1.createCommandEncoder();
let renderBundleEncoder48 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true});
try {
computePassEncoder35.setBindGroup(2, bindGroup87, new Uint32Array(1901), 254, 0);
} catch {}
try {
commandEncoder165.copyBufferToBuffer(buffer123, 0, buffer75, 12, 0);
} catch {}
let pipeline34 = device1.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule9,
  targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule9,
    constants: {override19: 1, 7_569: 1},
    buffers: [
      {
        arrayStride: 8,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm8x2', offset: 2, shaderLocation: 3},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'unorm16x2', offset: 0, shaderLocation: 13},
          {format: 'float16x4', offset: 0, shaderLocation: 8},
          {format: 'sint8x2', offset: 2, shaderLocation: 5},
          {format: 'sint16x2', offset: 0, shaderLocation: 1},
          {format: 'sint32x2', offset: 0, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7},
          {format: 'sint16x4', offset: 0, shaderLocation: 15},
          {format: 'uint32x2', offset: 0, shaderLocation: 0},
          {format: 'uint8x2', offset: 0, shaderLocation: 4},
          {format: 'sint32', offset: 0, shaderLocation: 14},
          {format: 'uint16x4', offset: 0, shaderLocation: 9},
          {format: 'sint8x2', offset: 0, shaderLocation: 2},
          {format: 'unorm8x4', offset: 0, shaderLocation: 12},
        ],
      },
      {arrayStride: 0, attributes: [{format: 'uint16x4', offset: 360, shaderLocation: 6}]},
    ],
  },
});
try {
externalTexture27.label = '\u3d93\u07fc\u2c21\u{1f860}\uf3f7\uf89b\ud126\u{1f9e9}\u{1f8bc}';
} catch {}
let commandEncoder203 = device1.createCommandEncoder({});
let texture266 = device1.createTexture({
  size: {width: 39, height: 41, depthOrArrayLayers: 31},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder61 = commandEncoder33.beginComputePass();
let renderPassEncoder28 = commandEncoder170.beginRenderPass({
  colorAttachments: [{
  view: textureView102,
  clearValue: { r: 991.7, g: 343.9, b: 191.4, a: -274.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet3,
});
try {
renderBundleEncoder4.setBindGroup(2, bindGroup47);
} catch {}
try {
renderBundleEncoder40.setIndexBuffer(buffer101, 'uint16', 0, 0);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline6);
} catch {}
try {
device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); });
} catch {}
try {
device1.queue.writeTexture({
  texture: texture172,
  mipLevel: 0,
  origin: {x: 108, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(38).fill(152), /* required buffer size: 38 */
{offset: 38}, {width: 115, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'jedecP22Phosphors', transfer: 'smpte240m'} });
try {
globalThis.someLabel = device1.queue.label;
} catch {}
let buffer138 = device1.createBuffer({size: 72, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, mappedAtCreation: false});
let texture267 = device1.createTexture({
  size: {width: 19, height: 20, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture268 = device1.createTexture({
  size: [156, 164, 169],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder39.end();
} catch {}
try {
computePassEncoder61.setPipeline(pipeline10);
} catch {}
try {
commandEncoder81.copyBufferToBuffer(buffer123, 0, buffer110, 1064, 0);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(31); };
} catch {}
let veryExplicitBindGroupLayout36 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 9,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {binding: 52, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }},
  ],
});
let buffer139 = device0.createBuffer({size: 464, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let commandEncoder204 = device0.createCommandEncoder({});
let renderBundle6 = renderBundleEncoder27.finish();
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer99, 44); };
} catch {}
try {
renderPassEncoder9.draw(234, 0, 305_063_713);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer49, 52);
} catch {}
try {
renderBundleEncoder31.setBindGroup(0, bindGroup45, new Uint32Array(4680), 290, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
try {
device0.queue.writeBuffer(buffer134, 68, new DataView(new ArrayBuffer(6474)), 1236, 124);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer140 = device1.createBuffer({size: 171, usage: GPUBufferUsage.INDEX});
let commandBuffer18 = commandEncoder34.finish();
try {
renderPassEncoder8.setBindGroup(1, bindGroup58, new Uint32Array(2510), 81, 0);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup79);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline28);
} catch {}
try {
commandEncoder81.resolveQuerySet(querySet2, 26, 8, buffer103, 0);
} catch {}
document.body.prepend(img2);
let bindGroup93 = device0.createBindGroup({
  label: '',
  layout: veryExplicitBindGroupLayout11,
  entries: [{binding: 1, resource: {buffer: buffer71}}],
});
try {
renderPassEncoder4.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer47, 0);
} catch {}
let textureView226 = texture200.createView({arrayLayerCount: 1});
let sampler28 = device1.createSampler({label: '\u0398', addressModeW: 'repeat', minFilter: 'linear', lodMaxClamp: 99.86});
try {
renderBundleEncoder6.setVertexBuffer(4, buffer131);
} catch {}
let promise15 = device1.queue.onSubmittedWorkDone();
await gc();
let commandEncoder205 = device1.createCommandEncoder();
try {
gpuCanvasContext6.unconfigure();
} catch {}
let buffer141 = device0.createBuffer({size: 188, usage: GPUBufferUsage.COPY_SRC});
let texture269 = device0.createTexture({
  size: {width: 1697, height: 1, depthOrArrayLayers: 1},
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView227 = texture128.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder27.setBindGroup(1, bindGroup65, new Uint32Array(3319), 449, 0);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer112, 'uint16', 0, 3);
} catch {}
let videoFrame34 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte240m', transfer: 'bt2020_12bit'} });
let recycledExplicitBindGroupLayout3 = pipeline25.getBindGroupLayout(0);
let textureView228 = texture253.createView({aspect: 'all'});
try {
{ clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroupsIndirect(buffer47, 8); };
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup6, new Uint32Array(40), 8, 0);
} catch {}
try {
renderPassEncoder4.draw(0, 0);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline29);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 80}
*/
{
  source: videoFrame25,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 5, y: 4, z: 16},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter1.label = '\u6d78\uf303\u{1ffd6}\uc782\u485c\u0b0d\u03e4\u0b03\u0177';
} catch {}
let commandEncoder206 = device0.createCommandEncoder({});
let commandBuffer19 = commandEncoder2.finish({});
let texture270 = device0.createTexture({
  size: {width: 1, height: 178, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup44, new Uint32Array(1019), 10, 0);
} catch {}
try {
renderPassEncoder26.drawIndexed(2, 0, 0, 1_150_283_779);
} catch {}
try {
renderBundleEncoder46.setIndexBuffer(buffer64, 'uint16', 0, 0);
} catch {}
let commandEncoder207 = device0.createCommandEncoder({});
try {
computePassEncoder37.setBindGroup(2, bindGroup46);
} catch {}
try {
renderPassEncoder3.draw(2, 188, 0, 2_570_443_794);
} catch {}
try {
renderPassEncoder4.drawIndexed(1, 0, 0, 268_832_930, 0);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer99, 28);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer89, 0, 19);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(5, buffer112, 24);
} catch {}
try {
device0.queue.writeBuffer(buffer134, 80, new DataView(new ArrayBuffer(7848)), 114, 4);
} catch {}
let pipeline35 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule11, entryPoint: 'compute11'}});
let commandEncoder208 = device1.createCommandEncoder({});
let texture271 = device1.createTexture({
  label: '\u693b\u{1fc5c}\u0d4f\u38b4\u3772',
  size: {width: 640, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder13.setIndexBuffer(buffer32, 'uint16', 8, 4);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
commandEncoder130.copyBufferToTexture({
  /* bytesInLastRow: 232 widthInBlocks: 29 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 744 */
  offset: 744,
  buffer: buffer77,
}, {
  texture: texture131,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 29, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext4.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device1.queue.writeBuffer(buffer12, 0, new Uint32Array(9577).map((_, i) => i * 8), 2511, 0);
} catch {}
let commandEncoder209 = device1.createCommandEncoder();
let texture272 = device1.createTexture({
  size: {width: 640, height: 1, depthOrArrayLayers: 397},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder41.setBindGroup(1, bindGroup21, new Uint32Array(5611), 1_438, 1);
} catch {}
try {
commandEncoder127.copyBufferToBuffer(buffer21, 4, buffer115, 4, 0);
} catch {}
try {
commandEncoder179.resolveQuerySet(querySet2, 35, 2, buffer125, 0);
} catch {}
let veryExplicitBindGroupLayout37 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true },
    },
    {
      binding: 98,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let bindGroup94 = device1.createBindGroup({
  layout: veryExplicitBindGroupLayout25,
  entries: [
    {binding: 174, resource: sampler3},
    {binding: 236, resource: textureView92},
    {binding: 3, resource: {buffer: buffer117}},
    {binding: 1, resource: textureView17},
    {binding: 379, resource: {buffer: buffer110, offset: 0}},
    {binding: 0, resource: textureView36},
    {binding: 6, resource: textureView169},
    {binding: 68, resource: textureView45},
  ],
});
let commandEncoder210 = device1.createCommandEncoder({});
let texture273 = device1.createTexture({
  size: {width: 19, height: 20, depthOrArrayLayers: 20},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder49 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float'], sampleCount: 1});
try {
renderPassEncoder14.setIndexBuffer(buffer140, 'uint32', 0, 6);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup33, new Uint32Array(449), 6, 1);
} catch {}
let bindGroup95 = device1.createBindGroup({layout: autogeneratedBindGroupLayout9, entries: [{binding: 98, resource: textureView80}]});
let texture274 = device1.createTexture({
  size: {width: 102, height: 1, depthOrArrayLayers: 355},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder10.setVertexBuffer(1, buffer61);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let texture275 = device1.createTexture({
  size: [19, 20, 295],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler29 = device1.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 87.94, maxAnisotropy: 20});
try {
renderPassEncoder24.setScissorRect(16, 86, 9, 7);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
try {
commandEncoder107.copyTextureToTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 68, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture63,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 54},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let commandEncoder211 = device1.createCommandEncoder({label: '\u{1fef8}\u3d9e\u0735\u{1fda9}\u0cc7\u7a28\u55c5\u0cdc'});
let textureView229 = texture227.createView({mipLevelCount: 1});
let textureView230 = texture201.createView({dimension: '1d'});
let computePassEncoder62 = commandEncoder143.beginComputePass();
try {
computePassEncoder56.setBindGroup(2, bindGroup69);
} catch {}
try {
computePassEncoder34.setBindGroup(1, bindGroup0, new Uint32Array(131), 6, 0);
} catch {}
try {
computePassEncoder62.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer107, 'uint16', 16, 67);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer81, 'uint32', 0, 16);
} catch {}
try {
commandEncoder179.copyBufferToTexture({
  /* bytesInLastRow: 280 widthInBlocks: 35 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 456 */
  offset: 456,
  bytesPerRow: 15616,
  rowsPerImage: 233,
  buffer: buffer77,
}, {
  texture: texture172,
  mipLevel: 0,
  origin: {x: 93, y: 0, z: 0},
  aspect: 'all',
}, {width: 35, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder158.copyTextureToBuffer({
  texture: texture149,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 40 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2864 */
  offset: 2864,
  buffer: buffer30,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 19, height: 20, depthOrArrayLayers: 1}
*/
{
  source: videoFrame28,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture233,
  mipLevel: 0,
  origin: {x: 5, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
veryExplicitBindGroupLayout24.label = '\u{1f964}';
} catch {}
let bindGroup96 = device1.createBindGroup({
  layout: autogeneratedBindGroupLayout5,
  entries: [{binding: 1, resource: {buffer: buffer50, size: 8}}],
});
let textureView231 = texture274.createView({});
let textureView232 = texture241.createView({dimension: '2d-array'});
try {
renderPassEncoder15.setBindGroup(3, bindGroup62, []);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer131, 'uint32', 4, 6);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(0, buffer88, 8, 24);
} catch {}
try {
commandEncoder152.copyBufferToBuffer(buffer77, 128, buffer31, 12, 8);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture97,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(26).fill(181), /* required buffer size: 26 */
{offset: 26}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline36 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule6, constants: {}}});
let textureView233 = texture86.createView({dimension: '2d', baseArrayLayer: 3});
try {
renderPassEncoder20.setBlendConstant({ r: -248.0, g: 698.2, b: 954.5, a: -950.0, });
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer8, 748);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer48, 'uint16', 2, 4);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(2, buffer112, 4);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 178, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 1, y: 11 },
  flipY: true,
}, {
  texture: texture94,
  mipLevel: 0,
  origin: {x: 0, y: 29, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 15, depthOrArrayLayers: 0});
} catch {}
let videoFrame35 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt709', transfer: 'smpteSt4281'} });
try {
externalTexture19.label = '\u0b30\u83aa\u{1fa1a}\u83ba\u{1fcab}\u0fd6\u{1fa08}\u{1f899}\ue835';
} catch {}
let commandEncoder212 = device0.createCommandEncoder({});
let texture276 = device0.createTexture({size: [2, 356, 1], format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING});
try {
computePassEncoder5.end();
} catch {}
try {
computePassEncoder45.setPipeline(pipeline35);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup50, new Uint32Array(3011), 13, 0);
} catch {}
try {
renderPassEncoder4.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer128, 4);
} catch {}
try {
renderPassEncoder26.drawIndirect(buffer73, 4);
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1704 */
  offset: 1704,
  buffer: buffer136,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder119.copyTextureToBuffer({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 283, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2912 */
  offset: 2912,
  buffer: buffer46,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder36.pushDebugGroup('\u0457');
} catch {}
try {
globalThis.someLabel = externalTexture6.label;
} catch {}
let texture277 = device0.createTexture({size: [424, 1, 38], format: 'depth32float', usage: GPUTextureUsage.COPY_DST});
try {
{ clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(4); };
} catch {}
try {
renderPassEncoder26.drawIndexedIndirect(buffer47, 0);
} catch {}
try {
renderPassEncoder2.drawIndirect(buffer108, 0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup67, new Uint32Array(5786), 1_558, 0);
} catch {}
try {
renderBundleEncoder33.setIndexBuffer(buffer10, 'uint16', 86, 88);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
  await promise15;
} catch {}
let buffer142 = device1.createBuffer({size: 448, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder213 = device1.createCommandEncoder({});
try {
renderBundleEncoder48.setVertexBuffer(4, buffer85);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let bindGroup97 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 1, resource: textureView6},
    {binding: 103, resource: externalTexture3},
    {binding: 13, resource: textureView108},
    {binding: 9, resource: textureView68},
    {binding: 30, resource: {buffer: buffer114}},
  ],
});
let commandEncoder214 = device0.createCommandEncoder();
let textureView234 = texture166.createView({mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(3); };
} catch {}
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder2.draw(54, 0, 584_595_089);
} catch {}
try {
renderPassEncoder26.drawIndexed(2, 0, 0, 47_102_994);
} catch {}
try {
renderBundleEncoder33.setBindGroup(0, bindGroup93);
} catch {}
let commandEncoder215 = device0.createCommandEncoder();
try {
{ clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroups(2); };
} catch {}
try {
device0.queue.writeBuffer(buffer104, 8, new DataView(new Uint8Array(620).map((_, i) => i).buffer), 115, 28);
} catch {}
let commandEncoder216 = device0.createCommandEncoder({});
let textureView235 = texture173.createView({baseArrayLayer: 0});
let textureView236 = texture87.createView({});
let renderBundleEncoder50 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthStencilFormat: 'depth32float'});
try {
computePassEncoder51.setBindGroup(2, bindGroup20, new Uint32Array(1641), 606, 0);
} catch {}
try {
renderPassEncoder4.drawIndexed(1, 0, 0, 1_034_742_047);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline25);
} catch {}
let bindGroup98 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [{binding: 1, resource: {buffer: buffer49, size: 60}}],
});
let texture278 = gpuCanvasContext3.getCurrentTexture();
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer128, 4); };
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer100, 'uint32', 16, 17);
} catch {}
try {
renderBundleEncoder28.setBindGroup(0, bindGroup83);
} catch {}
try {
renderBundleEncoder46.setIndexBuffer(buffer92, 'uint16', 32, 21);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 20, new Float32Array(19081).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.607)), 1504, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 16, height: 16, depthOrArrayLayers: 80}
*/
{
  source: videoFrame18,
  origin: { x: 2, y: 38 },
  flipY: false,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 13},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 2, height: 2, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas0);
await gc();
let commandEncoder217 = device0.createCommandEncoder();
let computePassEncoder63 = commandEncoder101.beginComputePass();
try {
renderPassEncoder26.draw(0, 0);
} catch {}
try {
renderPassEncoder2.drawIndexed(2, 0, 0, 414_983_600);
} catch {}
try {
device0.queue.writeBuffer(buffer118, 324, new Uint32Array(15624).map((_, i) => i * 3), 2496, 8);
} catch {}
let textureView237 = texture174.createView({dimension: '2d-array', baseMipLevel: 0});
let computePassEncoder64 = commandEncoder192.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroupsIndirect(buffer7, 8); };
} catch {}
try {
computePassEncoder64.setPipeline(pipeline35);
} catch {}
try {
renderPassEncoder9.drawIndexed(0, 0, 0, 369_438_159, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer79, 4, 1);
} catch {}
try {
commandEncoder36.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer79, 56, new Float32Array(6134).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.315)), 913, 12);
} catch {}
let pipeline37 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute1', constants: {}}});
let renderBundleEncoder51 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true});
try {
renderPassEncoder26.drawIndexed(2, 0, 0, 711_572_442);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer79, 104);
} catch {}
let pipeline38 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule8, constants: {override17: 1, override16: 1}}});
let commandEncoder218 = device0.createCommandEncoder({});
let externalTexture30 = device0.importExternalTexture({source: videoFrame19});
try {
computePassEncoder59.setBindGroup(3, bindGroup9, []);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline14);
} catch {}
try {
renderPassEncoder9.draw(0, 0);
} catch {}
try {
renderPassEncoder26.drawIndexed(2, 0, 0, -1_906_354_931);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer129, 'uint32', 92, 104);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer100, 'uint32', 8, 2);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(0, buffer79, 0);
} catch {}
try {
device0.queue.submit([commandBuffer19]);
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
try {
  await promise16;
} catch {}
let texture279 = device0.createTexture({
  size: [2, 356, 1],
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder19.setBindGroup(0, bindGroup20, new Uint32Array(2619), 133, 0);
} catch {}
try {
renderPassEncoder4.draw(0, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer134, 16);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
let commandEncoder219 = device1.createCommandEncoder({});
try {
computePassEncoder36.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup96);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup22, new Uint32Array(1626), 507, 0);
} catch {}
try {
buffer23.unmap();
} catch {}
try {
commandEncoder195.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 976 */
  offset: 976,
  rowsPerImage: 1273,
  buffer: buffer77,
}, {
  texture: texture58,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 3},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
let bindGroup99 = device1.createBindGroup({
  layout: autogeneratedBindGroupLayout11,
  entries: [{binding: 2, resource: {buffer: buffer127, size: 48}}],
});
let buffer143 = device1.createBuffer({size: 8, usage: GPUBufferUsage.COPY_SRC});
let commandEncoder220 = device1.createCommandEncoder({});
let textureView238 = texture71.createView({mipLevelCount: 1});
try {
computePassEncoder56.setBindGroup(2, bindGroup52, new Uint32Array(302), 10, 0);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline13);
} catch {}
let commandEncoder221 = device0.createCommandEncoder({label: '\ud029\u0331\u91c4'});
try {
computePassEncoder52.setBindGroup(0, bindGroup74);
} catch {}
try {
renderPassEncoder17.setBindGroup(0, bindGroup90, []);
} catch {}
try {
renderPassEncoder6.end();
} catch {}
try {
renderPassEncoder17.drawIndexed(1, 46, 0, -2_011_886_048, 115_026_085);
} catch {}
try {
renderPassEncoder2.drawIndexedIndirect(buffer134, 88);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(4, buffer89, 44, 2);
} catch {}
try {
renderPassEncoder9.insertDebugMarker('\uddd2');
} catch {}
try {
device0.queue.writeBuffer(buffer79, 92, new DataView(new Uint8Array(2784).map((_, i) => i).buffer), 501, 12);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
videoFrame0.close();
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame6.close();
videoFrame7.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame14.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
videoFrame27.close();
videoFrame28.close();
videoFrame29.close();
videoFrame30.close();
videoFrame31.close();
videoFrame32.close();
videoFrame33.close();
videoFrame34.close();
videoFrame35.close();
}
async function window1() {
let promise0 = navigator.gpu.requestAdapter({});
let adapter0 = await navigator.gpu.requestAdapter({});
let adapter1 = await navigator.gpu.requestAdapter();
let promise1 = adapter1.requestDevice({
  requiredFeatures: ['shader-f16'],
  requiredLimits: {maxStorageBufferBindingSize: 175161326, maxUniformBufferBindingSize: 24641468},
});
let device0 = await promise1;
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'iec6196624'} });
let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 59,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 61,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 109,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 308,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 312,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 524,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let texture0 = device0.createTexture({
  size: [256, 256, 203],
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView0 = texture0.createView({});
let commandEncoder0 = device0.createCommandEncoder({});
let texture1 = device0.createTexture({
  size: [256, 256, 19],
  mipLevelCount: 4,
  format: 'rg16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture2 = device0.createTexture({
  size: [690, 1, 37],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 28, y: 22, z: 22},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer0 = device0.createBuffer({size: 620, usage: GPUBufferUsage.INDIRECT});
let texture3 = device0.createTexture({
  size: {width: 345},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView1 = texture3.createView({});
try {
globalThis.someLabel = textureView0.label;
} catch {}
let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]});
let commandEncoder1 = device0.createCommandEncoder();
let texture4 = device0.createTexture({
  size: [828, 1, 1],
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let promise2 = device0.queue.onSubmittedWorkDone();
let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let commandEncoder2 = device0.createCommandEncoder({});
let textureView2 = texture1.createView({dimension: 'cube-array', mipLevelCount: 2, baseArrayLayer: 1, arrayLayerCount: 6});
let texture5 = device0.createTexture({
  size: [414, 1, 1],
  dimension: '2d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView3 = texture4.createView({dimension: '2d-array', mipLevelCount: 1});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true});
try {
veryExplicitBindGroupLayout2.label = '\u2a2a\ud700\uf127\u84a8';
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

@group(1) @binding(93) var st1: texture_storage_1d<rgba32sint, read>;

struct T1 {
  @size(16) f0: atomic<i32>,
}

struct T5 {
  f0: array<array<vec2i, 1>>,
}

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

struct FragmentInput3 {
  @location(5) location_5: vec4h,
}

struct T4 {
  f0: array<u32>,
}

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

struct T3 {
  @align(8) f0: array<array<f16, 14>>,
}

@id(58764) override override0: u32 = (705493666 % 103) + 1;

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

struct T0 {
  f0: array<u32, 32>,
  @align(8) @size(128) f1: atomic<i32>,
  @size(384) f2: array<array<atomic<i32>, 4>, 1>,
  f3: array<array<atomic<i32>, 1>>,
}

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

struct FragmentInput0 {
  @location(2) @interpolate(linear, centroid) location_2: vec2f,
  @location(14) @interpolate(perspective, centroid) location_14: f16,
}

struct VertexInput1 {
  @location(9) location_9: f32,
}

var<private> vp1: array<u32, 40> = array<u32, 40>(u32(1423838915), u32(326491431), u32(2119806305), u32(1662692236), u32(1037945241), u32(1928406291), u32(1057850745), u32(2902840888), u32(661395436), u32(55413696), u32(256827667), u32(176895435), u32(8047532), u32(1101801793), u32(1273227544), u32(133718569), u32(571320255), u32(125118434), u32(66848407), u32(354584102), u32(175610453), u32(1314837497), u32(113661415), u32(867609415), u32(3599471605), u32(923911212), u32(366185443), u32(1172369296), u32(290971450), u32(673988678), u32(96754695), u32(899571375), u32(49881458), u32(366726435), u32(44553738), u32(46037114), u32(658980187), u32(279147503), u32(181687720), u32(147961781));

struct VertexInput2 {
  @location(13) @interpolate(flat) location_13: i32,
}

@id(48613) override override2: f32;

var<private> vp0 = modf(vec2h(2040.4, 776.3));

var<private> vp3: vec2i = vec2i(95279000, 15828716);

struct VertexInput0 {
  @location(12) @interpolate(flat) location_12: vec4f,
  @location(14) location_14: vec4f,
  @location(5) location_5: vec4h,
  @location(15) @interpolate(flat) location_15: vec4u,
  @location(2) location_2: vec4h,
  @location(10) @interpolate(flat, sample) location_10: vec2h,
  @location(7) location_7: vec2u,
}

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

struct FragmentOutput0 {
  @location(5) location_5: vec2i,
  @location(0) @interpolate(flat, centroid) location_0: vec4i,
}

struct FragmentInput1 {
  @location(5) location_5: vec4h,
}

@id(14197) override override1: f16;

override override4: f32;

var<workgroup> vw0: i32;

struct VertexOutput0 {
  @location(14) @interpolate(perspective, centroid) location_14: f16,
  @invariant @builtin(position) position: vec4f,
  @location(10) location_10: vec2u,
  @location(5) location_5: vec4h,
  @location(8) @interpolate(linear, centroid) location_8: vec4f,
  @location(2) @interpolate(linear, centroid) location_2: vec2f,
}

var<private> vp2: array<vec2i, 13> = array<vec2i, 13>();

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

struct VertexInput3 {
  @location(11) location_11: f32,
}

@group(0) @binding(93) var st0: texture_storage_1d<rgba32sint, read>;

struct FragmentInput2 {
  @location(2) @interpolate(linear, centroid) location_2: vec2f,
}

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

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

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

/* used global variables: st1 */
@vertex
fn vertex0(@location(4) location_4: u32, a1: VertexInput0, a2: VertexInput1, a3: VertexInput2, @location(8) @interpolate(flat) location_8: vec4i, @builtin(vertex_index) vertex_index: u32, a6: VertexInput3) -> VertexOutput0 {
  var out: VertexOutput0;
  vp2[unconst_u32(26306385)] = bitcast<vec2i>(unpack4x8unorm(unconst_u32(1501353532)).br.rr.rr.yy.gr.xx.rg.gg.xx.rg);
  out = VertexOutput0(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2)))[0], vec4f(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))).rgrg), vec2u(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))).yy), floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))).grrg, vec4f(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))).rrrr.rgaa.xxxy), vec2f(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2)))));
  var vf0: f32 = out.location_2[unconst_u32(1525366310)];
  let ptr0: ptr<function, vec2u> = &out.location_10;
  out.location_10 += vec2u(bitcast<u32>(a1.location_14[unconst_u32(2694144421)]));
  out.position = vec4f(textureLoad(st1, unconst_i32(725447499)).yzwz);
  return out;
  _ = st1;
}

/* zero global variables used */
@fragment
fn fragment0(@location(8) @interpolate(linear) location_8: vec4f, a1: FragmentInput0, a2: FragmentInput1) -> FragmentOutput0 {
  var out: FragmentOutput0;
  var vf1: FragmentInput1 = a2;
  var vf2: vec2f = a1.location_2;
  let vf3: vec2f = atanh(vec2f(unconst_f32(0.05919e-37), unconst_f32(0.1800)));
  return out;
}

/* used global variables: st0 */
@fragment
fn fragment1(a0: FragmentInput2, @location(10) @interpolate(flat, centroid) location_10: vec2u, a2: FragmentInput3) -> @location(200) vec4i {
  var out: vec4i;
  vp3 += vec2i(i32(textureDimensions(st0)));
  vp0.whole = bitcast<vec2h>(vp2[unconst_u32(69289615)][unconst_u32(836792121)]);
  var vf4: i32 = vp2[12][unconst_u32(1104178073)];
  for (var jj40=0u; jj40<15; jj40++) { vp2[jj40] = countLeadingZeros(vec3i(unconst_i32(104927857), unconst_i32(425508417), unconst_i32(261798975))).zz; }
  vp0 = modf(bitcast<vec2h>(cos(unconst_f32(0.2199))));
  return out;
  _ = st0;
}

/* zero global variables used */
@compute @workgroup_size(8, 2, 1)
fn compute0(a0: ComputeInput0) {
  vp1[39] &= vec2u(vp2[12])[1];
  let vf5: f32 = override4;
  let vf6: vec2h = sqrt(vec2h(unconst_f16(4621.2), unconst_f16(-1148.5)));
  vp0 = modf(vp0.whole);
  vp2[unconst_u32(90467102)] |= vec2i(bitcast<i32>(vp1[39]));
  var vf7: vec4i = unpack4xI8(reverseBits(vec2u(unconst_u32(172866832), unconst_u32(212281484)))[1]);
  vp2[unconst_u32(108556843)] = vec2i(refract(vec2h(unconst_f16(1813.8), unconst_f16(15123.7)), vec2h(unconst_f16(867.1), unconst_f16(12946.7)), unconst_f16(3330.7)));
  let vf8: ptr<workgroup, i32> = &vw0;
  var vf9: vec3f = ceil(vec3f(unconst_f32(0.04753), unconst_f32(0.1866), unconst_f32(-0.1424e30)));
  let vf10: vec2f = fma(vec2f(unconst_f32(0.01866), unconst_f32(0.05296e-43)), vec2f(unconst_f32(-0.04896), unconst_f32(0.1797)), vec2f(unconst_f32(0.2411e-9), unconst_f32(0.09721e36)));
  _ = override4;
}`,
});
let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  label: '\u1ae9\u7702\u7738\uec85\u{1f8ae}\u0c6d\u0adf\ua1f5',
  entries: [
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let buffer1 = device0.createBuffer({size: 72, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let texture6 = device0.createTexture({
  size: {width: 2},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder0 = commandEncoder1.beginComputePass();
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, stencilReadOnly: true});
try {
renderBundleEncoder0.setVertexBuffer(0, undefined, 0, 468_327_760);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let texture7 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 4},
  mipLevelCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4});
let bindGroup0 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]});
let commandEncoder3 = device0.createCommandEncoder({});
let textureView4 = texture1.createView({dimension: 'cube-array', mipLevelCount: 2, baseArrayLayer: 1, arrayLayerCount: 6});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: false});
try {
computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(3850), 227, 0);
} catch {}
try {
renderBundleEncoder3.insertDebugMarker('\u03db');
} catch {}
let sampler0 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  compare: 'less',
});
try {
computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(2686), 448, 0);
} catch {}
let buffer2 = device0.createBuffer({size: 92, usage: GPUBufferUsage.COPY_DST});
let textureView5 = texture3.createView({format: 'rgba32sint', mipLevelCount: 1});
try {
renderBundleEncoder0.setBindGroup(0, bindGroup0);
} catch {}
let bindGroup1 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
let buffer3 = device0.createBuffer({size: 6108, usage: GPUBufferUsage.VERTEX});
let texture8 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 448},
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView6 = texture2.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 3});
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'unspecified', transfer: 'logSqrt'} });
let bindGroup2 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout3]});
let buffer4 = device0.createBuffer({size: 8, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let texture9 = device0.createTexture({
  size: {width: 4},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder1 = commandEncoder3.beginComputePass();
let pipeline0 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule0, constants: {override4: 1}}});
let buffer5 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST});
let textureView7 = texture7.createView({arrayLayerCount: 1});
let texture10 = device0.createTexture({
  size: [690],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView8 = texture7.createView({arrayLayerCount: 1});
let computePassEncoder2 = commandEncoder2.beginComputePass();
try {
renderBundleEncoder0.setBindGroup(1, bindGroup1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 8, y: 11, z: 26},
  aspect: 'all',
}, new Uint8Array(800_328).fill(101), /* required buffer size: 800_328 */
{offset: 148, bytesPerRow: 132, rowsPerImage: 243}, {width: 16, height: 230, depthOrArrayLayers: 25});
} catch {}
let videoFrame2 = new VideoFrame(videoFrame0, {timestamp: 0});
let bindGroup3 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let texture11 = device0.createTexture({
  size: [828, 1, 1],
  sampleCount: 4,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture12 = device0.createTexture({
  size: [690, 1, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer3, 84, 279);
} catch {}
let commandEncoder4 = device0.createCommandEncoder();
let texture13 = device0.createTexture({
  size: {width: 8},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture14 = device0.createTexture({
  size: [828, 1, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
device0.queue.writeBuffer(buffer2, 12, new Float16Array(5336).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.8232)), 867, 0);
} catch {}
let commandEncoder5 = device0.createCommandEncoder();
let texture15 = device0.createTexture({
  size: {width: 8},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder0.setBindGroup(2, bindGroup2);
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteSt4281', transfer: 'gamma28curve'} });
let buffer6 = device0.createBuffer({size: 110, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder6 = device0.createCommandEncoder({});
let texture16 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 339},
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView9 = texture7.createView({baseMipLevel: 0, arrayLayerCount: 2});
let textureView10 = texture16.createView({});
try {
renderBundleEncoder1.insertDebugMarker('\u0aa0');
} catch {}
let pipeline1 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, constants: {override4: 1}}});
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt2020', transfer: 'pq'} });
let textureView11 = texture9.createView({});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder0.setBindGroup(0, bindGroup2, []);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup1, new Uint32Array(319), 39, 0);
} catch {}
let pipeline2 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x1dfbed59},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 156, shaderLocation: 13},
          {format: 'sint32x3', offset: 292, shaderLocation: 8},
          {format: 'uint8x2', offset: 432, shaderLocation: 4},
          {format: 'unorm16x4', offset: 88, shaderLocation: 10},
          {format: 'float32x3', offset: 0, shaderLocation: 12},
          {format: 'uint16x4', offset: 268, shaderLocation: 15},
          {format: 'snorm8x4', offset: 572, shaderLocation: 2},
          {format: 'snorm8x4', offset: 140, shaderLocation: 5},
          {format: 'snorm16x4', offset: 144, shaderLocation: 14},
          {format: 'unorm16x4', offset: 388, shaderLocation: 9},
          {format: 'uint16x2', offset: 72, shaderLocation: 7},
          {format: 'float16x4', offset: 72, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
let textureView12 = texture15.createView({});
let texture17 = device0.createTexture({
  size: [414, 1, 1],
  sampleCount: 4,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder0.setBindGroup(1, bindGroup1, new Uint32Array(5957), 1_481, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); };
} catch {}
try {
device0.queue.writeBuffer(buffer5, 0, new Uint32Array(24845).map((_, i) => i * 10), 3693, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 39, y: 109, z: 45},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer7 = device0.createBuffer({size: 124, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let texture18 = device0.createTexture({
  size: [828, 1, 1],
  sampleCount: 4,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4});
let externalTexture0 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'srgb'});
try {
computePassEncoder0.setBindGroup(1, bindGroup3, new Uint32Array(1720), 725, 0);
} catch {}
try {
renderBundleEncoder0.setBindGroup(2, bindGroup3, new Uint32Array(1102), 303, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer6, 'uint16', 32, 3);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(0, buffer3, 0, 613);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup4 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let textureView13 = texture8.createView({baseMipLevel: 0});
let texture19 = device0.createTexture({size: {width: 4}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.STORAGE_BINDING});
try {
computePassEncoder1.setBindGroup(1, bindGroup4, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer0, 84); };
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup1);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline2);
} catch {}
let commandEncoder7 = device0.createCommandEncoder({label: ''});
let texture20 = device0.createTexture({
  size: [345, 1, 60],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture21 = device0.createTexture({
  size: [345, 1, 1],
  mipLevelCount: 4,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder3 = commandEncoder6.beginComputePass();
try {
computePassEncoder3.setBindGroup(0, bindGroup1, new Uint32Array(1560), 5, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer1, 0); };
} catch {}
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer6, 'uint32', 12, 18);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(5, buffer6, 36);
} catch {}
let texture22 = device0.createTexture({
  size: [4, 4, 1],
  format: 'depth32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
device0.queue.writeBuffer(buffer7, 0, new Float32Array(10962).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.2679)), 3277, 4);
} catch {}
let textureView14 = texture1.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 3});
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder0.end();
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(837), 42, 0);
} catch {}
let texture23 = device0.createTexture({
  size: [1656, 1, 30],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture24 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderBundleEncoder0.setVertexBuffer(2, buffer6);
} catch {}
try {
commandEncoder5.clearBuffer(buffer2, 12);
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

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

struct FragmentInput6 {
  @location(5) location_5: vec4h,
}

@group(0) @binding(153) var<storage, read_write> buffer14: array<array<array<array<f16, 1>, 13>, 32>>;

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

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

struct VertexInput4 {
  @location(2) location_2: vec2u,
  @location(14) @interpolate(linear) location_14: vec4h,
  @location(0) location_0: vec4h,
}

alias vec3b = vec3<bool>;

struct VertexInput5 {
  @location(7) location_7: u32,
  @location(1) location_1: vec2h,
  @location(12) @interpolate(flat, center) location_12: vec2f,
}

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

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

var<workgroup> vw1: atomic<i32>;

@group(0) @binding(10) var<storage, read_write> buffer11: array<array<array<f16, 3>, 512>>;

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

/* used global variables: buffer10, buffer8 */
fn fn0(a0: vec4<bool>, a1: vec2i, a2: ptr<function, vec2f>) -> u32 {
  var out: u32;
  var vf11: f32 = buffer8[0][unconst_u32(2001959669)][unconst_u32(54717938)][unconst_u32(187101228)].location_8[unconst_u32(224632116)];
  let ptr1: ptr<uniform, FragmentInput4> = &(*&buffer8)[0][0][2][unconst_u32(412766681)];
  out = u32(buffer10[arrayLength(&buffer10)][unconst_u32(23502321)][1][0][u32(buffer10[unconst_i32(263958562)][0][1][0][20])]);
  let ptr2: ptr<storage, f32, read_write> = &(*&buffer10)[arrayLength(&(*&buffer10))][unconst_u32(1276262732)][1][unconst_u32(2306078884)][20];
  let ptr3: ptr<storage, f32, read_write> = &buffer10[unconst_u32(738882874)][unconst_u32(374967987)][1][unconst_u32(426987955)][20];
  out |= bitcast<vec2u>((*a2)).g;
  (*a2) -= vec2f(buffer10[arrayLength(&buffer10)][0][1][0][20]);
  for (var jj93=0u; jj93<3; jj93++) { buffer10[unconst_u32(968942034)][unconst_u32(206621244)][unconst_u32(152645598)][jj93][20] = atan2(vec4f(unconst_f32(-0.7276e-35), unconst_f32(0.09431), unconst_f32(0.03818e4), unconst_f32(0.3893e-31)), vec4f(unconst_f32(0.08307e-16), unconst_f32(0.04453), unconst_f32(0.00409), unconst_f32(0.08987)))[1]; }
  let ptr4: ptr<uniform, array<array<array<FragmentInput4, 1>, 3>, 1>> = &(*&buffer8)[unconst_u32(190184686)];
  return out;
  _ = buffer10;
  _ = buffer8;
}

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

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

@group(0) @binding(1) var<uniform> buffer8: array<array<array<array<FragmentInput4, 1>, 3>, 1>, 1>;

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

@group(0) @binding(61) var st2: texture_storage_2d_array<r32uint, read_write>;

@group(0) @binding(7) var<storage, read_write> buffer10: array<array<array<array<array<f32, 21>, 1>, 2>, 1>>;

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

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

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

@group(0) @binding(4) var<storage, read> buffer9: array<array<f16, 107>>;

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

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

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

struct FragmentInput4 {
  @location(8) @interpolate(linear, centroid) location_8: vec4f,
}

@group(0) @binding(308) var st4: texture_storage_1d<r32sint, read_write>;

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

/* used global variables: buffer8, buffer9 */
@vertex
fn vertex1(@location(10) location_10: vec2i, a1: VertexInput4, a2: VertexInput5, @location(4) @interpolate(perspective, centroid) location_4: vec4h, @location(8) location_8: vec2i, @location(5) location_5: vec2f, @location(6) @interpolate(linear, centroid) location_6: f32, @location(15) @interpolate(linear) location_15: vec2f, @location(11) location_11: vec4u, @location(13) location_13: vec4i, @location(9) location_9: vec4f, @location(3) @interpolate(flat) location_3: vec2u, a12: VertexInput6, @builtin(instance_index) instance_index: u32) -> @builtin(position) vec4f {
  var out: vec4f;
  out -= (*&buffer8)[unconst_u32(1782582892)][unconst_u32(286633249)][2][unconst_u32(255617457)].location_8;
  out = vec4f(buffer8[0][0][unconst_u32(693769602)][0].location_8[unconst_u32(171520132)]);
  out = vec4f(buffer8[u32(buffer9[unconst_u32(623673591)][106])][unconst_u32(160759905)][2][0].location_8[unconst_u32(33213369)]);
  let ptr5: ptr<uniform, array<array<array<array<FragmentInput4, 1>, 3>, 1>, 1>> = &buffer8;
  out *= bitcast<vec4f>(extractBits(vec2i(unconst_i32(392281936), unconst_i32(834173565)), unconst_u32(1382776417), unconst_u32(10124857)).grrr);
  out = buffer8[0][0][2][0].location_8;
  out += buffer8[0][unconst_u32(576249965)][unconst_u32(347093539)][0].location_8;
  var vf12: vec4f = location_9;
  var vf13: u32 = arrayLength(&(*&buffer9));
  var vf14: f32 = (*ptr5)[0][0][2][unconst_u32(134166411)].location_8[unconst_u32(223239230)];
  return out;
  _ = buffer8;
  _ = buffer9;
}

/* used global variables: buffer10, buffer11, buffer8, st4 */
@fragment
fn fragment2(@builtin(sample_index) sample_index: u32, @location(10) @interpolate(flat) location_10: vec2u, @location(14) location_14: f16, a3: FragmentInput4, a4: FragmentInput5, @location(2) location_2: vec2f, a6: FragmentInput6, @invariant @builtin(position) position: vec4f, a8: FragmentInput7) -> @location(200) @interpolate(linear) vec4i {
  var out: vec4i;
  {
  for (var jj15=0u; jj15<514; jj15++) { buffer11[unconst_u32(2727868187)][jj15][unconst_u32(274281939)] -= f16((*&buffer8)[unconst_u32(544480495)][0][unconst_u32(1035334477)][0].location_8.r); }
  textureStore(st4, unconst_i32(1020774540), vec4i(vec4i(unconst_i32(458337439), unconst_i32(54693274), unconst_i32(28271337), unconst_i32(273961714))));
  out = vec4i(bitcast<i32>((*&buffer10)[unconst_u32(304768520)][unconst_u32(1208266618)][pack4x8unorm(buffer8[0][unconst_u32(314665112)][unconst_u32(460918486)][unconst_u32(245199098)].location_8)][0][unconst_u32(860670981)]));
  return out;
  _ = buffer8;
  _ = buffer10;
  _ = buffer11;
  _ = st4;
}
  buffer10[unconst_u32(3217681452)][unconst_u32(859655236)][unconst_u32(706674866)][0][unconst_u32(106423922)] += buffer8[0][unconst_u32(630273999)][2][unconst_u32(68597042)].location_8.a;
  return out;
  _ = st4;
  _ = buffer8;
  _ = buffer11;
  _ = buffer10;
}

/* used global variables: buffer10, buffer14, buffer8, st2 */
@compute @workgroup_size(1, 1, 1)
fn compute1(a0: ComputeInput1, a1: ComputeInput2, @builtin(local_invocation_id) local_invocation_id: vec3u) {
  let ptr6: ptr<uniform, array<FragmentInput4, 1>> = &buffer8[0][0][unconst_u32(457299166)];
  for (var jj70=0u; jj70<15; jj70++) { buffer14[unconst_u32(20450856)][unconst_u32(803147190)][jj70][unconst_u32(45947234)] *= buffer14[unconst_u32(360315158)][31][12][0]; }
  let ptr7: ptr<uniform, FragmentInput4> = &(*&buffer8)[unconst_u32(268142995)][unconst_u32(1397544263)][2][0];
  let ptr8: ptr<uniform, array<array<FragmentInput4, 1>, 3>> = &buffer8[0][0];
  let ptr9: ptr<uniform, array<FragmentInput4, 1>> = &(*&buffer8)[0][0][unconst_u32(2553692495)];
  vp4 = pack4x8snorm((*ptr9)[0].location_8);
  textureStore(st2, vec2i(unconst_i32(-92814968), unconst_i32(110061182)), unconst_i32(634057737), vec4u(vec4u((*&buffer8)[unconst_u32(631184180)][0][2][u32(buffer10[arrayLength(&buffer10)][0][1][0][20])].location_8.wyww)));
  buffer10[unconst_u32(600263447)][unconst_u32(1234079334)][1][unconst_u32(264912048)][u32((*&buffer14)[pack4x8unorm((*&buffer8)[0][unconst_u32(2318848300)][2][0].location_8)][unconst_u32(227997948)][unconst_u32(616519815)][unconst_u32(830710441)])] = buffer8[unconst_u32(180360769)][0][2][0].location_8[0];
  _ = buffer10;
  _ = buffer14;
  _ = buffer8;
  _ = st2;
}`,
});
let textureView15 = texture13.createView({});
let textureView16 = texture6.createView({});
try {
computePassEncoder3.setPipeline(pipeline1);
} catch {}
let buffer15 = device0.createBuffer({size: 2260, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder8 = device0.createCommandEncoder({});
let textureView17 = texture22.createView({arrayLayerCount: 1});
try {
computePassEncoder2.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 0, new Float32Array(24185).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4166)), 1823, 0);
} catch {}
let bindGroup5 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]});
let buffer16 = device0.createBuffer({size: 312, usage: GPUBufferUsage.COPY_DST});
let textureView18 = texture20.createView({dimension: '2d', baseArrayLayer: 20});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4});
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer4, 'uint16', 0, 0);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
adapter0.label = '\ud688\ueeba\u7303\u1a20\u{1fb3a}';
} catch {}
let bindGroup6 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
let commandBuffer0 = commandEncoder1.finish();
let textureView19 = texture23.createView({dimension: '2d', baseArrayLayer: 2});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true});
try {
renderBundleEncoder4.setBindGroup(2, bindGroup6, new Uint32Array(2143), 104, 0);
} catch {}
try {
computePassEncoder1.insertDebugMarker('\u{1f976}');
} catch {}
let imageBitmap0 = await createImageBitmap(videoFrame1);
let bindGroup7 = device0.createBindGroup({label: '', layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]});
let buffer17 = device0.createBuffer({size: 148, usage: GPUBufferUsage.UNIFORM});
let commandEncoder9 = device0.createCommandEncoder({});
let textureView20 = texture20.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 36});
try {
renderBundleEncoder3.setBindGroup(1, bindGroup5);
} catch {}
let bindGroup8 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]});
let texture25 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 47},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder3.setBindGroup(1, bindGroup8, new Uint32Array(2560), 669, 0);
} catch {}
try {
computePassEncoder3.dispatchWorkgroups(1, 1, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer4, 4, new Uint32Array(2223).map((_, i) => i * 4), 29, 0);
} catch {}
let commandEncoder10 = device0.createCommandEncoder({});
let sampler1 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMinClamp: 64.32, lodMaxClamp: 76.95});
let texture26 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView21 = texture23.createView({dimension: '2d', baseArrayLayer: 2});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, stencilReadOnly: true});
let externalTexture1 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer1, 36); };
} catch {}
let buffer18 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_DST});
let commandEncoder11 = device0.createCommandEncoder({});
let texture27 = device0.createTexture({
  size: [2760, 1, 1],
  sampleCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder7.setBindGroup(3, bindGroup8);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeBuffer(buffer4, 0, new BigInt64Array(12195).map((_, i) => BigInt(i - 9)), 1100, 0);
} catch {}
let textureView22 = texture27.createView({});
let texture28 = device0.createTexture({
  size: [207, 1, 11],
  mipLevelCount: 3,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer1, 8); };
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup8);
} catch {}
try {
buffer7.unmap();
} catch {}
let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let bindGroup9 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]});
let textureView23 = texture9.createView({baseMipLevel: 0});
let textureView24 = texture8.createView({});
try {
computePassEncoder3.setBindGroup(1, bindGroup6, []);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline2);
} catch {}
try {
commandEncoder8.insertDebugMarker('\u0d8b');
} catch {}
let pipeline3 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {override4: 1}}});
let textureView25 = texture18.createView({});
let textureView26 = texture19.createView({aspect: 'all', baseMipLevel: 0, arrayLayerCount: 1});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder6.setVertexBuffer(3, buffer3, 348, 134);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 1, y: 112, z: 20},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup10 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]});
let buffer19 = device0.createBuffer({size: 64, usage: GPUBufferUsage.INDIRECT, mappedAtCreation: false});
let computePassEncoder4 = commandEncoder7.beginComputePass();
try {
computePassEncoder1.setBindGroup(1, bindGroup2, new Uint32Array(20), 4, 0);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline2);
} catch {}
try {
  await promise2;
} catch {}
let bindGroup11 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let commandEncoder12 = device0.createCommandEncoder({});
let textureView27 = texture7.createView({arrayLayerCount: 2});
let computePassEncoder5 = commandEncoder8.beginComputePass();
try {
computePassEncoder3.setBindGroup(1, bindGroup2, new Uint32Array(859), 35, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); };
} catch {}
try {
buffer3.unmap();
} catch {}
let buffer20 = device0.createBuffer({size: 135, usage: GPUBufferUsage.INDEX});
let textureView28 = texture0.createView({dimension: '3d', baseArrayLayer: 0});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder4.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer6, 'uint32', 16, 21);
} catch {}
try {
commandEncoder0.clearBuffer(buffer16);
} catch {}
try {
device0.queue.writeBuffer(buffer16, 96, new Float32Array(3163).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.762)), 19, 36);
} catch {}
let texture29 = device0.createTexture({
  size: [414],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba16sint'],
});
let textureView29 = texture14.createView({});
let computePassEncoder6 = commandEncoder11.beginComputePass();
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer5, 0, new DataView(new Uint8Array(4622).map((_, i) => i).buffer), 71, 0);
} catch {}
let bindGroup12 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]});
let textureView30 = texture7.createView({arrayLayerCount: 1});
try {
computePassEncoder3.setBindGroup(0, bindGroup3, new Uint32Array(1291), 97, 0);
} catch {}
try {
globalThis.someLabel = computePassEncoder5.label;
} catch {}
let texture30 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 1099},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder3.setBindGroup(1, bindGroup6);
} catch {}
try {
computePassEncoder1.setBindGroup(0, bindGroup5, new Uint32Array(205), 13, 0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline3);
} catch {}
await gc();
let bindGroup13 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let textureView31 = texture30.createView({dimension: '3d', aspect: 'all', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); };
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup0);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(7, buffer6, 40);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
let buffer21 = device0.createBuffer({size: 176, usage: GPUBufferUsage.COPY_SRC});
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1, 1); };
} catch {}
let buffer22 = device0.createBuffer({size: 382, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let textureView32 = texture27.createView({aspect: 'all', format: 'bgra8unorm-srgb', mipLevelCount: 1, arrayLayerCount: 1});
let textureView33 = texture9.createView({baseMipLevel: 0});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4});
let recycledExplicitBindGroupLayout0 = pipeline3.getBindGroupLayout(0);
try {
computePassEncoder1.setBindGroup(0, bindGroup12);
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 25,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 239,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let autogeneratedBindGroupLayout0 = pipeline2.getBindGroupLayout(0);
let commandEncoder13 = device0.createCommandEncoder({});
let texture31 = device0.createTexture({
  size: [207, 1, 406],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView34 = texture21.createView({mipLevelCount: 1});
let computePassEncoder7 = commandEncoder13.beginComputePass();
let externalTexture2 = device0.importExternalTexture({source: videoFrame2});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer0, 256); };
} catch {}
try {
computePassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline2);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(978).fill(160), /* required buffer size: 978 */
{offset: 978}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture1.label;
} catch {}
let texture32 = device0.createTexture({
  size: [345, 1, 30],
  mipLevelCount: 1,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup11, new Uint32Array(554), 27, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer16.unmap();
} catch {}
let commandEncoder14 = device0.createCommandEncoder();
let texture33 = device0.createTexture({
  size: [2760, 1, 1],
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder1.end();
} catch {}
try {
renderBundleEncoder6.setBindGroup(2, bindGroup11);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer6, 'uint32', 24, 28);
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
let textureView35 = texture1.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 3});
try {
computePassEncoder2.setBindGroup(0, bindGroup4, new Uint32Array(1743), 850, 0);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(0, buffer3, 5_144, 46);
} catch {}
try {
commandEncoder12.copyBufferToBuffer(buffer21, 80, buffer16, 8, 40);
} catch {}
let textureView36 = texture23.createView({dimension: '2d-array', baseArrayLayer: 1, arrayLayerCount: 11});
try {
device0.queue.writeBuffer(buffer7, 12, new Uint32Array(4861).map((_, i) => i * 1), 516, 0);
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
let recycledExplicitBindGroupLayout1 = pipeline0.getBindGroupLayout(1);
let bindGroup14 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let textureView37 = texture16.createView({aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder3.setBindGroup(0, bindGroup14);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup6, new Uint32Array(2980), 635, 0);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer6, 0, 11);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
adapter0.label = '\u8ed0\u{1f6ec}\u0321';
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

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

alias vec3b = vec3<bool>;

struct VertexOutput1 {
  @location(10) location_10: vec2f,
  @builtin(position) position: vec4f,
  @location(6) @interpolate(flat, sample) location_6: i32,
  @location(1) @interpolate(linear, centroid) location_1: vec4f,
}

var<workgroup> vw7: array<vec2f, 2>;

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

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

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

var<workgroup> vw4: atomic<u32>;

struct VertexInput7 {
  @location(10) location_10: vec4h,
}

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

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

var<workgroup> vw6: f32;

struct T0 {
  f0: f32,
  f1: array<array<i32, 3>>,
}

var<workgroup> vw3: atomic<i32>;

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

/* zero global variables used */
@vertex
fn vertex2(@location(7) @interpolate(flat) location_7: u32, a1: VertexInput7, @location(6) @interpolate(linear) location_6: f16, @location(9) location_9: f16) -> VertexOutput1 {
  var out: VertexOutput1;
  out.location_6 = i32(pack4xI8Clamp(vec4i(unconst_i32(309823799), unconst_i32(27553571), unconst_i32(54949721), unconst_i32(646235963))));
  out.position = vec4f(tan(unconst_f32(-0.2459e-8)));
  out.location_6 -= i32(out.location_1.y);
  out.position = out.location_1;
  var vf15: f32 = out.location_1[unconst_u32(114556682)];
  out.position -= vec4f(radians(unconst_f32(0.1733)));
  return out;
}

/* zero global variables used */
@compute @workgroup_size(2, 1, 1)
fn compute2() {
  {
  atomicAdd(&vw3, unconst_i32(220249479));
  atomicXor(&vw8[0], unconst_u32(392649761));
  atomicExchange(&vw3, unconst_i32(68742127));
  let ptr10: ptr<workgroup, atomic<u32>> = &vw8[unconst_u32(2195107266)];
  textureBarrier();
}
}`,
});
let bindGroup15 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let computePassEncoder8 = commandEncoder10.beginComputePass();
try {
computePassEncoder8.setBindGroup(2, bindGroup6, new Uint32Array(2134), 469, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(2, 1); };
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
let textureView38 = texture23.createView({aspect: 'all', baseArrayLayer: 2, arrayLayerCount: 3});
try {
renderBundleEncoder5.setIndexBuffer(buffer4, 'uint32', 4, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(5, buffer6, 0);
} catch {}
try {
commandEncoder9.insertDebugMarker('\u0622');
} catch {}
let bindGroup16 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
let commandBuffer1 = commandEncoder3.finish();
let texture34 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 82},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView39 = texture26.createView({baseArrayLayer: 0});
try {
computePassEncoder8.setBindGroup(0, bindGroup14);
} catch {}
try {
computePassEncoder2.setBindGroup(3, bindGroup8, new Uint32Array(49), 14, 0);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline2);
} catch {}
try {
commandEncoder9.copyBufferToTexture({
  /* bytesInLastRow: 188 widthInBlocks: 47 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 72 */
  offset: 72,
  bytesPerRow: 5888,
  buffer: buffer21,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
}, {width: 47, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 60, y: 30, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture35 = device0.createTexture({
  size: {width: 414, height: 1, depthOrArrayLayers: 4},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder6.setBindGroup(0, bindGroup11);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer4, 'uint32', 0, 2);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(3, buffer3, 1_052, 789);
} catch {}
try {
buffer6.unmap();
} catch {}
let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 2,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 38,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let recycledExplicitBindGroupLayout2 = pipeline3.getBindGroupLayout(0);
let buffer23 = device0.createBuffer({size: 167, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let computePassEncoder9 = commandEncoder14.beginComputePass();
try {
device0.queue.writeBuffer(buffer1, 4, new DataView(new ArrayBuffer(18302)), 1454, 8);
} catch {}
let commandEncoder15 = device0.createCommandEncoder();
let texture36 = device0.createTexture({
  size: [345, 1, 1228],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView40 = texture14.createView({aspect: 'all'});
try {
computePassEncoder8.setBindGroup(1, bindGroup11, new Uint32Array(921), 40, 0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(0, buffer6, 20, 41);
} catch {}
let commandEncoder16 = device0.createCommandEncoder({});
let textureView41 = texture25.createView({aspect: 'all', baseMipLevel: 0});
try {
computePassEncoder9.setPipeline(pipeline1);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let buffer24 = device0.createBuffer({size: 111, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let textureView42 = texture0.createView({});
try {
buffer21.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer4, 0, new Uint16Array(2863).map((_, i) => i + 4), 684, 0);
} catch {}
try {
  await promise3;
} catch {}
let computePassEncoder10 = commandEncoder12.beginComputePass();
try {
computePassEncoder9.setBindGroup(0, bindGroup3);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder16.copyBufferToBuffer(buffer24, 36, buffer16, 200, 0);
} catch {}
let bindGroup17 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 239, resource: {buffer: buffer17}},
    {binding: 2, resource: textureView17},
    {binding: 25, resource: {buffer: buffer7}},
  ],
});
try {
computePassEncoder6.setBindGroup(1, bindGroup4);
} catch {}
try {
computePassEncoder8.setBindGroup(0, bindGroup11, new Uint32Array(52), 22, 0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer24, 'uint16', 4, 12);
} catch {}
try {
commandEncoder16.copyBufferToBuffer(buffer24, 36, buffer5, 20, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 51, y: 11, z: 24},
  aspect: 'all',
}, new Uint8Array(1_014_781).fill(108), /* required buffer size: 1_014_781 */
{offset: 89, bytesPerRow: 217, rowsPerImage: 28}, {width: 25, height: 0, depthOrArrayLayers: 168});
} catch {}
try {
  await promise4;
} catch {}
let computePassEncoder11 = commandEncoder9.beginComputePass();
try {
computePassEncoder3.end();
} catch {}
try {
computePassEncoder11.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder7.setBindGroup(3, bindGroup7, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer23, 8); };
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline2);
} catch {}
let textureView43 = texture36.createView({aspect: 'all', arrayLayerCount: 1});
try {
computePassEncoder9.setBindGroup(2, bindGroup14);
} catch {}
try {
computePassEncoder4.setBindGroup(2, bindGroup6, new Uint32Array(327), 19, 0);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(3, buffer23, 16);
} catch {}
try {
device0.queue.writeBuffer(buffer16, 12, new Float64Array(9111).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/9107)), 606, 0);
} catch {}
let commandEncoder17 = device0.createCommandEncoder({});
let textureView44 = texture13.createView({label: '\udf23'});
let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let computePassEncoder12 = commandEncoder16.beginComputePass();
try {
computePassEncoder10.setBindGroup(1, bindGroup8);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(1, buffer3, 0, 1_266);
} catch {}
let sampler2 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  minFilter: 'linear',
  lodMaxClamp: 86.66,
  compare: 'always',
});
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1, 2); };
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup8, new Uint32Array(5759), 115, 0);
} catch {}
let commandEncoder18 = device0.createCommandEncoder({});
let texture37 = device0.createTexture({
  size: [1],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView45 = texture22.createView({mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder12.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup8);
} catch {}
try {
commandEncoder18.clearBuffer(buffer7, 8);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 4, new Float64Array(12782).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/12780)), 454, 0);
} catch {}
let bindGroup18 = device0.createBindGroup({label: '', layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]});
let commandEncoder19 = device0.createCommandEncoder({});
let texture38 = device0.createTexture({
  size: {width: 2760},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder0.setBindGroup(0, bindGroup11);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(1, buffer6);
} catch {}
let buffer25 = device0.createBuffer({
  size: 78,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder20 = device0.createCommandEncoder({});
let textureView46 = texture23.createView({dimension: '2d', mipLevelCount: 1});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder10.setBindGroup(0, bindGroup8, new Uint32Array(315), 25, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer23, 4); };
} catch {}
try {
computePassEncoder10.end();
} catch {}
try {
renderBundleEncoder11.setBindGroup(3, bindGroup2);
} catch {}
let imageData0 = new ImageData(36, 8);
let sampler3 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat'});
try {
computePassEncoder9.setBindGroup(3, bindGroup12, new Uint32Array(2688), 661, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder8.end();
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer20, 'uint32', 8, 58);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 0, new Uint32Array(1441).map((_, i) => i * 8), 394, 0);
} catch {}
let canvas0 = document.createElement('canvas');
let bindGroup19 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]});
let texture39 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 16},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView47 = texture24.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderBundleEncoder3.setPipeline(pipeline2);
} catch {}
try {
buffer20.destroy();
} catch {}
try {
buffer19.unmap();
} catch {}
await gc();
let textureView48 = texture1.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1});
try {
renderBundleEncoder11.setIndexBuffer(buffer4, 'uint32', 0, 3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 60, y: 37, z: 89},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(2, 1); };
} catch {}
let gpuCanvasContext0 = canvas0.getContext('webgpu');
let bindGroup20 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let commandEncoder21 = device0.createCommandEncoder({});
try {
renderBundleEncoder9.setIndexBuffer(buffer24, 'uint32', 24, 8);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(7, buffer25, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
let commandEncoder22 = device0.createCommandEncoder({});
let commandBuffer2 = commandEncoder6.finish();
let texture40 = device0.createTexture({
  size: {width: 828, height: 1, depthOrArrayLayers: 134},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView49 = texture12.createView({});
let sampler4 = device0.createSampler({addressModeV: 'repeat'});
try {
computePassEncoder6.end();
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline2);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 52, y: 0, z: 104},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView50 = texture6.createView({});
let texture41 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 9},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView51 = texture6.createView({mipLevelCount: 1});
try {
renderBundleEncoder7.setVertexBuffer(7, buffer23, 12, 18);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 17, y: 19, z: 14},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
enable f16;

struct T6 {
  f0: array<vec2f>,
}

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

struct T3 {
  f0: array<array<atomic<i32>, 40>>,
}

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

var<workgroup> vw11: atomic<u32>;

struct T5 {
  f0: array<u32>,
}

var<workgroup> vw9: vec4u;

var<workgroup> vw15: array<mat3x2f, 1>;

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

/* zero global variables used */
fn fn1(a0: texture_storage_1d<rgba32sint, read>, a1: vec2h) -> array<array<i32, 1>, 1> {
  var out: array<array<i32, 1>, 1>;
  let ptr12: ptr<function, i32> = &out[0][0];
  var vf16: vec2<bool> = (vec2<bool>(unconst_bool(false), unconst_bool(true)) & vec2<bool>(unconst_bool(true), unconst_bool(true)));
  let ptr13: ptr<private, array<vec4h, 1>> = &vp5[unconst_u32(649232014)][unconst_u32(498380959)];
  vp5[unconst_u32(735336509)][unconst_u32(934021259)][unconst_u32(864025411)] = (*ptr13)[unconst_u32(164547684)];
  out[unconst_u32(205438159)][unconst_u32(157269941)] ^= i32(vf16[unconst_u32(2449523801)]);
  vp5[unconst_u32(1131705037)][unconst_u32(166510764)][unconst_u32(381463164)] = (*ptr13)[0];
  return out;
}

var<private> vp5: array<array<array<vec4h, 1>, 4>, 1> = array(array(array<vec4h, 1>(vec4h(1916.6, 13098.4, 5289.6, 6272.6)), array(vec4h(3411.9, 7735.9, 13997.7, 963.9)), array<vec4h, 1>(), array<vec4h, 1>(vec4h(22200.0, 22005.8, 30398.2, 19428.8))));

/* zero global variables used */
fn fn0(a0: array<array<array<vec2h, 1>, 1>, 1>, a1: ptr<workgroup, atomic<u32>>, a2: ptr<workgroup, atomic<i32>>, a3: vec2i) {
  let ptr11: ptr<private, array<vec4h, 1>> = &vp5[unconst_u32(2138083756)][3];
  atomicMin(&(*a2), vec4i(vp5[unconst_u32(327193231)][3][0]).y);
  atomicMax(&(*a1), unconst_u32(562115267));
}

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

alias vec3b = vec3<bool>;

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

@group(1) @binding(93) var st7: texture_storage_1d<rgba32sint, read>;

@group(0) @binding(93) var st6: texture_storage_1d<rgba32sint, read>;

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

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

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

var<workgroup> vw13: atomic<u32>;

struct T1 {
  f0: array<vec4h>,
}

struct FragmentOutput1 {
  @location(5) @interpolate(flat, center) location_5: vec4i,
  @location(0) @interpolate(flat) location_0: vec4i,
}

struct T7 {
  f0: array<vec4f>,
}

/* used global variables: st6, st7 */
fn fn2() {
  let ptr14: ptr<private, vec4h> = &vp5[unconst_u32(1267706988)][3][unconst_u32(40857604)];
  var vf17: vec3i = firstTrailingBit(vec3i(unconst_i32(427675155), unconst_i32(171638504), unconst_i32(667426459)));
  vp5[unconst_u32(534990613)][unconst_u32(280162548)][unconst_u32(21307163)] *= bitcast<vec4h>(log2(vec2f(unconst_f32(0.1983e-33), unconst_f32(-0.4007))));
  vf17 = vec3i(log2(bitcast<vec2f>(vp5[0][3][0])).rgr);
  _ = fn1(st7, vp5[unconst_u32(12491638)][3][0].zy);
  fn1(st6, vp5[unconst_u32(350937403)][unconst_u32(317121651)][unconst_u32(673052288)].xx);
  let vf18: f16 = vp5[0][3][0][unconst_u32(1357254636)];
  var vf19: f16 = vp5[unconst_u32(764693432)][3][unconst_u32(310470552)][unconst_u32(733901442)];
  var vf20: f16 = vp5[0][unconst_u32(133745634)][unconst_u32(71478873)][unconst_u32(416170764)];
  for (var it0=u32((*ptr14).x); it0<(u32(vp5[unconst_u32(1021977536)][unconst_u32(377038438)][0][3]) & 0xfff); it0++) {
  vp5[unconst_u32(375720983)][3][unconst_u32(257747285)] = vec4h(f16(quantizeToF16(unconst_f32(-0.2381e18))));
  let ptr15: ptr<private, vec4h> = &vp5[unconst_u32(1085420317)][unconst_u32(857122517)][unconst_u32(856817846)];
  fn1(st6, atan2(vec4h(unconst_f16(5143.9), unconst_f16(74.49), unconst_f16(7039.1), unconst_f16(12232.0)), vec4h(unconst_f16(-29542.4), unconst_f16(18340.4), unconst_f16(4214.4), unconst_f16(34962.3))).rb);
  _ = st6;
}
  _ = st7;
  _ = st6;
}

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

var<workgroup> vw14: array<vec4u, 1>;

struct T0 {
  @size(64) f0: vec2u,
  f1: array<u32>,
}

/* used global variables: st7 */
@fragment
fn fragment3() -> FragmentOutput1 {
  var out: FragmentOutput1;
  let vf21: vec3i = (vec3i(unconst_i32(133778481), unconst_i32(519548276), unconst_i32(12541355)) >> vec3u(unconst_u32(785660211), unconst_u32(1087833074), unconst_u32(1505174498)));
  let vf22: u32 = textureDimensions(st7);
  return out;
  _ = st7;
}`,
});
let bindGroup21 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]});
let buffer26 = device0.createBuffer({
  size: 52,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
computePassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline2);
} catch {}
let commandEncoder23 = device0.createCommandEncoder({});
let texture42 = device0.createTexture({
  size: {width: 207, height: 1, depthOrArrayLayers: 50},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: false, stencilReadOnly: true});
try {
computePassEncoder12.setBindGroup(2, bindGroup1);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup9, new Uint32Array(3757), 185, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(2, buffer25, 0, 9);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 4, new DataView(new ArrayBuffer(11628)), 160, 0);
} catch {}
let imageData1 = new ImageData(20, 92);
let buffer27 = device0.createBuffer({size: 284, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let computePassEncoder13 = commandEncoder10.beginComputePass();
try {
computePassEncoder4.setBindGroup(1, bindGroup3, new Uint32Array(8342), 76, 0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer4, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline2);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: canvas0,
  origin: { x: 93, y: 4 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 5, y: 8, z: 7},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 28, height: 29, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout3 = pipeline0.getBindGroupLayout(0);
let buffer28 = device0.createBuffer({size: 197, usage: GPUBufferUsage.UNIFORM});
let textureView52 = texture26.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderBundleEncoder1.setBindGroup(1, bindGroup19);
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
try {
  await promise5;
} catch {}
let textureView53 = texture24.createView({dimension: '2d-array', baseMipLevel: 0, arrayLayerCount: 1});
try {
computePassEncoder13.setBindGroup(0, bindGroup18);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder24 = device0.createCommandEncoder({});
let texture43 = device0.createTexture({
  size: [8],
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder6.setVertexBuffer(0, buffer25, 20, 0);
} catch {}
try {
commandEncoder15.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 89, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture20,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
},
{width: 26, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let autogeneratedBindGroupLayout1 = pipeline2.getBindGroupLayout(1);
try {
renderBundleEncoder6.setIndexBuffer(buffer24, 'uint32', 56, 7);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer5, 32, new Float32Array(8316).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.977)), 2732, 0);
} catch {}
document.body.append(canvas0);
let imageBitmap1 = await createImageBitmap(imageData0);
try {
device0.queue.writeBuffer(buffer25, 0, new Float64Array(7398).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/7396)), 95, 0);
} catch {}
try {
computePassEncoder5.setBindGroup(3, bindGroup16);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer4, 'uint32', 0, 3);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline2);
} catch {}
let texture44 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView54 = texture14.createView({});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder0.setIndexBuffer(buffer24, 'uint32', 4, 39);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(2, buffer23);
} catch {}
try {
buffer26.unmap();
} catch {}
let imageData2 = new ImageData(56, 48);
let bindGroup22 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView1}]});
try {
renderBundleEncoder9.setIndexBuffer(buffer4, 'uint16', 0, 2);
} catch {}
try {
commandEncoder20.copyBufferToBuffer(buffer24, 72, buffer1, 4, 0);
} catch {}
let texture45 = device0.createTexture({
  size: [4, 4, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16sint'],
});
try {
renderBundleEncoder4.setBindGroup(3, bindGroup13, new Uint32Array(4529), 8, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 0, new BigInt64Array(8281).map((_, i) => BigInt(i - 7)), 276, 0);
} catch {}
try {
computePassEncoder5.setBindGroup(0, bindGroup9);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline2);
} catch {}
try {
globalThis.someLabel = externalTexture2.label;
} catch {}
let recycledExplicitBindGroupLayout4 = pipeline1.getBindGroupLayout(0);
let bindGroup23 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
try {
computePassEncoder11.setBindGroup(2, bindGroup7);
} catch {}
try {
computePassEncoder9.setBindGroup(2, bindGroup5, new Uint32Array(2604), 57, 0);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(3, buffer23, 28, 77);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
commandEncoder23.copyTextureToTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 249},
  aspect: 'all',
},
{
  texture: texture35,
  mipLevel: 0,
  origin: {x: 61, y: 0, z: 0},
  aspect: 'all',
},
{width: 116, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let textureView55 = texture15.createView({mipLevelCount: 1});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
let bindGroup24 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
let commandEncoder25 = device0.createCommandEncoder({label: '\u098d\u0544\u09fb\u80d7'});
let texture46 = device0.createTexture({
  size: {width: 2},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder13.setPipeline(pipeline2);
} catch {}
await gc();
let textureView56 = texture11.createView({mipLevelCount: 1});
try {
computePassEncoder7.setBindGroup(0, bindGroup3, new Uint32Array(6427), 574, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup17, new Uint32Array(1461), 123, 0);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(3, buffer6, 0, 35);
} catch {}
try {
buffer7.unmap();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup25 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]});
let texture47 = device0.createTexture({
  size: {width: 1380, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
device0.queue.writeBuffer(buffer18, 48, new Float16Array(6304).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.170)), 1429, 0);
} catch {}
let imageData3 = new ImageData(48, 52);
let textureView57 = texture25.createView({baseMipLevel: 0});
try {
renderBundleEncoder6.setPipeline(pipeline2);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 4, new DataView(new Uint8Array(1890).map((_, i) => i).buffer), 193, 8);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 690, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 2, y: 6 },
  flipY: true,
}, {
  texture: texture47,
  mipLevel: 1,
  origin: {x: 34, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandBuffer3 = commandEncoder12.finish();
try {
computePassEncoder11.setBindGroup(0, bindGroup19, new Uint32Array(2050), 249, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer25, 44, new Uint32Array(9723).map((_, i) => i * 1), 9270, 0);
} catch {}
let buffer29 = device0.createBuffer({size: 168, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false});
try {
renderBundleEncoder8.setVertexBuffer(5, buffer23, 12);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup26 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let buffer30 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_DST});
let texture48 = device0.createTexture({
  size: [1380, 1, 54],
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture3 = device0.importExternalTexture({source: videoFrame2});
try {
renderBundleEncoder7.setIndexBuffer(buffer4, 'uint16', 0, 3);
} catch {}
let texture49 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 1},
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder7.setBindGroup(2, bindGroup13, new Uint32Array(1563), 47, 0);
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
let textureView58 = texture12.createView({dimension: '2d-array'});
try {
commandEncoder24.copyTextureToTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 106, y: 0, z: 59},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
},
{width: 44, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder11.insertDebugMarker('\u9a48');
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: imageData1,
  origin: { x: 0, y: 3 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 7, y: 66, z: 24},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 20, height: 24, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let commandEncoder26 = device0.createCommandEncoder({});
let textureView59 = texture34.createView({mipLevelCount: 1});
try {
renderBundleEncoder7.setIndexBuffer(buffer6, 'uint32', 4, 6);
} catch {}
let imageData4 = new ImageData(12, 40);
let computePassEncoder14 = commandEncoder5.beginComputePass();
try {
computePassEncoder14.setPipeline(pipeline3);
} catch {}
try {
commandEncoder0.copyBufferToBuffer(buffer24, 28, buffer4, 0, 0);
} catch {}
let bindGroup27 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
let texture50 = device0.createTexture({
  size: [828, 1, 13],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder11.setPipeline(pipeline3);
} catch {}
let commandEncoder27 = device0.createCommandEncoder({});
let texture51 = device0.createTexture({
  size: [1, 1, 36],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture52 = device0.createTexture({
  size: [345],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
buffer3.unmap();
} catch {}
document.body.prepend(canvas0);
let bindGroup28 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let buffer31 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let texture53 = device0.createTexture({size: [256, 256, 19], format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_SRC});
let textureView60 = texture33.createView({dimension: '2d-array'});
try {
computePassEncoder7.setBindGroup(1, bindGroup20);
} catch {}
try {
renderBundleEncoder2.setBindGroup(2, bindGroup2, new Uint32Array(1047), 175, 0);
} catch {}
let promise6 = device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4},
  fragment: {
  module: shaderModule3,
  constants: {},
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 620, shaderLocation: 14},
          {format: 'uint16x4', offset: 160, shaderLocation: 2},
          {format: 'float32', offset: 44, shaderLocation: 1},
          {format: 'float32x2', offset: 16, shaderLocation: 6},
          {format: 'snorm8x4', offset: 308, shaderLocation: 9},
          {format: 'sint16x2', offset: 412, shaderLocation: 10},
          {format: 'float32', offset: 208, shaderLocation: 12},
          {format: 'snorm8x2', offset: 252, shaderLocation: 15},
          {format: 'uint32x4', offset: 196, shaderLocation: 11},
          {format: 'sint8x4', offset: 112, shaderLocation: 13},
          {format: 'snorm16x4', offset: 780, shaderLocation: 0},
          {format: 'unorm8x4', offset: 200, shaderLocation: 5},
          {format: 'uint32', offset: 24, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 8},
          {format: 'snorm16x4', offset: 0, shaderLocation: 4},
          {format: 'uint32', offset: 0, shaderLocation: 3},
        ],
      },
    ],
  },
});
let buffer32 = device0.createBuffer({
  size: 668,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder28 = device0.createCommandEncoder({label: ''});
let textureView61 = texture6.createView({});
let sampler5 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 54.86,
  maxAnisotropy: 1,
});
try {
renderBundleEncoder8.setIndexBuffer(buffer24, 'uint16', 22, 3);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline2);
} catch {}
try {
adapter1.label = '';
} catch {}
let commandEncoder29 = device0.createCommandEncoder({});
let sampler6 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 86.09});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 11, y: 12 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 119, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout5 = pipeline0.getBindGroupLayout(0);
let bindGroup29 = device0.createBindGroup({
  label: '\u{1ffd2}',
  layout: veryExplicitBindGroupLayout1,
  entries: [{binding: 93, resource: textureView5}],
});
let commandBuffer4 = commandEncoder23.finish();
try {
renderBundleEncoder5.setPipeline(pipeline2);
} catch {}
try {
commandEncoder25.clearBuffer(buffer4, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 31, y: 56, z: 19},
  aspect: 'all',
}, new Uint8Array(304_814).fill(213), /* required buffer size: 304_814 */
{offset: 262, bytesPerRow: 168, rowsPerImage: 66}, {width: 17, height: 31, depthOrArrayLayers: 28});
} catch {}
let pipeline4 = await promise6;
let commandEncoder30 = device0.createCommandEncoder({});
let texture54 = device0.createTexture({
  size: [690, 1, 53],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder14.setBindGroup(1, bindGroup9, new Uint32Array(6809), 2_583, 0);
} catch {}
try {
renderBundleEncoder5.insertDebugMarker('\u{1ffb5}');
} catch {}
try {
device0.queue.writeBuffer(buffer25, 4, new Uint32Array(14612).map((_, i) => i * 6), 1112, 4);
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'unspecified'} });
let videoFrame6 = new VideoFrame(videoFrame1, {timestamp: 0});
let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 59,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 61,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 109,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 308,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 312,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 524,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let textureView62 = texture12.createView({label: '\ub219\u54ff\u3313\u76d9\u6e7b\uc91e\u24e2\u5e90', dimension: '2d-array', baseArrayLayer: 0});
try {
computePassEncoder11.setBindGroup(0, bindGroup1);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup15, new Uint32Array(343), 139, 0);
} catch {}
try {
buffer18.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer23, 4, new DataView(new ArrayBuffer(2788)), 46, 32);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(133).fill(16), /* required buffer size: 133 */
{offset: 133}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline5 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 4, mask: 0x39df22f5},
  fragment: {
  module: shaderModule3,
  constants: {},
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {arrayStride: 580, stepMode: 'instance', attributes: []},
      {
        arrayStride: 96,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint16x4', offset: 12, shaderLocation: 15},
          {format: 'float16x4', offset: 24, shaderLocation: 5},
          {format: 'float32', offset: 12, shaderLocation: 2},
          {format: 'uint16x2', offset: 8, shaderLocation: 4},
          {format: 'sint8x2', offset: 58, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12},
          {format: 'float32x2', offset: 16, shaderLocation: 14},
          {format: 'sint32x2', offset: 20, shaderLocation: 8},
          {format: 'uint8x4', offset: 44, shaderLocation: 7},
          {format: 'snorm8x2', offset: 6, shaderLocation: 10},
          {format: 'snorm8x2', offset: 8, shaderLocation: 11},
          {format: 'unorm8x4', offset: 12, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'front'},
});
let bindGroup30 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout5, entries: [{binding: 93, resource: textureView1}]});
let commandBuffer5 = commandEncoder11.finish();
let textureView63 = texture39.createView({format: 'rgba16sint', mipLevelCount: 1});
try {
renderBundleEncoder12.setIndexBuffer(buffer24, 'uint32', 16, 6);
} catch {}
try {
commandEncoder0.copyTextureToTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 51},
  aspect: 'all',
},
{width: 139, height: 0, depthOrArrayLayers: 34});
} catch {}
try {
commandEncoder29.insertDebugMarker('\u845e');
} catch {}
try {
device0.queue.submit([commandBuffer5]);
} catch {}
await gc();
let commandEncoder31 = device0.createCommandEncoder({});
let computePassEncoder15 = commandEncoder26.beginComputePass();
try {
computePassEncoder15.setPipeline(pipeline1);
} catch {}
let textureView64 = texture34.createView({mipLevelCount: 1});
try {
renderBundleEncoder4.setBindGroup(0, bindGroup17);
} catch {}
let imageData5 = new ImageData(76, 20);
try {
globalThis.someLabel = sampler0.label;
} catch {}
let textureView65 = texture41.createView({});
try {
renderBundleEncoder8.setIndexBuffer(buffer6, 'uint16', 10, 26);
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
try {
device0.queue.writeBuffer(buffer23, 28, new DataView(new ArrayBuffer(25384)), 1018, 4);
} catch {}
let buffer33 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
try {
computePassEncoder7.setBindGroup(1, bindGroup23, new Uint32Array(91), 2, 0);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer6, 'uint32', 12, 62);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let bindGroup31 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
let buffer34 = device0.createBuffer({size: 132, usage: GPUBufferUsage.STORAGE});
try {
renderBundleEncoder6.setBindGroup(3, bindGroup27, new Uint32Array(112), 7, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer6, 'uint32', 0, 10);
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 592 */
  offset: 592,
  bytesPerRow: 15616,
  buffer: buffer32,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer32, 36, new DataView(new ArrayBuffer(7420)), 335, 52);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 176, y: 0, z: 8},
  aspect: 'all',
}, new Uint8Array(53).fill(15), /* required buffer size: 53 */
{offset: 53}, {width: 238, height: 0, depthOrArrayLayers: 1});
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData4,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 402, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas1 = document.createElement('canvas');
let textureView66 = texture51.createView({aspect: 'all', format: 'rg8uint', mipLevelCount: 1});
try {
renderBundleEncoder9.setIndexBuffer(buffer4, 'uint16', 2, 1);
} catch {}
try {
renderBundleEncoder5.pushDebugGroup('\u0a0d');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 36, new Float16Array(1093).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.8395)), 208, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture52,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(21).fill(115), /* required buffer size: 21 */
{offset: 21}, {width: 30, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 65, y: 0 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 97, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 41, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder32 = device0.createCommandEncoder({});
let computePassEncoder16 = commandEncoder19.beginComputePass();
try {
renderBundleEncoder7.setPipeline(pipeline4);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
renderBundleEncoder5.popDebugGroup();
} catch {}
let buffer35 = device0.createBuffer({size: 508, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let texture55 = device0.createTexture({
  size: [1380, 1, 1],
  sampleCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder17 = commandEncoder21.beginComputePass();
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder13.setBindGroup(1, bindGroup8, new Uint32Array(171), 16, 0);
} catch {}
try {
computePassEncoder16.setPipeline(pipeline3);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder33 = device0.createCommandEncoder({label: '\u6142'});
let texture56 = device0.createTexture({
  size: {width: 414, height: 1, depthOrArrayLayers: 21},
  mipLevelCount: 3,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder17.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup18);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 12, new Uint32Array(21832).map((_, i) => i * 2), 10138, 8);
} catch {}
try {
adapter0.label = '\u{1fc76}\u2126\u613d\u{1fc81}\u000d\u0880';
} catch {}
let commandEncoder34 = device0.createCommandEncoder({});
let texture57 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 91},
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView67 = texture14.createView({});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: false, stencilReadOnly: true});
try {
device0.queue.writeBuffer(buffer29, 4, new DataView(new Uint8Array(44603).map((_, i) => i).buffer), 1686, 24);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
document.body.append(canvas1);
let bindGroup32 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView5}]});
let buffer36 = device0.createBuffer({
  size: 32,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let textureView68 = texture46.createView({aspect: 'all'});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
let texture58 = device0.createTexture({
  size: [8, 8, 24],
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let texture59 = gpuCanvasContext0.getCurrentTexture();
let textureView69 = texture14.createView({dimension: '2d-array'});
let computePassEncoder18 = commandEncoder24.beginComputePass();
try {
buffer34.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let pipeline6 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 4, mask: 0x1d16fe0b},
  fragment: {
  module: shaderModule3,
  constants: {},
  targets: [{
  format: 'rgba16sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 148, shaderLocation: 9},
          {format: 'float32x4', offset: 68, shaderLocation: 6},
          {format: 'unorm16x2', offset: 132, shaderLocation: 10},
          {format: 'uint32x2', offset: 92, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front'},
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer2, 8, new Float32Array(8879).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.026)), 20, 0);
} catch {}
let bindGroup33 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]});
let buffer37 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder18.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer24, 'uint32', 16, 1);
} catch {}
document.body.prepend(canvas1);
try {
globalThis.someLabel = device0.label;
} catch {}
let textureView70 = texture31.createView({});
try {
device0.queue.writeTexture({
  texture: texture21,
  mipLevel: 2,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(311).fill(239), /* required buffer size: 311 */
{offset: 311}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline7 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {override4: 1}}});
try {
  await promise8;
} catch {}
let buffer38 = device0.createBuffer({
  size: 28,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
try {
renderBundleEncoder9.setPipeline(pipeline5);
} catch {}
let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let commandEncoder35 = device0.createCommandEncoder({});
let textureView71 = texture46.createView({});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], sampleCount: 1});
try {
computePassEncoder17.setBindGroup(0, bindGroup27, new Uint32Array(1876), 1_192, 0);
} catch {}
let recycledExplicitBindGroupLayout6 = pipeline1.getBindGroupLayout(0);
let bindGroup34 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView5}]});
let textureView72 = texture51.createView({mipLevelCount: 1});
let renderPassEncoder0 = commandEncoder35.beginRenderPass({
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: -219.1, g: -387.5, b: 834.7, a: 686.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']});
let externalTexture4 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
computePassEncoder13.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup11);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup23);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(3, buffer26, 0, 2);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer36, 0, new DataView(new ArrayBuffer(2750)), 38, 0);
} catch {}
document.body.append(canvas1);
let bindGroup35 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout5, entries: [{binding: 93, resource: textureView1}]});
let commandEncoder36 = device0.createCommandEncoder({});
let texture60 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder16.setBindGroup(3, bindGroup8, new Uint32Array(305), 1, 0);
} catch {}
try {
computePassEncoder15.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup6, new Uint32Array(8855), 1_610, 0);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING});
} catch {}
let gpuCanvasContext1 = canvas1.getContext('webgpu');
document.body.prepend(canvas1);
let texture61 = device0.createTexture({
  size: [2, 2, 1],
  mipLevelCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderPassEncoder1 = commandEncoder18.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: -747.1, g: -112.7, b: -372.1, a: -882.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderBundleEncoder4.setBindGroup(1, bindGroup29, new Uint32Array(2692), 192, 0);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer38, 'uint16', 0, 2);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(4, buffer23, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture46,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(91).fill(91), /* required buffer size: 91 */
{offset: 91}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder37 = device0.createCommandEncoder();
let computePassEncoder19 = commandEncoder0.beginComputePass();
try {
computePassEncoder19.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline4);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer36, 8, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer32, 136, new DataView(new ArrayBuffer(51888)), 871, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 690, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture47,
  mipLevel: 1,
  origin: {x: 200, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let textureView73 = texture6.createView({baseMipLevel: 0});
try {
renderBundleEncoder6.setIndexBuffer(buffer36, 'uint32', 12, 2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup27, new Uint32Array(510), 249, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup19, new Uint32Array(2066), 252, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let commandEncoder38 = device0.createCommandEncoder();
let textureView74 = texture16.createView({format: 'r32sint'});
try {
renderPassEncoder1.setBindGroup(0, bindGroup10, new Uint32Array(621), 49, 0);
} catch {}
try {
renderPassEncoder1.setStencilReference(357);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(6, buffer23, 0, 27);
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

diagnostic(info, xyz);

struct VertexInput9 {
  @location(10) @interpolate(flat) location_10: u32,
  @location(8) location_8: vec2h,
}

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

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

struct VertexInput8 {
  @location(3) @interpolate(flat) location_3: i32,
  @location(4) @interpolate(flat) location_4: i32,
}

struct VertexInput11 {
  @location(7) location_7: vec2f,
  @location(1) @interpolate(flat, first) location_1: vec4u,
  @location(11) @interpolate(flat) location_11: vec2u,
}

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

struct VertexInput12 {
  @location(15) @interpolate(flat) location_15: vec2u,
}

@group(0) @binding(7) var<storage, read> buffer40: array<array<f16, 2>, 96>;

@group(0) @binding(116) var<storage, read_write> buffer41: array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 23>, 1>, 1>, 8>>;

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

@group(0) @binding(60) var tex4: texture_multisampled_2d<i32>;

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

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

struct VertexInput14 {
  @location(5) location_5: vec4h,
}

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

struct T0 {
  f0: array<u32>,
}

var<workgroup> vw16: vec2i;

var<workgroup> vw18: array<array<array<array<vec4h, 5>, 4>, 1>, 1>;

struct VertexOutput2 {
  @location(3) @interpolate(flat, centroid) location_3: vec2h,
  @location(8) location_8: f32,
  @invariant @builtin(position) position: vec4f,
  @location(14) @interpolate(flat, centroid) location_14: vec2i,
  @location(2) location_2: vec2u,
  @location(4) location_4: vec4i,
}

struct T4 {
  f0: array<array<vec2f, 2>>,
}

struct VertexInput10 {
  @location(14) @interpolate(linear, first) location_14: vec4h,
}

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

var<workgroup> vw19: vec2<bool>;

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

var<workgroup> vw17: atomic<i32>;

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

struct VertexInput13 {
  @location(2) location_2: vec2u,
}

/* used global variables: buffer40, tex4 */
@vertex
fn vertex3(a0: VertexInput8, a1: VertexInput9, a2: VertexInput10, a3: VertexInput11, @location(13) location_13: vec4u, @location(9) location_9: vec4u, @location(6) @interpolate(perspective, first) location_6: vec2h, @location(0) @interpolate(flat) location_0: vec2h, a8: VertexInput12, a9: VertexInput13, @location(12) location_12: vec4h, a11: VertexInput14, a12: VertexInput15, @builtin(instance_index) instance_index: u32) -> VertexOutput2 {
  var out: VertexOutput2;
  let ptr16: ptr<storage, array<f16, 2>, read> = &(*&buffer40)[unconst_u32(59716463)];
  var vf23: bool = any(vec2<bool>(unconst_bool(false), unconst_bool(false)));
  let ptr17: ptr<storage, array<f16, 2>, read> = &(*&buffer40)[95];
  out.position = vec4f(a8.location_15.xyxx);
  out.position = vec4f(reflect(vec4h(unconst_f16(-6167.1), unconst_f16(-87.43), unconst_f16(15918.4), unconst_f16(5352.5)), vec4h(unconst_f16(736.5), unconst_f16(30524.0), unconst_f16(21315.6), unconst_f16(4399.7))).ywxy);
  out.location_3 += bitcast<vec2h>(a3.location_11[unconst_u32(208827852)]);
  out.position *= vec4f(f32(buffer40[95][1]));
  var vf24: f16 = cos(unconst_f16(877.5));
  vf23 = bool(textureDimensions(tex4)[0]);
  let ptr18: ptr<storage, f16, read> = &(*&buffer40)[95][1];
  return out;
  _ = buffer40;
  _ = tex4;
}

/* used global variables: buffer41 */
@compute @workgroup_size(1, 1, 1)
fn compute3(a0: ComputeInput3, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) {
  let ptr19: ptr<workgroup, vec4h> = &(*&vw18)[unconst_u32(1601756889)][0][3][4];
  let ptr20: ptr<storage, f16, read_write> = &buffer41[arrayLength(&buffer41)][unconst_u32(504271322)][unconst_u32(693014012)][unconst_u32(1049967045)][unconst_u32(720105791)][unconst_u32(867827880)][0][unconst_u32(783811190)][0];
  vw18[unconst_u32(394354723)][unconst_u32(404690683)][unconst_u32(290190671)][unconst_u32(1305566375)] *= vec4h((*&buffer41)[arrayLength(&(*&buffer41))][unconst_u32(645864597)][0][0][22][unconst_u32(163500864)][unconst_u32(818462862)][0][0]);
  for (var jj84=0u; jj84<6; jj84++) { vw18[unconst_u32(78264059)][unconst_u32(530498517)][jj84][unconst_u32(225720447)] += vec4h((*&buffer41)[unconst_u32(191585141)][7][unconst_u32(3115362690)][unconst_u32(406242004)][22][unconst_u32(1149668495)][u32(buffer41[arrayLength(&buffer41)][unconst_u32(2432215391)][0][u32((*&buffer41)[arrayLength(&(*&buffer41))][7][unconst_u32(381412990)][0][unconst_u32(1115311470)][0][0][unconst_u32(343390694)][0])][unconst_u32(1003846851)][0][0][0][unconst_u32(1076972753)])][unconst_u32(287727296)][unconst_u32(877025309)]); }
  vw19 = vec2<bool>(bool((*&buffer41)[unconst_u32(1271669102)][7][0][0][u32(buffer41[arrayLength(&buffer41)][7][0][unconst_u32(869248787)][22][unconst_u32(1011746422)][unconst_u32(84001523)][unconst_u32(84253691)][0])][0][0][0][0]));
  return;
  _ = buffer41;
}`,
});
let commandEncoder39 = device0.createCommandEncoder({});
let textureView75 = texture25.createView({});
try {
renderPassEncoder1.setVertexBuffer(3, buffer38, 0, 9);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let buffer42 = device0.createBuffer({size: 116, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder40 = device0.createCommandEncoder({});
try {
renderPassEncoder1.setBindGroup(2, bindGroup28);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup17, new Uint32Array(193), 9, 0);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup27);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer38, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline4);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 29, y: 21, z: 41},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup36 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: []});
try {
renderPassEncoder1.setIndexBuffer(buffer38, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder6.setBindGroup(0, bindGroup36, []);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline2);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder37.copyBufferToBuffer(buffer42, 72, buffer1, 32, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 690, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 8, y: 39 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 1,
  origin: {x: 399, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup36);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer4, 'uint16', 0, 2);
} catch {}
let commandEncoder41 = device0.createCommandEncoder({});
let textureView76 = texture13.createView({});
try {
renderBundleEncoder2.setIndexBuffer(buffer24, 'uint16', 16, 39);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup37 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let buffer43 = device0.createBuffer({size: 248, usage: GPUBufferUsage.COPY_SRC});
try {
computePassEncoder12.setBindGroup(0, bindGroup34, new Uint32Array(98), 11, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer35, 'uint16', 78, 65);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer6, 'uint32', 4, 3);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.prepend(canvas0);
let texture62 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 42},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
renderPassEncoder0.setVertexBuffer(2, buffer38, 0);
} catch {}
let pipeline8 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0xffffffff},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {arrayStride: 4, stepMode: 'instance', attributes: []},
      {
        arrayStride: 768,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x4', offset: 340, shaderLocation: 15},
          {format: 'float32x3', offset: 232, shaderLocation: 11},
          {format: 'sint8x4', offset: 296, shaderLocation: 8},
          {format: 'unorm8x2', offset: 30, shaderLocation: 14},
          {format: 'unorm16x2', offset: 44, shaderLocation: 10},
          {format: 'float32x2', offset: 148, shaderLocation: 2},
          {format: 'uint16x4', offset: 96, shaderLocation: 4},
          {format: 'unorm16x2', offset: 172, shaderLocation: 12},
          {format: 'uint16x4', offset: 180, shaderLocation: 7},
          {format: 'sint32x2', offset: 0, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 148,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x2', offset: 4, shaderLocation: 9}, {format: 'unorm8x2', offset: 8, shaderLocation: 5}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 59,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 61,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 109,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 308,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 312,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 524,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let texture63 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 27},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder2.setBindGroup(3, bindGroup6, new Uint32Array(496), 105, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 0, 0);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline6);
} catch {}
let commandEncoder42 = device0.createCommandEncoder();
let sampler7 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 51.68,
  lodMaxClamp: 97.44,
});
let textureView77 = texture47.createView({mipLevelCount: 1});
try {
renderPassEncoder0.setBindGroup(2, bindGroup8, new Uint32Array(2096), 435, 0);
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup21, new Uint32Array(3), 2, 0);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(7, buffer35);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
let buffer44 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder43 = device0.createCommandEncoder({});
try {
commandEncoder30.copyBufferToBuffer(buffer42, 24, buffer23, 40, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 16, new DataView(new Uint8Array(18682).map((_, i) => i).buffer), 11332, 0);
} catch {}
await gc();
try {
renderPassEncoder1.setIndexBuffer(buffer35, 'uint32', 132, 142);
} catch {}
document.body.append(canvas1);
let commandEncoder44 = device0.createCommandEncoder({});
let textureView78 = texture57.createView({aspect: 'all'});
let renderPassEncoder2 = commandEncoder4.beginRenderPass({colorAttachments: [{view: textureView46, loadOp: 'load', storeOp: 'discard'}]});
try {
computePassEncoder4.setBindGroup(2, bindGroup11);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup11);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(0, buffer3, 0, 1_238);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder15.setBindGroup(2, bindGroup23, new Uint32Array(610), 15, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer35, 'uint32', 44, 178);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let renderPassEncoder3 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: -448.5, g: 436.4, b: 328.8, a: 95.73, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder0.setIndexBuffer(buffer24, 'uint16', 30, 9);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer36, 0, new DataView(new ArrayBuffer(58552)), 3444, 0);
} catch {}
let buffer45 = device0.createBuffer({
  label: '\u024a\u1c01\u04ab',
  size: 104,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder1.setIndexBuffer(buffer35, 'uint32', 8, 55);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer36, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup36, new Uint32Array(4933), 149, 0);
} catch {}
let renderPassEncoder4 = commandEncoder15.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: -782.8, g: -195.8, b: -41.67, a: -487.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 78742919,
});
try {
renderPassEncoder3.setIndexBuffer(buffer36, 'uint32', 0, 2);
} catch {}
try {
buffer45.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 121, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(52).fill(138), /* required buffer size: 52 */
{offset: 52}, {width: 31, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let bindGroup38 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
try {
computePassEncoder15.setBindGroup(1, bindGroup35);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: -319.7, g: -652.1, b: 37.49, a: -895.3, });
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer38, 0, 3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 226, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise7;
} catch {}
let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let buffer46 = device0.createBuffer({size: 5696, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder45 = device0.createCommandEncoder();
let sampler8 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', magFilter: 'linear', lodMaxClamp: 62.30});
try {
renderBundleEncoder13.setIndexBuffer(buffer4, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(0, buffer26, 4, 2);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer36, 'uint32', 0, 9);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline8);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 28, new Float32Array(5149).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.753)), 1419, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 690, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas1,
  origin: { x: 70, y: 22 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 1,
  origin: {x: 58, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline9 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
let pipeline10 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 4, mask: 0xffffffff},
  fragment: {
  module: shaderModule3,
  constants: {},
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 268,
        attributes: [
          {format: 'unorm8x4', offset: 24, shaderLocation: 6},
          {format: 'uint32', offset: 4, shaderLocation: 7},
          {format: 'float32x3', offset: 100, shaderLocation: 10},
          {format: 'unorm16x2', offset: 4, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front'},
});
let commandEncoder46 = device0.createCommandEncoder({});
let textureView79 = texture23.createView({dimension: '2d', baseArrayLayer: 5});
let renderPassEncoder5 = commandEncoder36.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: 946.4, g: -417.3, b: -929.8, a: 733.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 38529395,
});
try {
renderPassEncoder3.setBindGroup(3, bindGroup31);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup38, new Uint32Array(2554), 416, 0);
} catch {}
try {
renderBundleEncoder12.drawIndirect(buffer19, 24);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(2, buffer38, 0, 1);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 4, new Float32Array(13836).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7858)), 3692, 4);
} catch {}
await gc();
let textureView80 = texture56.createView({dimension: '2d', mipLevelCount: 2, baseArrayLayer: 10});
let texture64 = device0.createTexture({
  size: [256, 256, 76],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16sint'],
});
let renderBundle0 = renderBundleEncoder12.finish({});
let externalTexture5 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
computePassEncoder14.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 0, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(1, buffer25, 20);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(3, buffer36, 0, 3);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
document.body.append(canvas1);
let textureView81 = texture21.createView({dimension: '2d-array', mipLevelCount: 1});
try {
renderPassEncoder3.setVertexBuffer(4, buffer38, 4, 2);
} catch {}
let bindGroup39 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]});
let commandEncoder47 = device0.createCommandEncoder();
try {
renderPassEncoder3.setBindGroup(0, bindGroup32);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer45, 'uint16', 4, 23);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(7, buffer3, 1_056);
} catch {}
try {
  await promise9;
} catch {}
let imageBitmap2 = await createImageBitmap(imageBitmap1);
let commandEncoder48 = device0.createCommandEncoder({});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], sampleCount: 1, depthReadOnly: false});
try {
renderPassEncoder3.setIndexBuffer(buffer35, 'uint32', 32, 131);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(4, buffer45, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer18, 12, new Uint32Array(17729).map((_, i) => i * 1), 5309, 0);
} catch {}
let buffer47 = device0.createBuffer({label: '', size: 24, usage: GPUBufferUsage.COPY_DST});
let textureView82 = texture49.createView({});
try {
renderBundleEncoder4.setIndexBuffer(buffer35, 'uint16', 0, 42);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(5, buffer3, 1_076, 1_704);
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

@group(0) @binding(4) var<storage, read> buffer49: array<array<array<array<f16, 107>, 1>, 1>>;

@id(46114) override override5: f32;

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

@group(0) @binding(49) var<storage, read_write> buffer52: vec4i;

@group(0) @binding(153) var<storage, read_write> buffer54: array<array<FragmentInput8, 1>, 26>;

@group(0) @binding(312) var sam4: sampler_comparison;

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

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

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

struct FragmentOutput4 {
  @location(3) @interpolate(flat, centroid) location_3: i32,
  @location(6) @interpolate(flat, center) location_6: vec2i,
  @location(0) location_0: vec4u,
}

struct FragmentOutput2 {
  @location(0) @interpolate(flat, center) location_0: vec4i,
  @location(1) location_1: i32,
}

@group(0) @binding(10) var<storage, read_write> buffer51: array<array<array<array<array<array<f16, 1>, 2>, 3>, 128>, 2>>;

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

/* used global variables: buffer49 */
fn fn0(a0: bool) -> array<array<array<vec2h, 1>, 1>, 5> {
  var out: array<array<array<vec2h, 1>, 1>, 5>;
  let vf25: vec2h = fma(vec2h(unconst_f16(9802.2), unconst_f16(36962.7)), vec2h(unconst_f16(4107.8), unconst_f16(66.63)), vec2h(unconst_f16(208.9), unconst_f16(1841.4)));
  let ptr21: ptr<storage, f16, read> = &(*&buffer49)[unconst_u32(511642499)][0][0][unconst_u32(123356333)];
  out[unconst_u32(97023600)][unconst_u32(4294967295)][unconst_u32(323326778)] -= bitcast<vec2h>(pack4x8snorm(vec4f(unconst_f32(0.5167), unconst_f32(0.4044), unconst_f32(0.2612), unconst_f32(0.1166))));
  out[unconst_u32(951188550)][unconst_u32(544257865)][0] = vec2h((*&buffer49)[arrayLength(&(*&buffer49))][0][0][106]);
  let ptr22: ptr<storage, f16, read> = &(*&buffer49)[unconst_u32(583374892)][unconst_u32(34009293)][0][106];
  return out;
  _ = buffer49;
}

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

@group(0) @binding(7) var<storage, read_write> buffer50: array<array<vec2i, 21>>;

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

@id(23593) override override6 = true;

/* used global variables: sam4 */
fn fn1() {
  let vf26: vec3f = degrees(vec3f(unconst_f32(0.1205), unconst_f32(0.1605e-2), unconst_f32(0.3256)));
  var vf27: vec3f = vf26;
  vf27 = vec3f(vf26[unconst_u32(1398826703)]);
  vf27 += vf27;
  let vf28: vec3i = countTrailingZeros(vec3i(i32(override5)));
  for (var it1=pack2x16snorm(vec2f(unconst_f32(-0.02401), unconst_f32(0.2034))); it1<(u32( !bool( -vec2h(unconst_f16(14811.2), unconst_f16(3550.8)).g)) & 0xfff); it1++) {
  _ = sam4;
  _ = sam4;
}
  let vf29: f32 = vf27[unconst_u32(1480325548)];
  vf27 = vec3f(bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.02411e-6), unconst_f32(0.2033)))));
  var vf30: vec3f = ldexp(vec3f(unconst_f32(0.4570e-13), unconst_f32(-0.08213e4), unconst_f32(0.02571)), vec3i(unconst_i32(224810645), unconst_i32(156401543), unconst_i32(132945416)));
  var vf31: vec3i = vf28;
  _ = override5;
  _ = sam4;
}

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

struct T2 {
  f0: array<array<array<u32, 1>, 12>, 1>,
}

struct T3 {
  f0: array<array<array<vec4h, 1>, 8>, 1>,
  @align(64) @size(256) f1: array<array<array<array<array<f32, 1>, 6>, 1>, 10>, 1>,
  @size(128) f2: vec4h,
  @align(16) @size(320) f3: array<T2, 2>,
  @size(1472) f4: array<array<vec2u, 10>, 5>,
}

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

@group(0) @binding(308) var st15: texture_storage_1d<r32sint, read_write>;

struct FragmentInput12 {
  @location(4) location_4: vec4i,
  @location(14) @interpolate(flat, centroid) location_14: vec2i,
  @location(8) location_8: f32,
  @location(2) location_2: vec2u,
}

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

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

@group(0) @binding(59) var<storage, read_write> buffer53: array<array<f16, 176>>;

struct FragmentInput9 {
  @location(8) location_8: f32,
}

struct T0 {
  f0: array<u32>,
}

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

@group(0) @binding(116) var tex6: texture_cube_array<f32>;

struct FragmentInput8 {
  @location(4) location_4: vec4i,
  @location(3) @interpolate(flat, centroid) location_3: vec2h,
}

@group(0) @binding(3) var st12: texture_storage_3d<rgba16float, write>;

/* used global variables: buffer50, buffer51, st12, st15 */
@fragment
fn fragment4(@location(2) location_2: vec2u, @location(14) @interpolate(flat) location_14: vec2i, @builtin(sample_index) sample_index: u32, a3: FragmentInput8, a4: FragmentInput9) -> FragmentOutput2 {
  var out: FragmentOutput2;
  for (var jj72=0u; jj72<130; jj72++) { for (var jj19=0u; jj19<4; jj19++) { buffer51[unconst_u32(45336907)][unconst_u32(860437573)][jj72][unconst_u32(101209827)][jj19][u32(buffer51[arrayLength(&buffer51)][1][unconst_u32(428891357)][2][u32((*&buffer51)[arrayLength(&(*&buffer51))][unconst_u32(421071725)][unconst_u32(897875593)][unconst_u32(235046227)][1][0])][unconst_u32(130064747)])] = buffer51[arrayLength(&buffer51)][unconst_u32(1003740324)][127][unconst_u32(605618734)][1][0]; } }
  let ptr23: ptr<storage, f16, read_write> = &(*&buffer51)[unconst_u32(1540348275)][unconst_u32(1363261559)][127][unconst_u32(109743257)][1][unconst_u32(2700915281)];
  let ptr24: ptr<storage, array<f16, 1>, read_write> = &(*&buffer51)[arrayLength(&(*&buffer51))][unconst_u32(385056311)][unconst_u32(563269529)][2][unconst_u32(42642820)];
  textureStore(st15, unconst_i32(22214560), vec4i(vec4i(unconst_i32(203595893), unconst_i32(6610038), unconst_i32(-116491723), unconst_i32(-85015356))));
  out.location_1 = i32(buffer51[arrayLength(&buffer51)][1][127][2][unconst_u32(881749435)][unconst_u32(475570900)]);
  textureStore(st12, vec3i(unconst_i32(699173839), unconst_i32(783446579), unconst_i32(649110281)), vec4f(vec4f(unconst_f32(0.1931), unconst_f32(0.06196e16), unconst_f32(0.2452e29), unconst_f32(0.2810e-41))));
  for (var ii27=0u; ii27<0x1000; ii27+=0x11) { buffer50[ii27][unconst_u32(954515451)] &= vec2i(i32((*&buffer51)[unconst_u32(1226251063)][1][127][2][1][0])); }
  let ptr25: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][u32((*&buffer51)[unconst_u32(612442297)][1][unconst_u32(1433820747)][2][unconst_u32(57487338)][0])][unconst_u32(252122016)][unconst_u32(93818253)][1][0];
  buffer51[unconst_u32(674166875)][1][unconst_u32(371667292)][unconst_u32(831021898)][unconst_u32(2267837389)][unconst_u32(374367659)] = (*&buffer51)[unconst_u32(889810558)][1][unconst_u32(99094864)][unconst_u32(447606000)][1][0];
  out.location_1 = i32(buffer51[arrayLength(&buffer51)][1][127][unconst_u32(1180654935)][1][0]);
  out.location_1 = i32((*&buffer51)[arrayLength(&(*&buffer51))][unconst_u32(495886588)][unconst_u32(441273393)][unconst_u32(1379151462)][unconst_u32(437400437)][unconst_u32(176427368)]);
  return out;
  _ = buffer51;
  _ = st12;
  _ = buffer50;
  _ = st15;
}

/* used global variables: buffer51, st12 */
@fragment
fn fragment5(@builtin(sample_mask) sample_mask: u32, a1: FragmentInput10, @builtin(sample_index) sample_index: u32) -> FragmentOutput3 {
  var out: FragmentOutput3;
  let ptr26: ptr<storage, f16, read_write> = &(*&buffer51)[unconst_u32(208859165)][unconst_u32(533603716)][unconst_u32(1368698587)][unconst_u32(585099342)][unconst_u32(585617861)][0];
  let ptr27: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][unconst_u32(316980237)][unconst_u32(2192442421)][u32((*&buffer51)[unconst_u32(547492709)][unconst_u32(1375060656)][127][2][1][0])][unconst_u32(1277855236)][0];
  let ptr28: ptr<storage, f16, read_write> = &buffer51[unconst_u32(658822933)][u32((*&buffer51)[arrayLength(&(*&buffer51))][1][u32((*&buffer51)[arrayLength(&(*&buffer51))][u32(buffer51[unconst_u32(3969352897)][1][127][2][1][0])][unconst_u32(319578502)][2][1][0])][2][unconst_u32(656946519)][0])][unconst_u32(618140777)][2][1][0];
  textureStore(st12, vec3i(unconst_i32(302162057), unconst_i32(441561426), unconst_i32(287313451)), vec4f(vec4f(unconst_f32(0.08770), unconst_f32(0.1289), unconst_f32(0.05484), unconst_f32(0.1099))));
  return out;
  _ = st12;
  _ = buffer51;
}

/* used global variables: buffer50, buffer51 */
@fragment
fn fragment6(a0: FragmentInput11, @location(3) location_3: vec2h, a2: FragmentInput12, a3: FragmentInput13, @builtin(position) position: vec4f, @builtin(sample_index) sample_index: u32) -> FragmentOutput4 {
  var out: FragmentOutput4;
  let ptr29: ptr<storage, array<array<f16, 1>, 2>, read_write> = &buffer51[unconst_u32(48349769)][1][unconst_u32(161389384)][2];
  {
  let ptr30: ptr<storage, f16, read_write> = &buffer51[u32(buffer51[arrayLength(&buffer51)][1][127][unconst_u32(387508500)][1][0])][unconst_u32(1289396704)][unconst_u32(954785908)][u32((*&buffer51)[unconst_u32(424594703)][unconst_u32(301429971)][127][2][1][0])][unconst_u32(600748858)][0];
  if bool((*&buffer51)[arrayLength(&(*&buffer51))][unconst_u32(2086096870)][127][2][1][0]) {
  loop {
  let ptr31: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][1][unconst_u32(356335400)][unconst_u32(351566929)][unconst_u32(226052451)][0];
  let vf32: u32 = a2.location_2[unconst_u32(1225725947)];
  break;
  _ = buffer51;
}
  {
  out.location_6 = vec2i(i32((*&buffer51)[unconst_u32(1031412164)][1][127][2][1][unconst_u32(2075002093)]));
  out.location_0 -= vec4u(u32(buffer51[arrayLength(&buffer51)][unconst_u32(93234943)][127][unconst_u32(518116208)][unconst_u32(2456236552)][0]));
  let ptr32: ptr<function, FragmentOutput4> = &out;
  _ = buffer51;
}
  while bool((*&buffer51)[unconst_u32(260445915)][unconst_u32(85213171)][127][unconst_u32(2061611662)][u32(buffer51[unconst_u32(436940515)][1][unconst_u32(68660233)][unconst_u32(327860398)][unconst_u32(18667649)][0])][0]) {
  out.location_6 = vec2i(i32(buffer51[arrayLength(&buffer51)][unconst_u32(31100782)][127][2][unconst_u32(1716615624)][unconst_u32(737450572)]));
  out.location_0 = vec4u(u32((*&buffer50)[arrayLength(&(*&buffer50))][20][unconst_u32(1723804513)]));
  let ptr33: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][unconst_u32(503044121)][127][2][unconst_u32(1678238141)][0];
  _ = buffer51;
  _ = buffer50;
}
  let ptr34: ptr<storage, array<array<array<array<f16, 1>, 2>, 3>, 128>, read_write> = &(*&buffer51)[arrayLength(&(*&buffer51))][1];
  _ = buffer50;
  _ = buffer51;
}
  let ptr35: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][1][127][2][1][unconst_u32(138987392)];
  let ptr36: ptr<storage, f16, read_write> = &buffer51[unconst_u32(288961718)][u32((*&buffer51)[arrayLength(&(*&buffer51))][1][unconst_u32(1092263051)][2][1][0])][127][2][unconst_u32(1117272955)][u32((*&buffer51)[unconst_u32(151768537)][unconst_u32(1004496934)][unconst_u32(591056052)][2][unconst_u32(180625937)][0])];
  _ = buffer50;
  _ = buffer51;
}
  let ptr37: ptr<storage, array<array<array<f16, 1>, 2>, 3>, read_write> = &buffer51[arrayLength(&buffer51)][1][unconst_u32(325587972)];
  let ptr38: ptr<storage, array<f16, 1>, read_write> = &buffer51[arrayLength(&buffer51)][1][127][2][1];
  let ptr39: ptr<storage, array<f16, 1>, read_write> = &(*&buffer51)[unconst_u32(444538825)][unconst_u32(1070075072)][127][2][1];
  buffer50[unconst_u32(1008672232)][unconst_u32(1272784644)] |= vec2i(i32((*&buffer51)[unconst_u32(1982931254)][unconst_u32(197349751)][unconst_u32(121652139)][2][1][unconst_u32(273183968)]));
  let ptr40: ptr<storage, array<array<array<f16, 1>, 2>, 3>, read_write> = &buffer51[u32(buffer51[unconst_u32(10956809)][unconst_u32(704433095)][127][2][1][unconst_u32(380286937)])][1][127];
  return out;
  _ = buffer50;
  _ = buffer51;
}

/* used global variables: buffer50, buffer52, buffer53, buffer54, st15, tex6 */
@compute @workgroup_size(3, 1, 1)
fn compute4(a0: ComputeInput4, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u) {
  buffer50[unconst_u32(230622637)][unconst_u32(1436019643)] -= (*&buffer54)[25][0].location_4.zw;
  buffer52 |= (*&buffer50)[arrayLength(&(*&buffer50))][20].gggr;
  while bool(buffer53[unconst_u32(354081754)][unconst_u32(525388082)]) {
  buffer54[unconst_u32(38180289)][unconst_u32(7076139)] = FragmentInput8(vec4i(bitcast<i32>(max(unconst_f32(0.03531e-34), unconst_f32(0.06818e-2)))), bitcast<vec2h>(max(unconst_f32(0.03531e-34), unconst_f32(0.06818e-2))));
  textureStore(st15, unconst_i32(373823305), vec4i(vec4i(i32(textureNumLevels(tex6)))));
  break;
  _ = st15;
  _ = buffer54;
  _ = tex6;
}
  _ = buffer50;
  _ = st15;
  _ = buffer54;
  _ = tex6;
  _ = buffer53;
  _ = buffer52;
}`,
});
let buffer55 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let commandEncoder49 = device0.createCommandEncoder({});
let sampler9 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.02,
  maxAnisotropy: 8,
});
let externalTexture6 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
renderBundleEncoder10.setVertexBuffer(0, buffer3, 2_392);
} catch {}
document.body.prepend(canvas1);
await gc();
let bindGroup40 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView5}]});
let buffer56 = device0.createBuffer({size: 436, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false});
let commandEncoder50 = device0.createCommandEncoder({label: ''});
let computePassEncoder20 = commandEncoder46.beginComputePass();
let externalTexture7 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup19);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer26);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'srgb'});
} catch {}
let textureView83 = texture58.createView({baseArrayLayer: 0});
let renderPassEncoder6 = commandEncoder45.beginRenderPass({
  colorAttachments: [{
  view: textureView77,
  clearValue: { r: -32.52, g: 706.2, b: 929.0, a: -232.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 552004775,
});
try {
computePassEncoder13.setBindGroup(3, bindGroup20, []);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(266), 14, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(0, buffer38, 0);
} catch {}
try {
commandEncoder30.copyBufferToBuffer(buffer32, 92, buffer29, 36, 36);
} catch {}
try {
renderPassEncoder5.insertDebugMarker('\u3baa');
} catch {}
document.body.append(canvas1);
let videoFrame7 = new VideoFrame(videoFrame6, {timestamp: 0});
let buffer57 = device0.createBuffer({size: 169, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX});
let renderPassEncoder7 = commandEncoder33.beginRenderPass({
  colorAttachments: [{
  view: textureView77,
  clearValue: { r: -278.1, g: -366.2, b: 283.9, a: -596.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder16.setBindGroup(1, bindGroup21, new Uint32Array(950), 2, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup30, new Uint32Array(1820), 96, 0);
} catch {}
try {
renderPassEncoder4.setStencilReference(1141);
} catch {}
try {
commandEncoder48.copyTextureToTexture({
  texture: texture57,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture58,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 2});
} catch {}
document.body.append(canvas0);
let bindGroup41 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 38, resource: textureView35},
    {binding: 0, resource: {buffer: buffer34, offset: 0}},
    {binding: 2, resource: textureView31},
  ],
});
let texture65 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView84 = texture45.createView({baseArrayLayer: 0});
try {
renderPassEncoder6.setBindGroup(1, bindGroup40, new Uint32Array(242), 59, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer24, 'uint16', 20, 0);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline10);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
computePassEncoder18.insertDebugMarker('\u{1fedf}');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 0, new DataView(new Uint8Array(13710).map((_, i) => i).buffer), 1026, 16);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture66 = device0.createTexture({
  size: [828, 1, 7],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView85 = texture55.createView({format: 'bgra8unorm-srgb', baseMipLevel: 0});
try {
renderPassEncoder0.setBindGroup(2, bindGroup28);
} catch {}
let textureView86 = texture7.createView({dimension: '2d', aspect: 'all'});
let renderPassEncoder8 = commandEncoder20.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: -593.4, g: 279.4, b: -285.2, a: -917.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 279835565,
});
try {
computePassEncoder5.setBindGroup(0, bindGroup13, new Uint32Array(363), 363, 0);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup38, new Uint32Array(722), 113, 0);
} catch {}
try {
renderBundleEncoder6.draw(132, 0, 2_450_939_040);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer36, 0);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline6);
} catch {}
try {
buffer36.unmap();
} catch {}
let bindGroup42 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout13,
  entries: [
    {binding: 4, resource: {buffer: buffer15, offset: 512}},
    {binding: 312, resource: sampler0},
    {binding: 153, resource: {buffer: buffer46}},
    {binding: 1, resource: {buffer: buffer27}},
    {binding: 109, resource: textureView26},
    {binding: 2, resource: externalTexture5},
    {binding: 524, resource: textureView85},
    {binding: 49, resource: {buffer: buffer34}},
    {binding: 5, resource: externalTexture2},
    {binding: 59, resource: {buffer: buffer46}},
    {binding: 0, resource: textureView32},
    {binding: 308, resource: textureView55},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 116, resource: textureView4},
    {binding: 61, resource: textureView9},
    {binding: 159, resource: sampler1},
    {binding: 17, resource: externalTexture3},
    {binding: 7, resource: {buffer: buffer46}},
    {binding: 3, resource: textureView42},
  ],
});
let buffer58 = device0.createBuffer({
  size: 219,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let externalTexture8 = device0.importExternalTexture({source: videoFrame2});
try {
computePassEncoder9.setBindGroup(1, bindGroup6, new Uint32Array(815), 43, 0);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer57, 'uint16', 2, 16);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(0, buffer26, 0, 35);
} catch {}
try {
buffer32.unmap();
} catch {}
let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
let sampler10 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', maxAnisotropy: 1});
try {
renderPassEncoder7.setIndexBuffer(buffer35, 'uint32', 36, 31);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer6, 'uint16', 8, 31);
} catch {}
try {
device0.queue.writeBuffer(buffer4, 0, new Float32Array(34690).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.2146)), 4484, 0);
} catch {}
try {
externalTexture2.label = '\u0eee\u924a\u0585\u{1f634}\u71ff';
} catch {}
let commandEncoder51 = device0.createCommandEncoder({label: ''});
let texture67 = device0.createTexture({
  size: [2, 2, 1],
  sampleCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder19.setBindGroup(3, bindGroup40);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let bindGroup43 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 153, resource: {buffer: buffer15}},
    {binding: 7, resource: {buffer: buffer46, offset: 2304}},
    {binding: 59, resource: {buffer: buffer46, size: 1512}},
    {binding: 17, resource: externalTexture8},
    {binding: 1, resource: {buffer: buffer22, size: 72}},
    {binding: 159, resource: sampler10},
    {binding: 49, resource: {buffer: buffer25, size: 16}},
    {binding: 524, resource: textureView80},
    {binding: 308, resource: textureView16},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 2, resource: externalTexture0},
    {binding: 0, resource: textureView32},
    {binding: 5, resource: externalTexture5},
    {binding: 116, resource: textureView4},
    {binding: 109, resource: textureView11},
    {binding: 312, resource: sampler2},
    {binding: 61, resource: textureView9},
    {binding: 4, resource: {buffer: buffer15, offset: 768}},
    {binding: 3, resource: textureView57},
  ],
});
let texture68 = device0.createTexture({
  size: [207],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder6.drawIndexedIndirect(buffer0, 32);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
renderPassEncoder5.pushDebugGroup('\u0b8c');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 99, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(20).fill(198), /* required buffer size: 20 */
{offset: 20}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
let recycledExplicitBindGroupLayout7 = pipeline3.getBindGroupLayout(0);
let commandEncoder52 = device0.createCommandEncoder();
let texture69 = device0.createTexture({
  size: [207],
  dimension: '1d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture70 = device0.createTexture({
  size: [8, 8, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder2.setBindGroup(0, bindGroup36);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer32, 68);
} catch {}
try {
textureView15.label = '';
} catch {}
let recycledExplicitBindGroupLayout8 = pipeline3.getBindGroupLayout(0);
let buffer59 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_SRC});
let textureView87 = texture69.createView({mipLevelCount: 1});
try {
renderPassEncoder5.popDebugGroup();
} catch {}
document.body.prepend(canvas0);
let bindGroup44 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 16, resource: {buffer: buffer4}},
    {binding: 65, resource: externalTexture8},
    {binding: 4, resource: textureView45},
  ],
});
let commandEncoder53 = device0.createCommandEncoder({});
try {
renderBundleEncoder19.setBindGroup(0, bindGroup15);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(0, buffer25, 32, 9);
} catch {}
try {
buffer18.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: imageData5,
  origin: { x: 16, y: 0 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 22, y: 13, z: 79},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 15, height: 3, depthOrArrayLayers: 0});
} catch {}
let commandEncoder54 = device0.createCommandEncoder({});
try {
computePassEncoder11.setBindGroup(0, bindGroup33);
} catch {}
try {
computePassEncoder7.setBindGroup(1, bindGroup19, new Uint32Array(9), 0, 0);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup38, new Uint32Array(2166), 402, 0);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let autogeneratedBindGroupLayout2 = pipeline9.getBindGroupLayout(0);
let commandEncoder55 = device0.createCommandEncoder({});
let textureView88 = texture40.createView({baseArrayLayer: 21, arrayLayerCount: 81});
let renderPassEncoder9 = commandEncoder55.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  clearValue: { r: -14.55, g: -305.6, b: -261.9, a: -122.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder13.setBindGroup(0, bindGroup37);
} catch {}
try {
computePassEncoder9.setBindGroup(1, bindGroup37, new Uint32Array(1853), 71, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup15, new Uint32Array(130), 6, 0);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer58, 76);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer57, 'uint16', 8, 7);
} catch {}
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'iec61966-2-1'} });
let buffer60 = device0.createBuffer({size: 108, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder56 = device0.createCommandEncoder({});
let texture71 = device0.createTexture({
  size: [345],
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture72 = device0.createTexture({
  size: [207, 1, 50],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder4.setIndexBuffer(buffer55, 'uint16', 8, 3);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer36, 0, 7);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup40);
} catch {}
try {
device0.queue.writeBuffer(buffer32, 116, new DataView(new ArrayBuffer(44838)), 18, 0);
} catch {}
let pipeline11 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x500faba4},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment4',
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule4,
    buffers: [
      {
        arrayStride: 36,
        attributes: [
          {format: 'sint32x3', offset: 0, shaderLocation: 3},
          {format: 'uint8x4', offset: 0, shaderLocation: 9},
          {format: 'uint16x4', offset: 4, shaderLocation: 2},
          {format: 'uint32x2', offset: 0, shaderLocation: 1},
          {format: 'float32x3', offset: 0, shaderLocation: 8},
          {format: 'uint32', offset: 8, shaderLocation: 11},
          {format: 'unorm8x4', offset: 0, shaderLocation: 5},
          {format: 'uint16x4', offset: 0, shaderLocation: 10},
          {format: 'unorm8x4', offset: 0, shaderLocation: 0},
          {format: 'uint32x4', offset: 0, shaderLocation: 13},
          {format: 'sint8x4', offset: 0, shaderLocation: 4},
          {format: 'uint8x4', offset: 4, shaderLocation: 15},
          {format: 'float32x2', offset: 0, shaderLocation: 14},
          {format: 'unorm8x2', offset: 0, shaderLocation: 7},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 6},
        ],
      },
      {arrayStride: 52, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x2', offset: 1136, shaderLocation: 12}],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: false,
},
});
let commandEncoder57 = device0.createCommandEncoder({});
try {
renderBundleEncoder6.draw(303, 0, 1_116_468_984);
} catch {}
try {
renderBundleEncoder6.drawIndexedIndirect(buffer36, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas1,
  origin: { x: 27, y: 40 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 76, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture73 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 390},
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder8.setVertexBuffer(7, buffer25, 0, 25);
} catch {}
try {
renderBundleEncoder6.draw(31, 0, 31_932_516);
} catch {}
try {
renderBundleEncoder6.drawIndexedIndirect(buffer19, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
await gc();
try {
globalThis.someLabel = commandEncoder36.label;
} catch {}
let texture74 = device0.createTexture({
  size: {width: 414},
  dimension: '1d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture75 = device0.createTexture({
  size: {width: 345},
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView89 = texture35.createView({dimension: '2d', baseArrayLayer: 1});
let computePassEncoder21 = commandEncoder42.beginComputePass();
try {
computePassEncoder13.setBindGroup(3, bindGroup13, new Uint32Array(2065), 60, 0);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer24, 'uint32', 52, 3);
} catch {}
try {
renderBundleEncoder6.draw(147, 0, 432_977_133, 0);
} catch {}
try {
renderBundleEncoder6.drawIndexedIndirect(buffer36, 0);
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 656 */
  offset: 656,
  bytesPerRow: 29696,
  buffer: buffer32,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 120, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup45 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 7, resource: textureView46},
    {binding: 16, resource: textureView17},
    {binding: 3, resource: {buffer: buffer46}},
    {binding: 1, resource: textureView44},
    {binding: 2, resource: {buffer: buffer7, offset: 0, size: 28}},
  ],
});
let texture76 = device0.createTexture({
  label: '\u4162\u{1f716}\u0f7a\u0faf',
  size: {width: 1380, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture9 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder20.setBindGroup(1, bindGroup5, new Uint32Array(4782), 1_622, 0);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder52.copyTextureToTexture({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 73, y: 0, z: 39},
  aspect: 'all',
},
{
  texture: texture46,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
bindGroup16.label = '\u0071\ue7a2\u0946';
} catch {}
let bindGroup46 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView5}]});
let buffer61 = device0.createBuffer({
  size: 180,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture77 = device0.createTexture({
  size: [345, 1, 41],
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView90 = texture7.createView({aspect: 'all', arrayLayerCount: 1});
try {
renderPassEncoder4.setBindGroup(1, bindGroup19, new Uint32Array(339), 35, 0);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup5);
} catch {}
try {
renderBundleEncoder0.setBindGroup(0, bindGroup36, new Uint32Array(697), 62, 0);
} catch {}
let texture78 = device0.createTexture({
  size: {width: 2760, height: 1, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture10 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'});
try {
renderPassEncoder2.setBindGroup(3, bindGroup3, new Uint32Array(264), 82, 0);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST, colorSpace: 'srgb'});
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpteRp431', transfer: 'bt1361ExtendedColourGamut'} });
let textureView91 = texture76.createView({label: '\u05f9\u6d28\u0e62\u0689', format: 'rg32uint', arrayLayerCount: 1});
let textureView92 = texture8.createView({});
try {
renderPassEncoder3.setBindGroup(0, bindGroup28, new Uint32Array(3444), 557, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer55, 'uint32', 0, 1);
} catch {}
try {
commandEncoder29.copyBufferToTexture({
  /* bytesInLastRow: 1432 widthInBlocks: 358 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 160 */
  offset: 160,
  bytesPerRow: 18176,
  buffer: buffer56,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 91, y: 0, z: 2},
  aspect: 'all',
}, {width: 358, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let commandEncoder58 = device0.createCommandEncoder({});
let textureView93 = texture73.createView({mipLevelCount: 1});
let textureView94 = texture29.createView({});
try {
renderPassEncoder4.setBindGroup(0, bindGroup46, new Uint32Array(319), 90, 0);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup41, new Uint32Array(168), 5, 0);
} catch {}
try {
renderBundleEncoder6.draw(44, 0, 589_580_708, 0);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer26, 0);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer60, 'uint16', 2, 24);
} catch {}
try {
device0.queue.writeBuffer(buffer30, 84, new Float32Array(17106).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9915)), 39, 0);
} catch {}
let bindGroup47 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let buffer62 = device0.createBuffer({size: 144, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
try {
computePassEncoder5.setBindGroup(1, bindGroup37);
} catch {}
try {
renderBundleEncoder6.drawIndexedIndirect(buffer58, 0);
} catch {}
let textureView95 = texture73.createView({format: 'r32float'});
try {
renderPassEncoder5.setIndexBuffer(buffer36, 'uint32', 8, 7);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup38);
} catch {}
try {
renderBundleEncoder6.draw(44, 0, 372_212_962);
} catch {}
try {
renderBundleEncoder6.drawIndexedIndirect(buffer23, 104);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(1, buffer6);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas1);
let buffer63 = device0.createBuffer({size: 72, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let commandEncoder59 = device0.createCommandEncoder({});
let textureView96 = texture30.createView({dimension: '3d', mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']});
try {
computePassEncoder9.setBindGroup(3, bindGroup28, new Uint32Array(3417), 535, 0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup37, new Uint32Array(642), 228, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer45, 'uint32', 8, 14);
} catch {}
try {
renderBundleEncoder6.drawIndirect(buffer23, 44);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer4, 'uint16', 0, 1);
} catch {}
try {
commandEncoder30.copyBufferToTexture({
  /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 40 */
  offset: 40,
  bytesPerRow: 256,
  buffer: buffer42,
}, {
  texture: texture75,
  mipLevel: 0,
  origin: {x: 46, y: 0, z: 0},
  aspect: 'all',
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 113, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture57,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 18},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 6});
} catch {}
try {
device0.queue.writeBuffer(buffer23, 28, new DataView(new ArrayBuffer(48044)), 432, 4);
} catch {}
let bindGroup48 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout9,
  entries: [
    {binding: 0, resource: textureView22},
    {binding: 5, resource: externalTexture10},
    {binding: 153, resource: {buffer: buffer15}},
    {binding: 312, resource: sampler2},
    {binding: 1, resource: {buffer: buffer58, size: 78}},
    {binding: 17, resource: externalTexture1},
    {binding: 4, resource: {buffer: buffer46}},
    {binding: 7, resource: {buffer: buffer15, size: 596}},
    {binding: 308, resource: textureView55},
    {binding: 59, resource: {buffer: buffer22, offset: 0, size: 352}},
    {binding: 3, resource: textureView41},
    {binding: 524, resource: textureView80},
    {binding: 61, resource: textureView9},
    {binding: 49, resource: {buffer: buffer7}},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 116, resource: textureView2},
    {binding: 159, resource: sampler3},
    {binding: 109, resource: textureView23},
    {binding: 2, resource: externalTexture9},
  ],
});
let commandEncoder60 = device0.createCommandEncoder();
let textureView97 = texture11.createView({});
try {
renderPassEncoder7.setVertexBuffer(7, buffer38, 0, 4);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup36, new Uint32Array(368), 36, 0);
} catch {}
try {
renderBundleEncoder6.drawIndexedIndirect(buffer19, 36);
} catch {}
try {
renderBundleEncoder5.drawIndirect(buffer0, 200);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder38.copyBufferToBuffer(buffer21, 36, buffer47, 0, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: canvas1,
  origin: { x: 72, y: 0 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 53, y: 29, z: 52},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 8, height: 9, depthOrArrayLayers: 0});
} catch {}
let commandEncoder61 = device0.createCommandEncoder({});
try {
renderPassEncoder7.setBindGroup(0, bindGroup35, new Uint32Array(4065), 600, 0);
} catch {}
try {
commandEncoder53.insertDebugMarker('\u8a14');
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'unspecified'} });
let commandEncoder62 = device0.createCommandEncoder({});
let texture79 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder7.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer0, 24); };
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer45, 'uint16', 48, 18);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup40);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer62, 'uint16', 14, 74);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer58, 0);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture68,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture69,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 187, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(9).fill(183), /* required buffer size: 9 */
{offset: 9, bytesPerRow: 4003}, {width: 996, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'unspecified', transfer: 'smpteSt4281'} });
let bindGroup49 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 239, resource: {buffer: buffer58, size: 93}},
    {binding: 2, resource: textureView45},
    {binding: 25, resource: {buffer: buffer25, size: 40}},
  ],
});
let renderBundle1 = renderBundleEncoder6.finish({});
try {
computePassEncoder2.setBindGroup(0, bindGroup48, new Uint32Array(6565), 422, 2);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); };
} catch {}
try {
buffer21.unmap();
} catch {}
try {
renderBundleEncoder15.insertDebugMarker('\u1711');
} catch {}
let textureView98 = texture78.createView({format: 'rg32uint'});
try {
computePassEncoder14.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer1, 20); };
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer6, 'uint32', 4, 8);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer26, 0, 21);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup38);
} catch {}
try {
renderBundleEncoder5.drawIndirect(buffer22, 36);
} catch {}
let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', minBindingSize: 10, hasDynamicOffset: false },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 154,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let renderBundle2 = renderBundleEncoder5.finish({});
try {
computePassEncoder20.setBindGroup(0, bindGroup22);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer19, 4); };
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer45);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup45, new Uint32Array(670), 156, 0);
} catch {}
try {
  await buffer31.mapAsync(GPUMapMode.WRITE, 0, 4);
} catch {}
canvas1.height = 478;
await gc();
let bindGroup50 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let buffer64 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder63 = device0.createCommandEncoder({});
let renderPassEncoder10 = commandEncoder27.beginRenderPass({
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: 877.4, g: -411.4, b: 346.5, a: -858.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder8.setVertexBuffer(1, buffer35, 0);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline10);
} catch {}
let pipeline12 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule2, constants: {}}});
let offscreenCanvas0 = new OffscreenCanvas(183, 403);
let imageData6 = new ImageData(36, 28);
let commandEncoder64 = device0.createCommandEncoder({});
let texture80 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 83},
  sampleCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer60, 16); };
} catch {}
try {
buffer29.unmap();
} catch {}
let autogeneratedBindGroupLayout3 = pipeline8.getBindGroupLayout(1);
let commandEncoder65 = device0.createCommandEncoder({});
try {
computePassEncoder21.setBindGroup(0, bindGroup3);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer19, 12); };
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer62, 'uint32', 28, 40);
} catch {}
try {
renderBundleEncoder4.setBindGroup(1, bindGroup38, new Uint32Array(838), 94, 0);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline11);
} catch {}
let buffer65 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let textureView99 = texture9.createView({});
try {
computePassEncoder13.setBindGroup(0, bindGroup48, new Uint32Array(1692), 380, 2);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(2); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer32, 132); };
} catch {}
try {
renderBundleEncoder4.drawIndirect(buffer19, 0);
} catch {}
let pipeline13 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5}});
let pipeline14 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 4},
  fragment: {
  module: shaderModule3,
  constants: {},
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule1,
    constants: {},
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 240, shaderLocation: 10},
          {format: 'float16x4', offset: 1064, shaderLocation: 4},
          {format: 'float32x4', offset: 1368, shaderLocation: 6},
          {format: 'snorm16x2', offset: 868, shaderLocation: 1},
          {format: 'float32x3', offset: 124, shaderLocation: 14},
          {format: 'float32x4', offset: 200, shaderLocation: 15},
          {format: 'snorm8x4', offset: 656, shaderLocation: 0},
          {format: 'uint32x3', offset: 476, shaderLocation: 2},
          {format: 'uint32x3', offset: 292, shaderLocation: 7},
          {format: 'snorm16x4', offset: 328, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 16,
        attributes: [
          {format: 'float32x3', offset: 0, shaderLocation: 5},
          {format: 'uint32x4', offset: 0, shaderLocation: 11},
          {format: 'sint32x4', offset: 0, shaderLocation: 13},
          {format: 'uint16x4', offset: 0, shaderLocation: 3},
          {format: 'sint32x4', offset: 0, shaderLocation: 8},
          {format: 'unorm16x4', offset: 0, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'ccw'},
});
let commandEncoder66 = device0.createCommandEncoder({});
let computePassEncoder22 = commandEncoder29.beginComputePass();
try {
computePassEncoder19.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer57, 'uint32', 16, 21);
} catch {}
try {
buffer19.unmap();
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.prepend(canvas0);
let commandEncoder67 = device0.createCommandEncoder({});
let computePassEncoder23 = commandEncoder41.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer23, 8); };
} catch {}
try {
computePassEncoder20.end();
} catch {}
try {
computePassEncoder16.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer45, 'uint16', 0, 5);
} catch {}
try {
renderBundleEncoder17.setBindGroup(2, bindGroup29);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer36, 'uint32', 4, 5);
} catch {}
document.body.append(canvas0);
let buffer66 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDEX});
let commandEncoder68 = device0.createCommandEncoder({});
let texture81 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 2},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder23.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer60, 'uint32', 0, 12);
} catch {}
try {
renderBundleEncoder0.setBindGroup(1, bindGroup38, new Uint32Array(1474), 141, 0);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(3, buffer6, 12);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 2_596, new Float32Array(21289).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.412)), 9034, 168);
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
diagnostic(info, xyz);

enable f16;

struct VertexInput18 {
  @location(2) @interpolate(linear, either) location_2: f32,
}

@group(0) @binding(153) var<storage, read_write> buffer73: array<vec4u, 52>;

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

struct T0 {
  @size(180) f0: vec2u,
}

@group(0) @binding(524) var tex9: texture_2d<f32>;

var<workgroup> vw21: vec2i;

struct FragmentOutput5 {
  @location(0) location_0: vec4u,
  @builtin(sample_mask) sample_mask: u32,
  @location(7) location_7: vec4u,
  @location(1) location_1: vec2i,
}

struct VertexInput19 {
  @location(4) location_4: vec4i,
}

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

@group(0) @binding(308) var st18: texture_storage_1d<r32sint, read_write>;

@group(0) @binding(61) var st17: texture_storage_2d_array<r32uint, read_write>;

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

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

struct VertexOutput3 {
  @location(5) @interpolate(flat, either) location_5: f32,
  @location(10) @interpolate(flat, first) location_10: vec4u,
  @location(14) location_14: vec2i,
  @location(2) @interpolate(flat, sample) location_2: vec2i,
  @location(7) location_7: u32,
  @location(6) location_6: i32,
  @location(8) location_8: vec2u,
  @location(9) @interpolate(perspective, centroid) location_9: vec4h,
  @location(1) @interpolate(perspective, center) location_1: vec4f,
  @location(12) @interpolate(flat, centroid) location_12: u32,
  @location(0) location_0: i32,
  @location(3) location_3: vec2f,
  @location(11) location_11: vec4i,
  @builtin(position) position: vec4f,
}

alias vec3b = vec3<bool>;

var<workgroup> vw20: vec2u;

struct VertexInput16 {
  @location(15) @interpolate(flat, first) location_15: vec4i,
  @location(1) @interpolate(perspective) location_1: f16,
  @location(6) @interpolate(flat) location_6: vec2i,
  @builtin(vertex_index) vertex_index: u32,
  @location(13) location_13: vec2u,
  @location(8) @interpolate(flat) location_8: vec4u,
  @location(5) @interpolate(perspective) location_5: vec4h,
  @location(11) location_11: vec4u,
  @location(3) @interpolate(flat) location_3: vec2i,
  @location(12) location_12: u32,
}

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

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

@group(0) @binding(10) var<storage, read_write> buffer70: array<array<array<ComputeInput5, 64>, 3>>;

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

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

@group(0) @binding(49) var<storage, read_write> buffer71: array<i32, 4>;

struct VertexInput17 {
  @location(7) @interpolate(linear, either) location_7: vec2f,
  @location(0) @interpolate(flat, first) location_0: vec2i,
  @builtin(instance_index) instance_index: u32,
  @location(9) @interpolate(perspective) location_9: vec4h,
}

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

/* used global variables: buffer67 */
@vertex
fn vertex4(a0: VertexInput16, a1: VertexInput17, @location(10) @interpolate(flat) location_10: i32, a3: VertexInput18, a4: VertexInput19) -> VertexOutput3 {
  var out: VertexOutput3;
  out.location_0 = i32(buffer67[0][0][unconst_u32(738516004)][unconst_u32(220648969)][0][0][2][unconst_u32(924000259)]);
  return out;
  _ = buffer67;
}

/* used global variables: buffer67, buffer70, st18, tex9 */
@fragment
fn fragment7(@location(8) location_8: vec4f, @location(2) location_2: vec2f) -> FragmentOutput5 {
  var out: FragmentOutput5;
  let ptr41: ptr<uniform, vec4u> = &buffer67[0][0][unconst_u32(2487781333)][0][0][0][2];
  let ptr42: ptr<uniform, array<array<vec4u, 3>, 1>> = &(*&buffer67)[0][0][0][0][0];
  let ptr43: ptr<storage, array<array<ComputeInput5, 64>, 3>, read_write> = &(*&buffer70)[arrayLength(&(*&buffer70))];
  let ptr44: ptr<uniform, vec4u> = &buffer67[0][unconst_u32(1700209304)][unconst_u32(417583541)][unconst_u32(455890372)][unconst_u32(388290386)][0][2];
  let vf33: vec2u = textureDimensions(tex9, unconst_i32(129218515));
  let ptr45: ptr<uniform, array<array<vec4u, 3>, 1>> = &buffer67[unconst_u32(291769389)][0][0][unconst_u32(1543908004)][0];
  textureStore(st18, unconst_i32(-1107954345), vec4i(vec4i(unconst_i32(-121364319), unconst_i32(223672229), unconst_i32(159552115), unconst_i32(36806828))));
  return out;
  _ = st18;
  _ = buffer70;
  _ = tex9;
  _ = buffer67;
}

/* used global variables: buffer67, buffer71, buffer73, st17 */
@compute @workgroup_size(1, 1, 1)
fn compute5(a0: ComputeInput5, a1: ComputeInput6, a2: ComputeInput7) {
  buffer73[unconst_u32(470904277)] &= vec4u((*&buffer67)[unconst_u32(463699463)][unconst_u32(1235520433)][unconst_u32(624851088)][unconst_u32(1241118585)][unconst_u32(125896168)][0][2][unconst_u32(1464469223)]);
  buffer71[3] = bitcast<i32>(pack4xU8Clamp((*&buffer67)[0][unconst_u32(826500177)][0][unconst_u32(207834527)][0][0][2]));
  textureStore(st17, vec2i(unconst_i32(290786300), unconst_i32(-96729857)), unconst_i32(264775090), vec4u(vec4u(unconst_u32(90969319), unconst_u32(60185880), unconst_u32(1452251545), unconst_u32(649811044))));
  let ptr46: ptr<uniform, array<array<vec4u, 3>, 1>> = &(*&buffer67)[0][0][0][0][unconst_u32(30426296)];
  _ = st17;
  _ = buffer67;
  _ = buffer71;
  _ = buffer73;
}`,
});
let texture82 = device0.createTexture({
  size: {width: 828},
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder4.setBindGroup(0, bindGroup48, new Uint32Array(768), 128, 2);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup14);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer38, 'uint16', 14, 3);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
texture49.destroy();
} catch {}
try {
device0.queue.writeBuffer(buffer32, 124, new DataView(new ArrayBuffer(82000)), 1349, 12);
} catch {}
let commandEncoder69 = device0.createCommandEncoder({});
let texture83 = device0.createTexture({
  size: [1380, 1, 14],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler11 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 97.63,
});
let externalTexture11 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroupsIndirect(buffer23, 4); };
} catch {}
try {
computePassEncoder14.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline11);
} catch {}
try {
commandEncoder37.copyBufferToBuffer(buffer33, 36, buffer7, 8, 8);
} catch {}
try {
device0.queue.writeBuffer(buffer23, 16, new DataView(new ArrayBuffer(23052)), 776, 16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture55,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(171).fill(94), /* required buffer size: 171 */
{offset: 171}, {width: 49, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder70 = device0.createCommandEncoder({});
let commandBuffer6 = commandEncoder46.finish();
let renderBundle3 = renderBundleEncoder4.finish({});
try {
renderBundleEncoder0.setBindGroup(3, bindGroup7);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder9.insertDebugMarker('\u3b1c');
} catch {}
try {
device0.queue.writeBuffer(buffer45, 36, new Uint32Array(217).map((_, i) => i * 1), 0, 0);
} catch {}
let pipeline15 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 4, mask: 0x70290bb},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment5',
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 60,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 4, shaderLocation: 10},
          {format: 'float32x2', offset: 0, shaderLocation: 9},
          {format: 'float32', offset: 20, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 28,
        stepMode: 'instance',
        attributes: [{format: 'uint32x3', offset: 0, shaderLocation: 7}],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front'},
});
let recycledExplicitBindGroupLayout9 = pipeline1.getBindGroupLayout(0);
let bindGroup51 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 312, resource: sampler0},
    {binding: 7, resource: {buffer: buffer22, size: 176}},
    {binding: 17, resource: externalTexture1},
    {binding: 3, resource: textureView57},
    {binding: 1, resource: {buffer: buffer58, size: 70}},
    {binding: 524, resource: textureView35},
    {binding: 109, resource: textureView99},
    {binding: 153, resource: {buffer: buffer15, size: 872}},
    {binding: 5, resource: externalTexture11},
    {binding: 308, resource: textureView51},
    {binding: 4, resource: {buffer: buffer15}},
    {binding: 49, resource: {buffer: buffer7}},
    {binding: 59, resource: {buffer: buffer46}},
    {binding: 10, resource: {buffer: buffer46, offset: 512}},
    {binding: 61, resource: textureView8},
    {binding: 116, resource: textureView4},
    {binding: 0, resource: textureView32},
    {binding: 159, resource: sampler10},
    {binding: 2, resource: externalTexture2},
  ],
});
try {
renderPassEncoder10.setVertexBuffer(2, buffer23, 12, 40);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(0, buffer3, 1_220, 382);
} catch {}
let img0 = await imageWithData(38, 23, '#10101010', '#20202020');
let commandEncoder71 = device0.createCommandEncoder({});
let textureView100 = texture69.createView({mipLevelCount: 1});
let textureView101 = texture34.createView({baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder24 = commandEncoder65.beginComputePass();
let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true});
try {
computePassEncoder17.setBindGroup(0, bindGroup48, new Uint32Array(1710), 220, 2);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup40, new Uint32Array(748), 78, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer6, 'uint32', 8, 0);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup36, new Uint32Array(576), 3, 0);
} catch {}
let commandEncoder72 = device0.createCommandEncoder({});
let textureView102 = texture32.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 8});
let renderPassEncoder11 = commandEncoder63.beginRenderPass({
  colorAttachments: [{
  view: textureView77,
  clearValue: { r: -133.8, g: 974.6, b: 167.1, a: -357.1, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder7.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup29, new Uint32Array(2020), 116, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer24, 'uint16', 20, 3);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer1, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let pipeline16 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x12200d03},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment5',
  constants: {},
  targets: [{format: 'rgba16sint', writeMask: 0}],
},
  vertex: {
    module: shaderModule1,
    constants: {},
    buffers: [
      {
        arrayStride: 344,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm16x2', offset: 32, shaderLocation: 5},
          {format: 'unorm16x2', offset: 52, shaderLocation: 14},
          {format: 'snorm8x4', offset: 8, shaderLocation: 15},
          {format: 'sint8x2', offset: 82, shaderLocation: 10},
          {format: 'snorm16x2', offset: 64, shaderLocation: 1},
          {format: 'uint32x3', offset: 88, shaderLocation: 7},
          {format: 'sint16x4', offset: 28, shaderLocation: 8},
          {format: 'sint16x4', offset: 4, shaderLocation: 13},
          {format: 'uint8x4', offset: 4, shaderLocation: 2},
          {format: 'snorm8x2', offset: 40, shaderLocation: 0},
          {format: 'float32x3', offset: 4, shaderLocation: 9},
          {format: 'uint32x3', offset: 56, shaderLocation: 3},
          {format: 'uint32x3', offset: 92, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 76, shaderLocation: 6},
          {format: 'float16x2', offset: 308, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 1324,
        stepMode: 'instance',
        attributes: [{format: 'float32x3', offset: 60, shaderLocation: 12}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'back'},
});
let bindGroup52 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 159, resource: sampler4},
    {binding: 116, resource: textureView2},
    {binding: 59, resource: {buffer: buffer46, offset: 768}},
    {binding: 109, resource: textureView11},
    {binding: 4, resource: {buffer: buffer15}},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 61, resource: textureView90},
    {binding: 153, resource: {buffer: buffer15}},
    {binding: 49, resource: {buffer: buffer25, size: 28}},
    {binding: 0, resource: textureView22},
    {binding: 312, resource: sampler2},
    {binding: 7, resource: {buffer: buffer61}},
    {binding: 308, resource: textureView16},
    {binding: 1, resource: {buffer: buffer42, size: 49}},
    {binding: 17, resource: externalTexture5},
    {binding: 524, resource: textureView80},
    {binding: 5, resource: externalTexture5},
    {binding: 3, resource: textureView42},
    {binding: 2, resource: externalTexture10},
  ],
});
let commandEncoder73 = device0.createCommandEncoder();
let textureView103 = texture7.createView({dimension: '2d'});
let textureView104 = texture22.createView({aspect: 'depth-only'});
let externalTexture12 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder7.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder9.setScissorRect(45, 0, 132, 0);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer4, 'uint16', 0, 2);
} catch {}
let arrayBuffer0 = buffer61.getMappedRange(0, 12);
let buffer74 = device0.createBuffer({
  size: 197,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture84 = device0.createTexture({
  size: {width: 1, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView105 = texture76.createView({dimension: '2d-array'});
try {
renderPassEncoder6.setVertexBuffer(4, buffer36, 0, 7);
} catch {}
try {
renderBundleEncoder0.draw(47, 0, 429_190_440);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let bindGroup53 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout2,
  entries: [
    {binding: 153, resource: {buffer: buffer15}},
    {binding: 61, resource: textureView8},
    {binding: 7, resource: {buffer: buffer15}},
    {binding: 1, resource: {buffer: buffer28, size: 74}},
  ],
});
let buffer75 = device0.createBuffer({size: 244, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let texture85 = device0.createTexture({
  size: [1380, 1, 3],
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderBundleEncoder0.draw(346, 0, 90_086_416);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline16);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 690, height: 1, depthOrArrayLayers: 7}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture83,
  mipLevel: 1,
  origin: {x: 80, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let commandEncoder74 = device0.createCommandEncoder({});
try {
computePassEncoder5.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer65);
} catch {}
try {
renderBundleEncoder0.drawIndexed(1, 0, 0, 12_184_451);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer23, 12);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture57,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(38).fill(150), /* required buffer size: 38 */
{offset: 38}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 3}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 114, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder75 = device0.createCommandEncoder({});
let texture86 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder19.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup22, new Uint32Array(806), 63, 0);
} catch {}
try {
renderBundleEncoder0.drawIndexed(1, 0, 0, 6_199_949);
} catch {}
let bindGroup54 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]});
let texture87 = device0.createTexture({size: {width: 4}, dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.COPY_SRC});
try {
renderPassEncoder0.setIndexBuffer(buffer60, 'uint32', 0, 10);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer0, 108);
} catch {}
try {
renderBundleEncoder15.setIndexBuffer(buffer62, 'uint16', 30, 42);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(6, buffer61);
} catch {}
try {
  await buffer64.mapAsync(GPUMapMode.WRITE);
} catch {}
try {
commandEncoder32.copyTextureToTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 43},
  aspect: 'all',
},
{
  texture: texture43,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData7 = new ImageData(80, 4);
try {
computePassEncoder2.end();
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer35, 'uint16', 0, 15);
} catch {}
try {
renderBundleEncoder2.setBindGroup(1, bindGroup38, new Uint32Array(1038), 102, 0);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer1, 0);
} catch {}
try {
commandEncoder52.clearBuffer(buffer36);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.submit([commandBuffer6]);
} catch {}
let imageBitmap3 = await createImageBitmap(videoFrame5);
try {
computePassEncoder14.setBindGroup(0, bindGroup48, new Uint32Array(61), 3, 2);
} catch {}
try {
renderBundleEncoder0.drawIndexed(1, 0, 0, 654_820_979);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(4, buffer38);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 0, new DataView(new Uint8Array(39475).map((_, i) => i).buffer), 4316, 0);
} catch {}
let texture88 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler12 = device0.createSampler({addressModeV: 'mirror-repeat'});
try {
{ clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroupsIndirect(buffer19, 12); };
} catch {}
try {
computePassEncoder17.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup20, new Uint32Array(224), 39, 0);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer1, 0);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer4, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(0, buffer45, 16, 23);
} catch {}
let arrayBuffer1 = buffer31.getMappedRange(0, 0);
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(94).fill(107), /* required buffer size: 94 */
{offset: 94}, {width: 47, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
veryExplicitBindGroupLayout6.label = '\u{1f725}\u{1fb78}\ue64b\u0612\u{1fdda}\u0923\ube87';
} catch {}
let textureView106 = texture54.createView({});
try {
renderBundleEncoder0.draw(201, 0, 1_002_871_390);
} catch {}
try {
commandEncoder48.copyTextureToTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture62,
  mipLevel: 0,
  origin: {x: 37, y: 27, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 8});
} catch {}
try {
offscreenCanvas0.getContext('webgl2');
} catch {}
let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 14,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 21,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 242,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let bindGroup55 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
let buffer76 = device0.createBuffer({size: 120, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
try {
computePassEncoder9.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup50, new Uint32Array(61), 1, 0);
} catch {}
try {
computePassEncoder19.insertDebugMarker('\u{1f7e2}');
} catch {}
let buffer77 = device0.createBuffer({size: 472, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let commandBuffer7 = commandEncoder2.finish({});
let textureView107 = texture13.createView({});
let computePassEncoder25 = commandEncoder32.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer0, 20); };
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer35, 'uint32', 88, 3);
} catch {}
try {
renderBundleEncoder0.drawIndexedIndirect(buffer23, 28);
} catch {}
let videoFrame12 = new VideoFrame(videoFrame9, {timestamp: 0});
let bindGroup56 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 4, resource: textureView100},
    {binding: 0, resource: {buffer: buffer7}},
    {binding: 73, resource: {buffer: buffer46, offset: 256, size: 4204}},
    {binding: 154, resource: textureView86},
  ],
});
let renderBundle4 = renderBundleEncoder13.finish({});
try {
computePassEncoder25.setBindGroup(1, bindGroup20);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer32, 32); };
} catch {}
try {
computePassEncoder25.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup14);
} catch {}
try {
  await buffer37.mapAsync(GPUMapMode.READ, 0, 0);
} catch {}
await gc();
let videoFrame13 = videoFrame5.clone();
let bindGroup57 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 154, resource: textureView86},
    {binding: 73, resource: {buffer: buffer46}},
    {binding: 4, resource: textureView100},
    {binding: 0, resource: {buffer: buffer55}},
  ],
});
let buffer78 = device0.createBuffer({size: 320, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture89 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 232},
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder2.setVertexBuffer(7, buffer62, 12, 1);
} catch {}
let arrayBuffer2 = buffer61.getMappedRange(16, 20);
try {
commandEncoder73.copyTextureToTexture({
  texture: texture18,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 828, height: 0, depthOrArrayLayers: 0});
} catch {}
let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {binding: 12, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }},
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer79 = device0.createBuffer({size: 328, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder76 = device0.createCommandEncoder({});
try {
renderBundleEncoder20.setIndexBuffer(buffer35, 'uint32', 64, 10);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'iec61966-2-1'} });
let commandEncoder77 = device0.createCommandEncoder({});
let texture90 = device0.createTexture({
  size: {width: 1380, height: 1, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder21.setBindGroup(1, bindGroup50, new Uint32Array(3150), 388, 0);
} catch {}
try {
renderBundleEncoder0.drawIndexedIndirect(buffer32, 28);
} catch {}
let texture91 = device0.createTexture({
  size: {width: 828, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder23.end();
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer36, 'uint32', 0, 3);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer36, 0, 0);
} catch {}
try {
renderBundleEncoder0.drawIndexed(1, 0, 0, 642_996_347);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer38, 'uint32', 4, 3);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(1, buffer26, 8, 18);
} catch {}
try {
commandEncoder31.copyBufferToBuffer(buffer43, 20, buffer32, 16, 12);
} catch {}
let buffer80 = device0.createBuffer({size: 98, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let texture92 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture93 = device0.createTexture({
  size: {width: 345},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture13 = device0.importExternalTexture({source: videoFrame13});
try {
computePassEncoder22.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer26, 0, 5);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup44);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline8);
} catch {}
let autogeneratedBindGroupLayout4 = pipeline8.getBindGroupLayout(1);
let commandBuffer8 = commandEncoder41.finish();
let textureView108 = texture90.createView({});
try {
computePassEncoder17.setBindGroup(1, bindGroup33, new Uint32Array(3423), 496, 0);
} catch {}
try {
renderBundleEncoder0.drawIndexedIndirect(buffer80, 0);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer36, 0);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline14);
} catch {}
let imageData8 = new ImageData(12, 108);
let buffer81 = device0.createBuffer({
  size: 632,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder78 = device0.createCommandEncoder({});
let texture94 = device0.createTexture({
  size: [345],
  dimension: '1d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder4.end();
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer55, 'uint16', 22, 2);
} catch {}
try {
renderBundleEncoder0.setBindGroup(1, bindGroup38);
} catch {}
let commandEncoder79 = device0.createCommandEncoder({});
let textureView109 = texture94.createView({});
let computePassEncoder26 = commandEncoder37.beginComputePass();
try {
computePassEncoder19.setBindGroup(1, bindGroup32);
} catch {}
try {
computePassEncoder26.setBindGroup(1, bindGroup29, new Uint32Array(1034), 47, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1, 3, 1); };
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup16, new Uint32Array(1803), 147, 0);
} catch {}
try {
commandEncoder75.copyTextureToTexture({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 84, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture70,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer82 = device0.createBuffer({size: 312, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let texture95 = device0.createTexture({
  size: [1656, 1, 21],
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder26.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup25);
} catch {}
try {
renderBundleEncoder0.drawIndexedIndirect(buffer32, 48);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer26, 0);
} catch {}
let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 93,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let commandEncoder80 = device0.createCommandEncoder();
let texture96 = device0.createTexture({
  size: [8, 8, 1],
  sampleCount: 1,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture97 = device0.createTexture({
  size: [414, 1, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder0.setBindGroup(0, bindGroup36);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer22, 36);
} catch {}
try {
commandEncoder64.insertDebugMarker('\ufc0f');
} catch {}
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'unspecified', transfer: 'smpte240m'} });
let bindGroup58 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 4, resource: textureView17},
    {binding: 16, resource: {buffer: buffer22, size: 20}},
    {binding: 65, resource: externalTexture7},
  ],
});
let commandBuffer9 = commandEncoder7.finish();
let textureView110 = texture91.createView({dimension: '2d-array'});
try {
computePassEncoder19.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup14, new Uint32Array(221), 3, 0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(3, bindGroup30);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer1, 4);
} catch {}
try {
device0.queue.submit([commandBuffer7]);
} catch {}
try {
device0.queue.writeBuffer(buffer79, 44, new Float32Array(6634).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.766)), 927, 4);
} catch {}
let buffer83 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
computePassEncoder15.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup50);
} catch {}
try {
renderBundleEncoder0.drawIndirect(buffer19, 0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer66, 'uint16', 4, 0);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(6, buffer45, 0, 15);
} catch {}
let bindGroup59 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let commandEncoder81 = device0.createCommandEncoder({});
let texture98 = device0.createTexture({
  size: {width: 1380, height: 1, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder27 = commandEncoder61.beginComputePass();
let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb']});
let renderBundle5 = renderBundleEncoder0.finish({});
try {
renderPassEncoder8.setIndexBuffer(buffer80, 'uint32', 28, 24);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer66, 'uint16', 0, 2);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(4, buffer82, 0);
} catch {}
try {
  await buffer83.mapAsync(GPUMapMode.WRITE, 8);
} catch {}
let recycledExplicitBindGroupLayout10 = pipeline1.getBindGroupLayout(0);
let buffer84 = device0.createBuffer({size: 192, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder82 = device0.createCommandEncoder({});
let texture99 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba16float'],
});
try {
renderBundleEncoder20.setVertexBuffer(2, buffer23);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
document.body.prepend(img0);
let buffer85 = device0.createBuffer({
  size: 36748,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let commandEncoder83 = device0.createCommandEncoder({});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 2435});
let textureView111 = texture20.createView({baseMipLevel: 0, baseArrayLayer: 8, arrayLayerCount: 9});
try {
computePassEncoder25.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer36, 0); };
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer35, 'uint16', 114, 20);
} catch {}
try {
renderBundleEncoder21.setVertexBuffer(3, buffer76, 12, 45);
} catch {}
let pipeline17 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 4},
  fragment: {
  module: shaderModule3,
  constants: {},
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 128,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 8, shaderLocation: 10},
          {format: 'unorm8x4', offset: 68, shaderLocation: 0},
          {format: 'float16x4', offset: 60, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 12, shaderLocation: 7},
          {format: 'sint16x4', offset: 12, shaderLocation: 4},
          {format: 'uint32x2', offset: 0, shaderLocation: 9},
          {format: 'unorm8x4', offset: 0, shaderLocation: 5},
          {format: 'float32x4', offset: 0, shaderLocation: 8},
          {format: 'uint32x4', offset: 32, shaderLocation: 11},
          {format: 'uint32x4', offset: 56, shaderLocation: 1},
          {format: 'uint32x2', offset: 44, shaderLocation: 2},
          {format: 'uint16x2', offset: 28, shaderLocation: 13},
          {format: 'sint32x3', offset: 20, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 6},
          {format: 'uint16x4', offset: 12, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 152,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x2', offset: 56, shaderLocation: 14}],
      },
    ],
  },
  primitive: {frontFace: 'cw'},
});
try {
globalThis.someLabel = veryExplicitBindGroupLayout10.label;
} catch {}
let buffer86 = device0.createBuffer({size: 312, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 989});
try {
renderPassEncoder0.setIndexBuffer(buffer57, 'uint16', 6, 61);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup31);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
device0.queue.submit([commandBuffer8]);
} catch {}
try {
  await promise10;
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(20, 189);
let img1 = await imageWithData(49, 20, '#10101010', '#20202020');
let buffer87 = device0.createBuffer({
  size: 136,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture100 = device0.createTexture({
  size: {width: 1},
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView112 = texture70.createView({aspect: 'all'});
try {
renderPassEncoder8.setBindGroup(3, bindGroup39, new Uint32Array(1492), 63, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer80, 'uint16', 28, 8);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer65, 20);
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u2a3c');
} catch {}
let commandEncoder84 = device0.createCommandEncoder({});
try {
computePassEncoder22.setBindGroup(0, bindGroup48, new Uint32Array(212), 15, 2);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer55, 'uint16', 8, 2);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, buffer25, 0, 14);
} catch {}
document.body.prepend(canvas1);
let renderPassEncoder12 = commandEncoder30.beginRenderPass({
  colorAttachments: [{
  view: textureView77,
  clearValue: { r: 768.4, g: 245.9, b: -820.7, a: -616.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
});
try {
computePassEncoder25.setBindGroup(2, bindGroup14);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer6, 'uint32', 8, 20);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer57, 'uint32', 12, 10);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
  toneMapping: {mode: 'extended'},
});
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470m', transfer: 'pq'} });
let texture101 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture102 = gpuCanvasContext1.getCurrentTexture();
try {
computePassEncoder16.setBindGroup(2, bindGroup38);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1, 3, 1); };
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer24, 'uint32', 4, 23);
} catch {}
try {
commandEncoder70.resolveQuerySet(querySet0, 269, 2, buffer33, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 43, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(2).fill(190), /* required buffer size: 2 */
{offset: 2}, {width: 50, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas1);
let bindGroup60 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout10,
  entries: [
    {binding: 16, resource: {buffer: buffer22, size: 132}},
    {binding: 65, resource: externalTexture11},
    {binding: 4, resource: textureView17},
  ],
});
let commandEncoder85 = device0.createCommandEncoder({});
try {
renderPassEncoder7.setIndexBuffer(buffer24, 'uint16', 12, 3);
} catch {}
try {
buffer55.unmap();
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture65,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture83,
  mipLevel: 0,
  origin: {x: 262, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer9]);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(3); };
} catch {}
let img2 = await imageWithData(129, 23, '#10101010', '#20202020');
let texture103 = device0.createTexture({
  size: [414, 1, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView113 = texture74.createView({});
try {
computePassEncoder17.end();
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup13);
} catch {}
try {
commandEncoder34.copyBufferToBuffer(buffer74, 28, buffer47, 0, 0);
} catch {}
document.body.prepend(canvas1);
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'gamma22curve'} });
let videoFrame18 = new VideoFrame(videoFrame7, {timestamp: 0});
let texture104 = device0.createTexture({
  size: {width: 207, height: 1, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder27.setBindGroup(1, bindGroup2);
} catch {}
try {
computePassEncoder21.setBindGroup(0, bindGroup18, new Uint32Array(2198), 84, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer60, 'uint16', 8, 53);
} catch {}
try {
renderBundleEncoder14.setBindGroup(3, bindGroup18, new Uint32Array(2407), 563, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let texture105 = device0.createTexture({
  size: {width: 1656, height: 1, depthOrArrayLayers: 29},
  mipLevelCount: 3,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder13 = commandEncoder49.beginRenderPass({
  colorAttachments: [{
  view: textureView77,
  clearValue: { r: 161.5, g: -491.3, b: 363.3, a: -413.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder18.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
computePassEncoder15.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer84, 'uint32', 0, 19);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 2, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 311,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let sampler13 = device0.createSampler({addressModeU: 'clamp-to-edge', lodMaxClamp: 78.87});
try {
computePassEncoder12.setBindGroup(0, bindGroup48, new Uint32Array(415), 8, 2);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder83.copyTextureToTexture({
  texture: texture44,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture61,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer77, 80, new DataView(new Uint8Array(2105).map((_, i) => i).buffer), 318, 128);
} catch {}
let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu');
try {
computePassEncoder18.setBindGroup(3, bindGroup6, new Uint32Array(868), 7, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer0, 4); };
} catch {}
try {
computePassEncoder9.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup57, new Uint32Array(1063), 10, 0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, buffer36, 0, 1);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture76,
  mipLevel: 0,
  origin: {x: 432, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(68).fill(67), /* required buffer size: 68 */
{offset: 68, bytesPerRow: 170, rowsPerImage: 57}, {width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup0, new Uint32Array(622), 57, 0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer6, 'uint16', 32, 6);
} catch {}
document.body.append(canvas0);
let commandEncoder86 = device0.createCommandEncoder({});
let shaderModule7 = device0.createShaderModule({
  code: `
enable f16;

@group(0) @binding(7) var<storage, read_write> buffer90: array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 1>, 1>, 28>;

struct FragmentInput14 {
  @location(2) location_2: vec2u,
  @location(4) location_4: vec4i,
  @location(14) @interpolate(flat, centroid) location_14: vec2i,
  @location(8) location_8: f32,
  @builtin(position) position: vec4f,
}

struct VertexOutput4 {
  @location(4) @interpolate(perspective, either) location_4: vec4h,
  @location(0) location_0: i32,
  @location(11) @interpolate(flat, first) location_11: u32,
  @location(3) @interpolate(flat, center) location_3: vec2i,
  @location(13) @interpolate(perspective, first) location_13: vec2h,
  @location(2) location_2: u32,
  @location(7) @interpolate(perspective, either) location_7: f16,
  @location(15) @interpolate(perspective) location_15: vec4f,
  @builtin(position) position: vec4f,
  @location(1) @interpolate(flat, either) location_1: vec4f,
  @location(9) location_9: vec2u,
}

@id(47734) override override12: u32;

@id(29694) override override7 = 0.1209e10;

@id(15691) override override21: u32 = (942008513 % 103) + 1;

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

override override18: u32;

var<private> vp6 = frexp(vec3h(199.9, 741.0, 6960.6));

/* used global variables: buffer90, buffer92, buffer94, st22 */
fn fn0() -> array<f32, 1> {
  var out: array<f32, 1>;
  let ptr47: ptr<storage, array<f16, 1>, read_write> = &(*&buffer90)[unconst_u32(3742561329)][0][unconst_u32(911882079)][unconst_u32(480724591)][0][unconst_u32(1068495123)];
  buffer92 -= vec4i(i32(override18));
  let ptr48: ptr<storage, vec2i, read_write> = &buffer94[unconst_u32(710825750)][unconst_u32(1273347213)].location_14;
  let ptr49: ptr<storage, array<f16, 1>, read_write> = &buffer90[27][unconst_u32(372331493)][0][2][0][u32(buffer90[27][0][0][2][0][0][0])];
  buffer94[unconst_u32(2899639157)][unconst_u32(320982413)] = FragmentInput14(vec2u(u32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0])), vec4i(i32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0])), vec2i(i32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0])), f32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0]), vec4f(f32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0])));
  let ptr50: ptr<storage, array<f16, 1>, read_write> = &(*&buffer90)[u32((*&buffer90)[unconst_u32(208790966)][0][unconst_u32(699546556)][2][unconst_u32(144018230)][unconst_u32(498294928)][unconst_u32(38511700)])][0][unconst_u32(529685497)][unconst_u32(629088562)][0][0];
  out[0] = f32((*&buffer90)[unconst_u32(745166380)][0][unconst_u32(453314143)][unconst_u32(573076871)][u32(buffer90[unconst_u32(475505380)][unconst_u32(313919393)][0][2][0][0][0])][0][unconst_u32(260320816)]);
  textureStore(st22, unconst_i32(-473193107), vec4i(vec4i(unconst_i32(1064722282), unconst_i32(195439993), unconst_i32(169503257), unconst_i32(485943439))));
  let ptr51: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 3>, read_write> = &buffer90[unconst_u32(1179105005)][u32(buffer90[unconst_u32(492887668)][0][u32(buffer90[27][0][u32(buffer90[unconst_u32(708566509)][unconst_u32(2113386480)][0][2][0][0][0])][unconst_u32(1672061488)][0][unconst_u32(12274497)][unconst_u32(285903621)])][2][0][unconst_u32(313996960)][unconst_u32(788755813)])][0];
  return out;
  _ = override18;
  _ = buffer92;
  _ = st22;
  _ = buffer94;
  _ = buffer90;
}

struct FragmentOutput6 {
  @location(0) @interpolate(perspective) location_0: vec4f,
}

@group(0) @binding(4) var<storage, read> buffer89: array<array<f16, 107>>;

override override22: bool;

override override20: bool;

@id(13798) override override13: u32;

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

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

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

@id(38197) override override11: u32 = (919790132 % 103) + 1;

@group(0) @binding(153) var<storage, read_write> buffer94: array<array<FragmentInput14, 13>>;

@group(0) @binding(1) var<uniform> buffer88: array<array<FragmentOutput6, 3>, 1>;

@id(18962) override override8: f16 = 4044.5;

override override16 = true;

@id(52306) override override9: f32;

@group(0) @binding(49) var<storage, read_write> buffer92: vec4i;

@id(35769) override override17: bool;

@group(0) @binding(308) var st22: texture_storage_1d<r32sint, read_write>;

@group(0) @binding(59) var<storage, read_write> buffer93: array<FragmentOutput6, 22>;

var<private> vp8: array<vec2u, 24> = array(vec2u(775132986, 1050140349), vec2u(899207308, 1470137705), vec2u(450205710, 814223425), vec2u(158206980, 999358468), vec2u(30929791, 528693183), vec2u(1006499267, 1807149715), vec2u(553905187, 46103328), vec2u(691141676, 61766259), vec2u(1296480673, 1355766067), vec2u(344049842, 4294967295), vec2u(515538846, 754572819), vec2u(116311861, 102080851), vec2u(142414183, 2362300655), vec2u(634339918, 222291542), vec2u(355458764, 263764587), vec2u(136966529, 142131010), vec2u(869497747, 141575210), vec2u(21966086, 1358432344), vec2u(1907302602, 258583563), vec2u(58961460, 501596187), vec2u(766609360, 1748218547), vec2u(326801547, 307820495), vec2u(1749426723, 16511329), vec2u(508012755, 176146719));

struct T0 {
  @size(448) f0: vec4<bool>,
  f1: array<atomic<i32>>,
}

override override15: f16 = 6251.1;

override override10: u32;

@id(44718) override override19 = true;

/* used global variables: buffer90 */
fn fn1() -> bool {
  var out: bool;
  let ptr52: ptr<storage, array<f16, 1>, read_write> = &buffer90[27][0][unconst_u32(636759984)][unconst_u32(235258910)][0][unconst_u32(310557151)];
  vp8[23] >>= vec2u(u32(buffer90[unconst_u32(2285315808)][unconst_u32(1139893326)][unconst_u32(470298479)][unconst_u32(478251030)][unconst_u32(176318784)][unconst_u32(273487194)][unconst_u32(489973403)]));
  return out;
  _ = buffer90;
}

var<private> vp7: vec4i = vec4i(74567743, 319919167, 364797100, 4121778);

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

@group(0) @binding(10) var<storage, read_write> buffer91: array<array<array<f16, 24>, 64>>;

override override14: u32 = (976871902 % 103) + 1;

/* used global variables: buffer88, buffer89 */
@vertex
fn vertex5(@location(2) location_2: vec2u, @builtin(vertex_index) vertex_index: u32, @location(13) @interpolate(flat, sample) location_13: vec2u, @location(10) location_10: vec4u) -> VertexOutput4 {
  var out: VertexOutput4;
  loop {
  out.location_15 -= bitcast<vec4f>(out.location_3.xxyx.aggg.zwyx);
  let ptr53: ptr<uniform, FragmentOutput6> = &buffer88[0][unconst_u32(232669079)];
  break;
  _ = buffer88;
}
  out.location_13 = bitcast<vec2h>(arrayLength(&buffer89));
  vp7 ^= vec4i(i32(out.location_11));
  return out;
  _ = buffer89;
  _ = buffer88;
}

/* used global variables: buffer90, buffer91 */
@fragment
fn fragment8(a0: FragmentInput14) -> FragmentOutput6 {
  var out: FragmentOutput6;
  {
  vp8[unconst_u32(108955905)] *= vec2u(u32(buffer91[arrayLength(&buffer91)][63][23]));
  while bool((*&buffer90)[unconst_u32(68627032)][0][unconst_u32(1678480319)][2][unconst_u32(129641129)][unconst_u32(335475663)][0]) {
  let ptr54: ptr<storage, f16, read_write> = &(*&buffer90)[unconst_u32(681667515)][0][unconst_u32(716807804)][2][0][unconst_u32(1886146315)][unconst_u32(594268000)];
  discard;
  _ = buffer90;
}
  var vf34 = fn1();
  let ptr55: ptr<storage, array<f16, 1>, read_write> = &buffer90[unconst_u32(595450974)][0][0][override12][unconst_u32(1021825786)][0];
  loop {
  fn1();
  let ptr56: ptr<private, vec3i> = &vp6.exp;
  var vf35 = fn1();
  vf35 = bool(buffer90[unconst_u32(468404472)][0][u32((*&buffer90)[27][0][0][unconst_u32(373280696)][unconst_u32(279655394)][0][unconst_u32(62162733)])][unconst_u32(828484021)][0][0][0]);
  break;
  _ = buffer90;
}
  var vf36 = fn1();
  _ = override12;
  _ = buffer91;
  _ = buffer90;
}
  out.location_0 -= vec4f(f32((*&buffer90)[unconst_u32(94279634)][unconst_u32(1088072114)][0][unconst_u32(1026081566)][unconst_u32(187567517)][unconst_u32(359931366)][unconst_u32(311858188)]));
  var vf37 = fn1();
  fn1();
  vp8[23] |= vec2u(fma(vec3h(unconst_f16(-25741.3), unconst_f16(1597.5), unconst_f16(10052.9)), vec3h(unconst_f16(1174.3), unconst_f16(13083.3), unconst_f16(-2735.5)), vec3h(unconst_f16(8148.9), unconst_f16(5261.1), unconst_f16(10969.4))).yx.yx);
  fn1();
  let ptr57: ptr<storage, f16, read_write> = &(*&buffer90)[unconst_u32(874069850)][unconst_u32(64040582)][unconst_u32(534572942)][unconst_u32(114436647)][unconst_u32(3279143683)][0][0];
  return out;
  _ = override12;
  _ = buffer90;
  _ = buffer91;
}

/* used global variables: buffer90, buffer92, buffer93 */
@compute @workgroup_size(4, 1, 1)
fn compute6(@builtin(global_invocation_id) global_invocation_id: vec3u) {
  let ptr58: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 3>, read_write> = &buffer90[27][unconst_u32(1218020453)][0];
  let ptr59: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer90[27][0][unconst_u32(768283106)][2][0];
  vp6 = frexp(vec3h((*&buffer93)[21].location_0.brr.yzy.yzx.rgg));
  buffer92 ^= vec4i(i32((*&buffer90)[27][unconst_u32(118798853)][0][unconst_u32(335914999)][0][u32(buffer90[unconst_u32(111441394)][unconst_u32(716008635)][0][2][unconst_u32(1220734868)][unconst_u32(784130653)][0])][unconst_u32(675371861)]));
  _ = buffer93;
  _ = buffer92;
  _ = buffer90;
}`,
});
let buffer95 = device0.createBuffer({size: 181, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let externalTexture14 = device0.importExternalTexture({source: videoFrame11, colorSpace: 'display-p3'});
try {
renderPassEncoder13.setVertexBuffer(7, buffer25);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 1704 widthInBlocks: 213 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 6616 */
  offset: 6616,
  bytesPerRow: 23808,
  buffer: buffer85,
}, {
  texture: texture66,
  mipLevel: 0,
  origin: {x: 54, y: 0, z: 3},
  aspect: 'all',
}, {width: 213, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder17.resolveQuerySet(querySet0, 335, 5, buffer25, 0);
} catch {}
let buffer96 = device0.createBuffer({size: 128, usage: GPUBufferUsage.INDEX});
let commandEncoder87 = device0.createCommandEncoder({});
let renderPassEncoder14 = commandEncoder81.beginRenderPass({
  colorAttachments: [{
  view: textureView21,
  clearValue: { r: -824.2, g: 366.7, b: -889.7, a: -434.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder12.setBindGroup(2, bindGroup57, new Uint32Array(2700), 228, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer36, 'uint32', 4, 2);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(2, buffer58);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline16);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder86.copyBufferToTexture({
  /* bytesInLastRow: 256 widthInBlocks: 64 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 360 */
  offset: 360,
  bytesPerRow: 14336,
  buffer: buffer85,
}, {
  texture: texture4,
  mipLevel: 0,
  origin: {x: 137, y: 0, z: 0},
  aspect: 'all',
}, {width: 64, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture58,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(2_133).fill(197), /* required buffer size: 2_133 */
{offset: 316, bytesPerRow: 79, rowsPerImage: 23}, {width: 0, height: 1, depthOrArrayLayers: 2});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 3}
*/
{
  source: canvas1,
  origin: { x: 82, y: 35 },
  flipY: true,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 48, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await shaderModule5.getCompilationInfo();
} catch {}
let offscreenCanvas2 = new OffscreenCanvas(34, 492);
let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', minBindingSize: 10, hasDynamicOffset: false },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 154,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let bindGroup61 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 93, resource: textureView5}]});
let commandEncoder88 = device0.createCommandEncoder({});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: false});
try {
device0.queue.writeBuffer(buffer45, 8, new Float64Array(49430).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/49429)), 7598, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder89 = device0.createCommandEncoder({});
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder85.copyTextureToTexture({
  texture: texture61,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture52,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer79, 40, new Uint32Array(856).map((_, i) => i * 3), 56, 0);
} catch {}
let buffer97 = device0.createBuffer({size: 24315, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false});
let textureView114 = texture30.createView({mipLevelCount: 1});
try {
computePassEncoder26.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer6, 8, 11);
} catch {}
let textureView115 = texture96.createView({dimension: '2d-array'});
let texture106 = device0.createTexture({
  size: [207, 1, 1],
  mipLevelCount: 3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer85, 7_744); };
} catch {}
try {
computePassEncoder26.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(554);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer80, 'uint32', 12, 44);
} catch {}
try {
buffer56.unmap();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData9 = new ImageData(72, 4);
let commandEncoder90 = device0.createCommandEncoder();
try {
computePassEncoder11.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup59);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer98 = device0.createBuffer({size: 292, usage: GPUBufferUsage.INDEX});
try {
{ clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroupsIndirect(buffer60, 0); };
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(3, buffer76, 0, 6);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup32);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer66.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer74, 28, new Float32Array(10908).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.877)), 70, 20);
} catch {}
document.body.append(img2);
let img3 = await imageWithData(5, 60, '#10101010', '#20202020');
let texture107 = device0.createTexture({
  size: [690, 1, 1],
  mipLevelCount: 1,
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let textureView116 = texture52.createView({dimension: '1d', baseMipLevel: 0});
try {
computePassEncoder19.end();
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer24, 'uint32', 16, 4);
} catch {}
try {
renderBundleEncoder18.setBindGroup(2, bindGroup35, new Uint32Array(2557), 1_030, 0);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(0, buffer58, 0, 15);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(146); };
} catch {}
let externalTexture15 = device0.importExternalTexture({source: videoFrame17});
let imageData10 = new ImageData(88, 36);
let commandEncoder91 = device0.createCommandEncoder({});
let textureView117 = texture21.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(607);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
  await shaderModule7.getCompilationInfo();
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder75.copyBufferToTexture({
  /* bytesInLastRow: 616 widthInBlocks: 154 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 184 */
  offset: 184,
  bytesPerRow: 16640,
  buffer: buffer56,
}, {
  texture: texture52,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
}, {width: 154, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer80, 0, new DataView(new ArrayBuffer(82052)), 1282, 12);
} catch {}
let texture108 = device0.createTexture({
  size: {width: 1},
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba16sint'],
});
try {
renderPassEncoder13.setVertexBuffer(3, buffer84);
} catch {}
try {
buffer55.unmap();
} catch {}
document.body.append(img3);
let commandEncoder92 = device0.createCommandEncoder({});
try {
computePassEncoder13.setBindGroup(3, bindGroup54, new Uint32Array(1215), 599, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup54);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer87, 0, 3);
} catch {}
try {
renderBundleEncoder1.setPipeline(pipeline11);
} catch {}
let bindGroup62 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 116, resource: textureView4},
    {binding: 17, resource: externalTexture9},
    {binding: 109, resource: textureView33},
    {binding: 308, resource: textureView50},
    {binding: 524, resource: textureView85},
    {binding: 3, resource: textureView41},
    {binding: 1, resource: {buffer: buffer87, offset: 0}},
    {binding: 153, resource: {buffer: buffer15, offset: 0}},
    {binding: 5, resource: externalTexture9},
    {binding: 159, resource: sampler6},
    {binding: 59, resource: {buffer: buffer46}},
    {binding: 0, resource: textureView32},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 2, resource: externalTexture15},
    {binding: 49, resource: {buffer: buffer15}},
    {binding: 4, resource: {buffer: buffer46}},
    {binding: 312, resource: sampler0},
    {binding: 61, resource: textureView30},
    {binding: 7, resource: {buffer: buffer81}},
  ],
});
let buffer99 = device0.createBuffer({size: 276, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder93 = device0.createCommandEncoder({});
let textureView118 = texture11.createView({aspect: 'all', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer26, 8); };
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup14);
} catch {}
try {
renderBundleEncoder2.insertDebugMarker('\u05fd');
} catch {}
let buffer100 = device0.createBuffer({size: 48, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let texture109 = device0.createTexture({
  size: [690, 1, 24],
  mipLevelCount: 3,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderPassEncoder7.setBindGroup(3, bindGroup46);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(1368), 908, 0);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer66, 'uint16', 4, 0);
} catch {}
try {
buffer22.unmap();
} catch {}
let pipeline18 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
let commandEncoder94 = device0.createCommandEncoder();
let texture110 = device0.createTexture({
  size: [4, 4, 34],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer85, 14_244); };
} catch {}
try {
renderBundleEncoder21.setBindGroup(0, bindGroup47, new Uint32Array(2487), 117, 0);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer6, 'uint32', 36, 6);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline16);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let textureView119 = texture86.createView({dimension: '2d-array'});
let texture111 = device0.createTexture({
  size: [1380, 1, 1],
  mipLevelCount: 4,
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
try {
computePassEncoder26.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup38);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer98, 'uint16', 38, 9);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(6, buffer97, 2_536, 5_979);
} catch {}
try {
commandEncoder75.resolveQuerySet(querySet0, 439, 2, buffer26, 0);
} catch {}
let texture112 = device0.createTexture({
  size: [207, 1, 1],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder26.setBindGroup(0, bindGroup12, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer82, 8); };
} catch {}
let arrayBuffer3 = buffer61.getMappedRange(40, 24);
try {
commandEncoder31.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 184 */
  offset: 184,
  buffer: buffer79,
}, {
  texture: texture46,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData11 = new ImageData(16, 12);
let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
try {
computePassEncoder26.setBindGroup(2, bindGroup39);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup60, new Uint32Array(290), 18, 0);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(96);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer57, 'uint32', 28, 8);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer45, 44, 15);
} catch {}
try {
renderBundleEncoder8.setBindGroup(1, bindGroup24);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer38, 'uint16', 6, 1);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer97, 0, 6_048);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
commandEncoder38.resolveQuerySet(querySet1, 35, 2, buffer99, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'extended'},
});
} catch {}
let gpuCanvasContext3 = offscreenCanvas2.getContext('webgpu');
let recycledExplicitBindGroupLayout11 = pipeline0.getBindGroupLayout(1);
let bindGroup63 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 239, resource: {buffer: buffer22, size: 127}},
    {binding: 25, resource: {buffer: buffer74, size: 44}},
    {binding: 2, resource: textureView35},
  ],
});
let commandEncoder95 = device0.createCommandEncoder();
let texture113 = device0.createTexture({
  size: [1656, 1, 431],
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture114 = device0.createTexture({
  size: {width: 828, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder12.setBindGroup(1, bindGroup12);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
try {
  await promise11;
} catch {}
let bindGroup64 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 17, resource: externalTexture3},
    {binding: 5, resource: externalTexture10},
    {binding: 159, resource: sampler13},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 4, resource: {buffer: buffer15}},
    {binding: 524, resource: textureView85},
    {binding: 3, resource: textureView0},
    {binding: 0, resource: textureView32},
    {binding: 49, resource: {buffer: buffer55}},
    {binding: 153, resource: {buffer: buffer15}},
    {binding: 2, resource: externalTexture7},
    {binding: 1, resource: {buffer: buffer42}},
    {binding: 109, resource: textureView33},
    {binding: 312, resource: sampler0},
    {binding: 116, resource: textureView4},
    {binding: 308, resource: textureView51},
    {binding: 59, resource: {buffer: buffer22, size: 356}},
    {binding: 7, resource: {buffer: buffer61}},
    {binding: 61, resource: textureView7},
  ],
});
let texture115 = device0.createTexture({
  size: {width: 2760, height: 1, depthOrArrayLayers: 68},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let videoFrame19 = new VideoFrame(imageBitmap0, {timestamp: 0});
let texture116 = device0.createTexture({
  size: [256, 256, 19],
  mipLevelCount: 3,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture117 = gpuCanvasContext2.getCurrentTexture();
let textureView120 = texture50.createView({mipLevelCount: 1, arrayLayerCount: 5});
try {
computePassEncoder22.setBindGroup(2, bindGroup60, new Uint32Array(117), 11, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer36, 'uint32', 4, 0);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline14);
} catch {}
let buffer101 = device0.createBuffer({size: 136, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder96 = device0.createCommandEncoder({});
let commandBuffer10 = commandEncoder21.finish();
let externalTexture16 = device0.importExternalTexture({source: videoFrame13});
try {
computePassEncoder5.setBindGroup(3, bindGroup1, new Uint32Array(839), 96, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer4, 'uint16', 0, 0);
} catch {}
await gc();
let autogeneratedBindGroupLayout5 = pipeline10.getBindGroupLayout(1);
let commandEncoder97 = device0.createCommandEncoder({});
let texture118 = device0.createTexture({
  size: {width: 2760, height: 1, depthOrArrayLayers: 120},
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder24.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder8.insertDebugMarker('\u0fce');
} catch {}
let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 8, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 10, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 17,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 60,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 158,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 227,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let bindGroup65 = device0.createBindGroup({label: '\u2013\u5b02', layout: autogeneratedBindGroupLayout0, entries: []});
let texture119 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 16},
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder10.setVertexBuffer(5, buffer84);
} catch {}
try {
commandEncoder74.copyBufferToTexture({
  /* bytesInLastRow: 800 widthInBlocks: 100 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 5144 */
  offset: 5144,
  bytesPerRow: 9216,
  buffer: buffer85,
}, {
  texture: texture109,
  mipLevel: 2,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
}, {width: 100, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas0);
let texture120 = device0.createTexture({
  size: {width: 1380, height: 1, depthOrArrayLayers: 269},
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder21.setBindGroup(1, bindGroup15);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup61, []);
} catch {}
try {
renderBundleEncoder23.setVertexBuffer(0, buffer3, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer77, 120, new Uint32Array(7795).map((_, i) => i * 1), 1087, 12);
} catch {}
let pipeline19 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, constants: {}}});
let buffer102 = device0.createBuffer({
  size: 312,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder98 = device0.createCommandEncoder();
let textureView121 = texture120.createView({baseArrayLayer: 0});
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let imageData12 = new ImageData(20, 8);
let buffer103 = device0.createBuffer({size: 132, usage: GPUBufferUsage.INDIRECT});
let texture121 = device0.createTexture({
  size: [1380, 1, 45],
  dimension: '2d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture122 = device0.createTexture({
  size: [1656, 1, 1],
  mipLevelCount: 9,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder15 = commandEncoder73.beginRenderPass({
  label: '\u{1fcf8}\u0955\uc5ce\u{1f605}\u{1f725}\ube6a\u01c3\u0980\uc5cf',
  colorAttachments: [{
  view: textureView77,
  clearValue: { r: -245.1, g: 473.2, b: -112.4, a: -413.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder26.setPipeline(pipeline19);
} catch {}
let buffer104 = device0.createBuffer({size: 28, usage: GPUBufferUsage.QUERY_RESOLVE});
let commandBuffer11 = commandEncoder0.finish();
let texture123 = device0.createTexture({
  size: {width: 828, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 10,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture124 = device0.createTexture({
  size: [2760, 1, 37],
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder16 = commandEncoder90.beginRenderPass({
  colorAttachments: [{
  view: textureView79,
  clearValue: { r: -6.809, g: -369.7, b: -808.8, a: 224.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder5.setBindGroup(0, bindGroup64, new Uint32Array(4996), 531, 2);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(353);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(5, buffer82, 0, 38);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer24, 'uint16', 8, 16);
} catch {}
let arrayBuffer4 = buffer61.getMappedRange(80, 8);
try {
commandEncoder83.copyBufferToTexture({
  /* bytesInLastRow: 1820 widthInBlocks: 455 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 852 */
  offset: 852,
  bytesPerRow: 30208,
  buffer: buffer85,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 65, y: 0, z: 0},
  aspect: 'all',
}, {width: 455, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture43,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(22).fill(30), /* required buffer size: 22 */
{offset: 22}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'unspecified'} });
let bindGroup66 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]});
let texture125 = device0.createTexture({
  size: {width: 414, height: 1, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture126 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 38},
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder25.setBindGroup(2, bindGroup58, new Uint32Array(864), 250, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer36, 0); };
} catch {}
try {
renderBundleEncoder25.setBindGroup(2, bindGroup1);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline10);
} catch {}
try {
commandEncoder71.clearBuffer(buffer45);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture127 = device0.createTexture({
  size: [4, 4, 1],
  sampleCount: 1,
  dimension: '2d',
  format: 'stencil8',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView122 = texture46.createView({});
try {
renderBundleEncoder2.setBindGroup(1, bindGroup21);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer45, 'uint16', 10, 18);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(0, buffer23, 0);
} catch {}
let pipeline20 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, constants: {override4: 1}}});
let pipeline21 = device0.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 4},
  fragment: {module: shaderModule5, entryPoint: 'fragment5', targets: [{format: 'rgba16sint'}]},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 5},
          {format: 'uint32', offset: 0, shaderLocation: 2},
          {format: 'float32', offset: 0, shaderLocation: 15},
          {format: 'uint8x4', offset: 0, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4},
          {format: 'snorm16x2', offset: 0, shaderLocation: 6},
          {format: 'float32', offset: 0, shaderLocation: 1},
          {format: 'snorm8x2', offset: 0, shaderLocation: 0},
          {format: 'sint8x4', offset: 0, shaderLocation: 8},
          {format: 'sint16x2', offset: 0, shaderLocation: 13},
          {format: 'uint16x2', offset: 0, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 28,
        attributes: [
          {format: 'float16x4', offset: 8, shaderLocation: 12},
          {format: 'uint32x2', offset: 0, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 9},
          {format: 'snorm8x4', offset: 0, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'back'},
});
let textureView123 = texture104.createView({dimension: '2d-array'});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup57);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer35, 'uint16', 88, 32);
} catch {}
let commandEncoder99 = device0.createCommandEncoder({});
let texture128 = device0.createTexture({
  size: [345, 1, 1],
  mipLevelCount: 3,
  format: 'r8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView124 = texture7.createView({arrayLayerCount: 2});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer32, 120); };
} catch {}
try {
commandEncoder53.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2432 */
  offset: 2432,
  bytesPerRow: 3840,
  buffer: buffer85,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas1);
let buffer105 = device0.createBuffer({size: 212, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let texture129 = device0.createTexture({
  size: {width: 414, height: 1, depthOrArrayLayers: 1},
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler14 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 50.54, compare: 'not-equal'});
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer0, 68); };
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer62, 'uint32', 8, 10);
} catch {}
try {
device0.queue.submit([commandBuffer10, commandBuffer11]);
} catch {}
try {
device0.queue.writeBuffer(buffer29, 44, new DataView(new Uint8Array(2632).map((_, i) => i).buffer), 7, 16);
} catch {}
await gc();
let textureView125 = texture120.createView({});
try {
computePassEncoder5.setBindGroup(0, bindGroup48, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup66, new Uint32Array(1289), 61, 0);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(644);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer76, 0, 35);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline4);
} catch {}
try {
  await promise12;
} catch {}
let commandEncoder100 = device0.createCommandEncoder({});
let texture130 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView126 = texture1.createView({baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 4});
let externalTexture17 = device0.importExternalTexture({source: videoFrame3});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(3); };
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer84, 'uint32', 12, 15);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup53, new Uint32Array(2241), 25, 0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(0, buffer3);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', minBindingSize: 10, hasDynamicOffset: false },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 73,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 154,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let bindGroup67 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 1, resource: textureView107},
    {binding: 7, resource: textureView46},
    {binding: 16, resource: textureView17},
    {binding: 3, resource: {buffer: buffer22, size: 324}},
    {binding: 2, resource: {buffer: buffer46}},
  ],
});
let buffer106 = device0.createBuffer({size: 4838, usage: GPUBufferUsage.QUERY_RESOLVE});
let texture131 = device0.createTexture({
  size: {width: 1380, height: 1, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture132 = device0.createTexture({
  size: {width: 1656},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(7, buffer25, 0, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 28, new Uint32Array(390).map((_, i) => i * 3), 20, 0);
} catch {}
let pipeline22 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule7, constants: {}}});
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture133 = device0.createTexture({
  size: [1, 1, 1],
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder3.setStencilReference(1081);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer82, 44, 21);
} catch {}
try {
renderBundleEncoder21.setBindGroup(1, bindGroup19, new Uint32Array(910), 184, 0);
} catch {}
try {
renderBundleEncoder3.setPipeline(pipeline6);
} catch {}
let commandEncoder101 = device0.createCommandEncoder({});
let texture134 = device0.createTexture({
  size: {width: 414, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture135 = device0.createTexture({
  size: {width: 2760, height: 1, depthOrArrayLayers: 43},
  mipLevelCount: 4,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView127 = texture53.createView({dimension: 'cube', baseArrayLayer: 4});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
let externalTexture18 = device0.importExternalTexture({source: videoFrame18});
try {
computePassEncoder15.setBindGroup(0, bindGroup62, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder14.end();
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer62, 'uint32', 28, 37);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(3, buffer97);
} catch {}
let commandEncoder102 = device0.createCommandEncoder();
let texture136 = device0.createTexture({
  size: [1656, 1, 128],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder21.setBindGroup(1, bindGroup35, []);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(3, buffer6);
} catch {}
try {
renderBundleEncoder23.setBindGroup(3, bindGroup14);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
try {
buffer98.unmap();
} catch {}
try {
commandEncoder84.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture20,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.TEXTURE_BINDING});
} catch {}
let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'bt709'} });
try {
globalThis.someLabel = commandBuffer6.label;
} catch {}
let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {binding: 12, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }},
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let texture137 = device0.createTexture({
  size: {width: 1, height: 1, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture138 = device0.createTexture({
  size: [2, 2, 252],
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture19 = device0.importExternalTexture({source: videoFrame7});
try {
computePassEncoder9.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup56, new Uint32Array(1439), 222, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer66, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(6, buffer25, 0, 6);
} catch {}
try {
device0.queue.writeBuffer(buffer105, 28, new DataView(new ArrayBuffer(36800)), 7635, 4);
} catch {}
document.body.append(img2);
let bindGroup68 = device0.createBindGroup({layout: autogeneratedBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let buffer107 = device0.createBuffer({size: 268, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let texture139 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 19},
  mipLevelCount: 3,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture140 = device0.createTexture({
  label: '\u3aa9\u04f6\u83d8\u079c\u48e9\u083b\u078d\u13b6',
  size: {width: 8, height: 8, depthOrArrayLayers: 60},
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2760, height: 1, depthOrArrayLayers: 43}
*/
{
  source: imageBitmap3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture135,
  mipLevel: 0,
  origin: {x: 426, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer108 = device0.createBuffer({size: 116, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let commandEncoder103 = device0.createCommandEncoder({});
let texture141 = device0.createTexture({
  size: [1, 1, 1],
  mipLevelCount: 1,
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder15.setBindGroup(3, bindGroup16);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
device0.queue.writeBuffer(buffer102, 44, new Uint16Array(796).map((_, i) => i + 0), 408, 12);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 690, height: 1, depthOrArrayLayers: 7}
*/
{
  source: videoFrame15,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture83,
  mipLevel: 1,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let autogeneratedBindGroupLayout6 = pipeline17.getBindGroupLayout(1);
let bindGroup69 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 16, resource: textureView17},
    {binding: 2, resource: {buffer: buffer15}},
    {binding: 3, resource: {buffer: buffer15}},
    {binding: 1, resource: textureView109},
    {binding: 7, resource: textureView46},
  ],
});
let textureView128 = texture139.createView({dimension: 'cube', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 3});
try {
computePassEncoder7.end();
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(145);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(7, buffer102, 0, 5);
} catch {}
try {
commandEncoder94.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 6224 */
  offset: 6224,
  bytesPerRow: 11520,
  buffer: buffer85,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline23 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}});
let bindGroup70 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 3, resource: textureView75},
    {binding: 1, resource: {buffer: buffer17}},
    {binding: 17, resource: externalTexture10},
    {binding: 159, resource: sampler3},
    {binding: 59, resource: {buffer: buffer46}},
    {binding: 524, resource: textureView14},
    {binding: 7, resource: {buffer: buffer22, size: 220}},
    {binding: 116, resource: textureView2},
    {binding: 312, resource: sampler2},
    {binding: 2, resource: externalTexture10},
    {binding: 153, resource: {buffer: buffer15}},
    {binding: 0, resource: textureView32},
    {binding: 308, resource: textureView61},
    {binding: 5, resource: externalTexture9},
    {binding: 49, resource: {buffer: buffer79}},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 4, resource: {buffer: buffer79}},
    {binding: 61, resource: textureView8},
    {binding: 109, resource: textureView11},
  ],
});
let textureView129 = texture111.createView({dimension: '2d-array', format: 'rgba16float', mipLevelCount: 1});
try {
renderPassEncoder3.setBindGroup(2, bindGroup46);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
buffer25.unmap();
} catch {}
try {
commandEncoder98.copyBufferToBuffer(buffer32, 96, buffer62, 20, 24);
} catch {}
let pipeline24 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment6',
  targets: [{
  format: 'rgba16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule4,
    constants: {},
    buffers: [
      {
        arrayStride: 64,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x2', offset: 0, shaderLocation: 13},
          {format: 'uint32x2', offset: 20, shaderLocation: 11},
          {format: 'uint32x4', offset: 12, shaderLocation: 10},
          {format: 'unorm16x2', offset: 8, shaderLocation: 7},
          {format: 'snorm8x2', offset: 6, shaderLocation: 8},
          {format: 'float32x3', offset: 4, shaderLocation: 6},
          {format: 'uint32x2', offset: 20, shaderLocation: 15},
          {format: 'unorm16x4', offset: 0, shaderLocation: 0},
          {format: 'uint32', offset: 20, shaderLocation: 1},
          {format: 'float32x3', offset: 4, shaderLocation: 14},
          {format: 'unorm10-10-10-2', offset: 12, shaderLocation: 5},
          {format: 'uint32x3', offset: 0, shaderLocation: 2},
          {format: 'snorm8x4', offset: 4, shaderLocation: 12},
          {format: 'uint8x4', offset: 12, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [{format: 'sint32x3', offset: 0, shaderLocation: 4}, {format: 'sint32x3', offset: 0, shaderLocation: 3}],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', cullMode: 'front'},
});
try {
computePassEncoder12.setBindGroup(2, bindGroup3, new Uint32Array(1291), 234, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup20);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(863);
} catch {}
try {
renderBundleEncoder16.setIndexBuffer(buffer24, 'uint32', 4, 0);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer36, 0, 0);
} catch {}
let arrayBuffer5 = buffer61.getMappedRange(64, 0);
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0); };
} catch {}
let textureView130 = texture6.createView({dimension: '1d', format: 'r32sint'});
try {
renderPassEncoder3.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer35, 'uint16', 118, 21);
} catch {}
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout9, veryExplicitBindGroupLayout22]});
let commandEncoder104 = device0.createCommandEncoder({});
let texture142 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder13.setBindGroup(1, bindGroup34, new Uint32Array(4999), 1_802, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(5, 1); };
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline24);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView131 = texture94.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup44, new Uint32Array(933), 141, 0);
} catch {}
try {
renderBundleEncoder11.setBindGroup(1, bindGroup29, new Uint32Array(1146), 32, 0);
} catch {}
await gc();
let commandEncoder105 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup0, new Uint32Array(579), 23, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer6, 'uint16', 40, 1);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup5, new Uint32Array(1092), 278, 0);
} catch {}
try {
buffer35.unmap();
} catch {}
let bindGroup71 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout15,
  entries: [
    {binding: 154, resource: textureView98},
    {binding: 0, resource: {buffer: buffer81}},
    {binding: 4, resource: textureView87},
    {binding: 73, resource: {buffer: buffer46}},
  ],
});
try {
computePassEncoder22.setBindGroup(3, bindGroup17, new Uint32Array(721), 86, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer38, 'uint32', 8, 0);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(2, buffer65);
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(80, 500);
let commandEncoder106 = device0.createCommandEncoder({});
let texture143 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 332},
  sampleCount: 1,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder16.setBindGroup(0, bindGroup24, new Uint32Array(742), 48, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer98, 'uint16', 2, 47);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let bindGroup72 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout16,
  entries: [
    {binding: 16, resource: textureView17},
    {binding: 7, resource: textureView46},
    {binding: 2, resource: {buffer: buffer42, size: 4}},
    {binding: 3, resource: {buffer: buffer46}},
    {binding: 1, resource: textureView15},
  ],
});
let texture144 = device0.createTexture({size: {width: 345}, dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder24.setBindGroup(0, bindGroup47, new Uint32Array(2137), 371, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer84, 'uint32', 32, 40);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline14);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let commandBuffer12 = commandEncoder5.finish();
let textureView132 = texture142.createView({mipLevelCount: 1});
try {
renderPassEncoder9.setBlendConstant({ r: -974.7, g: -48.84, b: 18.33, a: 587.0, });
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline11);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2760, height: 1, depthOrArrayLayers: 120}
*/
{
  source: imageBitmap3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture118,
  mipLevel: 0,
  origin: {x: 183, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let textureView133 = texture1.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 9, arrayLayerCount: 4});
let renderPassEncoder17 = commandEncoder59.beginRenderPass({
  colorAttachments: [{
  view: textureView79,
  clearValue: { r: 512.7, g: -347.8, b: -308.9, a: -931.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 30244069,
});
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer95, 72);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(4, buffer102, 0, 72);
} catch {}
try {
  await buffer78.mapAsync(GPUMapMode.READ);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(26); };
} catch {}
let bindGroup73 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView5}]});
let textureView134 = texture1.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 2});
let computePassEncoder28 = commandEncoder28.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer22, 12); };
} catch {}
try {
computePassEncoder28.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder19.setBindGroup(2, bindGroup13);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup40, new Uint32Array(139), 38, 0);
} catch {}
try {
commandEncoder67.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 752 */
  offset: 752,
  bytesPerRow: 1024,
  buffer: buffer85,
}, {
  texture: texture84,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(81); };
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 16, resource: textureView104},
    {binding: 2, resource: {buffer: buffer15, offset: 0}},
    {binding: 7, resource: textureView21},
    {binding: 3, resource: {buffer: buffer46}},
    {binding: 1, resource: textureView44},
  ],
});
let buffer109 = device0.createBuffer({size: 304, usage: GPUBufferUsage.INDEX});
let textureView135 = texture139.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 4});
try {
renderPassEncoder8.setBindGroup(1, bindGroup27);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup7, new Uint32Array(118), 50, 0);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline24);
} catch {}
try {
commandEncoder83.clearBuffer(buffer63);
} catch {}
try {
computePassEncoder26.setBindGroup(2, bindGroup44, new Uint32Array(2134), 90, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup4, new Uint32Array(4865), 358, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer98, 'uint32', 36, 23);
} catch {}
try {
buffer109.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer79, 40, new Float32Array(1921).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.967)), 396, 8);
} catch {}
let gpuCanvasContext4 = offscreenCanvas3.getContext('webgpu');
let imageBitmap4 = await createImageBitmap(imageData8);
let bindGroup75 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let commandEncoder107 = device0.createCommandEncoder({});
let texture145 = device0.createTexture({
  size: [1380, 1, 69],
  mipLevelCount: 5,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder12.setBindGroup(2, bindGroup65);
} catch {}
try {
computePassEncoder11.dispatchWorkgroups(1);
} catch {}
try {
renderBundleEncoder2.setBindGroup(0, bindGroup18, new Uint32Array(1203), 68, 0);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(2, buffer97);
} catch {}
try {
device0.queue.submit([commandBuffer12]);
} catch {}
try {
device0.queue.writeBuffer(buffer16, 16, new Float32Array(153).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4487)), 22, 4);
} catch {}
try {
renderPassEncoder3.label = '\u0778\u1483\u2837\u41b9\u{1fc68}';
} catch {}
let bindGroup76 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout22,
  entries: [
    {binding: 16, resource: {buffer: buffer34}},
    {binding: 4, resource: textureView45},
    {binding: 65, resource: externalTexture10},
  ],
});
try {
computePassEncoder13.end();
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer109, 'uint16', 230, 4);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let computePassEncoder29 = commandEncoder77.beginComputePass();
try {
computePassEncoder12.setBindGroup(0, bindGroup64, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroupsIndirect(buffer22, 4); };
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(2, buffer102, 0, 29);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(39); };
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2760, height: 1, depthOrArrayLayers: 120}
*/
{
  source: imageData0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture118,
  mipLevel: 0,
  origin: {x: 444, y: 0, z: 26},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas1);
let texture146 = gpuCanvasContext1.getCurrentTexture();
try {
computePassEncoder22.setBindGroup(2, bindGroup76, new Uint32Array(4924), 769, 0);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer55, 'uint32', 4, 13);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer6, 'uint32', 20, 8);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline2);
} catch {}
try {
  await promise13;
} catch {}
document.body.prepend(canvas1);
let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte432', transfer: 'gamma22curve'} });
let bindGroup77 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 93, resource: textureView5}]});
let commandEncoder108 = device0.createCommandEncoder();
let texture147 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView136 = texture40.createView({dimension: '2d', baseArrayLayer: 37});
let computePassEncoder30 = commandEncoder88.beginComputePass();
try {
computePassEncoder25.end();
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder24.setBindGroup(1, bindGroup6, new Uint32Array(1112), 46, 0);
} catch {}
await gc();
try {
renderBundleEncoder20.setBindGroup(3, bindGroup68);
} catch {}
try {
renderBundleEncoder3.setBindGroup(3, bindGroup77, new Uint32Array(3294), 44, 0);
} catch {}
try {
commandEncoder39.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2376 */
  offset: 2376,
  buffer: buffer85,
}, {
  texture: texture28,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let imageData13 = new ImageData(16, 44);
let bindGroup78 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]});
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer22, 112); };
} catch {}
try {
computePassEncoder30.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(460);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer84, 'uint32', 12, 9);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline2);
} catch {}
try {
commandEncoder43.resolveQuerySet(querySet1, 55, 19, buffer15, 0);
} catch {}
try {
  await promise14;
} catch {}
let autogeneratedBindGroupLayout7 = pipeline4.getBindGroupLayout(0);
let buffer110 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let commandEncoder109 = device0.createCommandEncoder({});
let commandBuffer13 = commandEncoder10.finish();
try {
computePassEncoder30.setBindGroup(0, bindGroup70, [0, 0]);
} catch {}
try {
computePassEncoder24.setBindGroup(3, bindGroup66, new Uint32Array(931), 5, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer76, 8, 9);
} catch {}
try {
device0.queue.submit([commandBuffer13]);
} catch {}
try {
globalThis.someLabel = externalTexture14.label;
} catch {}
let bindGroup79 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 4, resource: textureView45},
    {binding: 16, resource: {buffer: buffer25, size: 36}},
    {binding: 65, resource: externalTexture0},
  ],
});
let textureView137 = texture96.createView({dimension: '2d-array'});
let texture148 = device0.createTexture({
  size: [256, 256, 19],
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView138 = texture141.createView({});
let externalTexture20 = device0.importExternalTexture({source: videoFrame10});
try {
computePassEncoder21.end();
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer96, 'uint32', 16, 12);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(6, buffer38, 0, 4);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(5, buffer82, 0, 15);
} catch {}
try {
commandEncoder97.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2056 */
  offset: 2056,
  bytesPerRow: 18432,
  buffer: buffer85,
}, {
  texture: texture65,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder110 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup2, new Uint32Array(5563), 1_756, 0);
} catch {}
try {
renderPassEncoder17.beginOcclusionQuery(499);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(4, buffer62, 0);
} catch {}
try {
renderBundleEncoder10.setBindGroup(0, bindGroup56, []);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline25 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x2c068ff3},
  fragment: {module: shaderModule5, entryPoint: 'fragment5', constants: {}, targets: [{format: 'rgba16sint'}]},
  vertex: {
    module: shaderModule7,
    constants: {},
    buffers: [
      {
        arrayStride: 4,
        stepMode: 'instance',
        attributes: [{format: 'uint8x2', offset: 0, shaderLocation: 13}, {format: 'uint8x4', offset: 0, shaderLocation: 10}],
      },
      {arrayStride: 92, attributes: [{format: 'uint32x2', offset: 4, shaderLocation: 2}]},
    ],
  },
  primitive: {topology: 'triangle-list', cullMode: 'back'},
});
let buffer111 = device0.createBuffer({size: 88, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let textureView139 = texture10.createView({dimension: '1d'});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(2, 1); };
} catch {}
try {
computePassEncoder11.end();
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer60, 'uint32', 0, 35);
} catch {}
let texture149 = device0.createTexture({
  size: {width: 2760, height: 1, depthOrArrayLayers: 25},
  mipLevelCount: 7,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4});
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer107, 8);
} catch {}
try {
renderBundleEncoder11.setVertexBuffer(1, buffer84);
} catch {}
let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 25,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 239,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let commandEncoder111 = device0.createCommandEncoder({});
try {
renderPassEncoder17.setIndexBuffer(buffer55, 'uint16', 8, 7);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup44, new Uint32Array(265), 180, 0);
} catch {}
try {
renderBundleEncoder18.setIndexBuffer(buffer24, 'uint16', 22, 33);
} catch {}
let texture150 = device0.createTexture({
  size: [345, 1, 42],
  mipLevelCount: 3,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView140 = texture147.createView({dimension: '2d-array', format: 'rgba16sint', mipLevelCount: 1});
let renderPassEncoder18 = commandEncoder75.beginRenderPass({
  colorAttachments: [{
  view: textureView77,
  clearValue: { r: 80.12, g: -271.1, b: -152.8, a: -870.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: false});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(2, buffer6);
} catch {}
let arrayBuffer6 = buffer78.getMappedRange(0, 0);
let commandEncoder112 = device0.createCommandEncoder({});
try {
renderPassEncoder8.setVertexBuffer(2, buffer6, 0, 16);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup68);
} catch {}
let arrayBuffer7 = buffer78.getMappedRange(8, 0);
try {
device0.queue.writeBuffer(buffer5, 4, new Uint32Array(12918).map((_, i) => i * 1), 1871, 0);
} catch {}
let pipeline26 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {}}});
let texture151 = device0.createTexture({
  size: {width: 207, height: 1, depthOrArrayLayers: 22},
  sampleCount: 1,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView141 = texture111.createView({dimension: '2d-array', aspect: 'all', format: 'rgba16float', baseMipLevel: 0, mipLevelCount: 1});
try {
renderPassEncoder4.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder23.setIndexBuffer(buffer4, 'uint32', 0, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandBuffer14 = commandEncoder13.finish();
let sampler15 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 77.62, maxAnisotropy: 12});
try {
device0.queue.writeBuffer(buffer36, 0, new DataView(new ArrayBuffer(12668)), 31, 0);
} catch {}
await gc();
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer1, 0); };
} catch {}
try {
renderPassEncoder11.setVertexBuffer(4, buffer6, 8, 11);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup74, new Uint32Array(4550), 642, 0);
} catch {}
let buffer112 = device0.createBuffer({size: 123, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder113 = device0.createCommandEncoder();
let texture152 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer85, 2_676); };
} catch {}
try {
computePassEncoder15.end();
} catch {}
try {
renderBundleEncoder10.setBindGroup(2, bindGroup5, []);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer6, 'uint32', 0, 21);
} catch {}
let promise15 = device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule7,
  constants: {47_734: 1},
  targets: [{
  format: 'rgba16float',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'src'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'one-minus-src'},
  },
  writeMask: 0,
}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex3',
    buffers: [
      {
        arrayStride: 108,
        attributes: [
          {format: 'unorm8x4', offset: 56, shaderLocation: 8},
          {format: 'unorm16x4', offset: 8, shaderLocation: 5},
          {format: 'snorm8x4', offset: 0, shaderLocation: 0},
          {format: 'uint32x3', offset: 36, shaderLocation: 9},
          {format: 'float32', offset: 24, shaderLocation: 6},
          {format: 'snorm8x2', offset: 0, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 7},
          {format: 'sint16x4', offset: 0, shaderLocation: 4},
          {format: 'uint16x2', offset: 0, shaderLocation: 2},
          {format: 'uint32x4', offset: 4, shaderLocation: 13},
          {format: 'uint16x4', offset: 4, shaderLocation: 11},
          {format: 'uint16x4', offset: 8, shaderLocation: 15},
          {format: 'uint16x2', offset: 4, shaderLocation: 1},
          {format: 'sint8x2', offset: 64, shaderLocation: 3},
          {format: 'uint32x2', offset: 4, shaderLocation: 10},
        ],
      },
      {arrayStride: 16, attributes: [{format: 'unorm8x2', offset: 0, shaderLocation: 14}]},
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'},
});
let bindGroup80 = device0.createBindGroup({
  layout: autogeneratedBindGroupLayout7,
  entries: [
    {binding: 1, resource: {buffer: buffer58, size: 83}},
    {binding: 4, resource: {buffer: buffer46, size: 2432}},
  ],
});
let texture153 = device0.createTexture({
  size: [256, 256, 120],
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
renderBundleEncoder3.setIndexBuffer(buffer80, 'uint16', 42, 5);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(0, buffer3, 172);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let commandEncoder114 = device0.createCommandEncoder({});
let texture154 = device0.createTexture({
  size: [828, 1, 1],
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder12.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(3, buffer6, 12);
} catch {}
try {
device0.queue.submit([commandBuffer14]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 256, height: 256, depthOrArrayLayers: 203}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 8, y: 13, z: 29},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(77); };
} catch {}
let imageData14 = new ImageData(32, 120);
try {
device0.queue.label = '';
} catch {}
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 3});
let texture155 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView142 = texture31.createView({dimension: '3d', format: 'rgba16sint', baseMipLevel: 0});
try {
computePassEncoder16.setBindGroup(0, bindGroup64, new Uint32Array(2567), 643, 2);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer55, 'uint16', 34, 38);
} catch {}
try {
renderBundleEncoder8.setBindGroup(1, bindGroup38);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(3, buffer61);
} catch {}
try {
computePassEncoder16.pushDebugGroup('\u{1f974}');
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
try {
  await promise16;
} catch {}
let textureView143 = texture141.createView({baseMipLevel: 0});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer101, 20); };
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer107, 'uint16', 28, 2);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
buffer85.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 2,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 25,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 239,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let buffer113 = device0.createBuffer({size: 58, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let texture156 = device0.createTexture({
  size: [207, 1, 5],
  mipLevelCount: 3,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView144 = texture105.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let renderPassEncoder19 = commandEncoder85.beginRenderPass({colorAttachments: [{view: textureView19, loadOp: 'clear', storeOp: 'store'}]});
try {
computePassEncoder18.setBindGroup(1, bindGroup72, new Uint32Array(810), 228, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer81, 264);
} catch {}
try {
device0.queue.writeBuffer(buffer23, 36, new DataView(new ArrayBuffer(7812)), 4, 4);
} catch {}
let commandEncoder115 = device0.createCommandEncoder({});
let texture157 = device0.createTexture({
  size: [345, 1, 67],
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView145 = texture101.createView({dimension: '2d-array', format: 'rg32uint'});
let computePassEncoder31 = commandEncoder69.beginComputePass();
try {
renderPassEncoder0.setIndexBuffer(buffer55, 'uint16', 50, 3);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(2, buffer62);
} catch {}
try {
computePassEncoder16.popDebugGroup();
} catch {}
try {
renderPassEncoder8.insertDebugMarker('\u0d9a');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'extended'},
});
} catch {}
document.body.append(canvas1);
await gc();
let commandEncoder116 = device0.createCommandEncoder();
let texture158 = device0.createTexture({
  size: [2, 2, 1],
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView146 = texture83.createView({mipLevelCount: 1});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true});
let externalTexture21 = device0.importExternalTexture({source: videoFrame14});
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer23, 8); };
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup19, new Uint32Array(169), 73, 0);
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer108, 'uint16', 4, 2);
} catch {}
let arrayBuffer8 = buffer61.getMappedRange(72, 0);
try {
device0.queue.writeBuffer(buffer46, 912, new DataView(new Uint8Array(2351).map((_, i) => i).buffer), 376, 368);
} catch {}
let pipeline27 = await device0.createComputePipelineAsync({
  label: '\u0873\ub0cc\u{1fe9e}\u{1fcab}\ua55b\u011c\uc92f',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, constants: {override4: 1}},
});
let texture159 = device0.createTexture({
  size: {width: 1},
  dimension: '1d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture160 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder29.setBindGroup(3, bindGroup31);
} catch {}
try {
commandEncoder54.copyBufferToBuffer(buffer59, 0, buffer74, 4, 4);
} catch {}
try {
commandEncoder112.clearBuffer(buffer80, 4, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup81 = device0.createBindGroup({
  label: '\uc80d\u3825\ua9fc\u3c62\u002f',
  layout: veryExplicitBindGroupLayout9,
  entries: [
    {binding: 61, resource: textureView27},
    {binding: 2, resource: externalTexture19},
    {binding: 312, resource: sampler14},
    {binding: 153, resource: {buffer: buffer15, size: 1488}},
    {binding: 4, resource: {buffer: buffer79}},
    {binding: 17, resource: externalTexture1},
    {binding: 1, resource: {buffer: buffer28, size: 83}},
    {binding: 159, resource: sampler1},
    {binding: 5, resource: externalTexture3},
    {binding: 524, resource: textureView85},
    {binding: 0, resource: textureView22},
    {binding: 109, resource: textureView23},
    {binding: 308, resource: textureView50},
    {binding: 49, resource: {buffer: buffer7}},
    {binding: 3, resource: textureView42},
    {binding: 7, resource: {buffer: buffer81}},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 59, resource: {buffer: buffer15}},
    {binding: 116, resource: textureView2},
  ],
});
let texture161 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 22},
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView147 = texture149.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 4});
let computePassEncoder32 = commandEncoder87.beginComputePass();
try {
device0.queue.submit([]);
} catch {}
let veryExplicitBindGroupLayout28 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 59,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 61,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 109,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 308,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 312,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 524,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let buffer114 = device0.createBuffer({size: 67, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let commandEncoder117 = device0.createCommandEncoder({});
let textureView148 = texture158.createView({dimension: '2d-array'});
let textureView149 = texture155.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
let computePassEncoder33 = commandEncoder53.beginComputePass();
try {
renderPassEncoder15.setVertexBuffer(4, buffer62, 0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup68);
} catch {}
try {
renderBundleEncoder26.setBindGroup(0, bindGroup37, new Uint32Array(797), 71, 0);
} catch {}
try {
commandEncoder57.copyBufferToBuffer(buffer64, 8, buffer102, 60, 0);
} catch {}
document.body.prepend(img1);
let commandEncoder118 = device0.createCommandEncoder({});
let textureView150 = texture159.createView({});
let texture162 = device0.createTexture({
  size: [2, 2, 362],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder33.setPipeline(pipeline1);
} catch {}
await gc();
let autogeneratedBindGroupLayout8 = pipeline16.getBindGroupLayout(0);
let bindGroup82 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 93, resource: textureView5}]});
let textureView151 = texture27.createView({});
try {
computePassEncoder12.setBindGroup(0, bindGroup72, new Uint32Array(971), 43, 0);
} catch {}
try {
computePassEncoder18.end();
} catch {}
try {
computePassEncoder32.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setStencilReference(1783);
} catch {}
try {
renderBundleEncoder20.setBindGroup(2, bindGroup21, new Uint32Array(2646), 404, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture54,
  mipLevel: 0,
  origin: {x: 43, y: 0, z: 5},
  aspect: 'all',
}, new Uint8Array(19_171).fill(8), /* required buffer size: 19_171 */
{offset: 19, bytesPerRow: 38, rowsPerImage: 72}, {width: 3, height: 0, depthOrArrayLayers: 8});
} catch {}
let bindGroup83 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 5, resource: externalTexture9},
    {binding: 0, resource: textureView32},
    {binding: 159, resource: sampler10},
    {binding: 49, resource: {buffer: buffer55}},
    {binding: 116, resource: textureView2},
    {binding: 1, resource: {buffer: buffer58, size: 69}},
    {binding: 2, resource: externalTexture15},
    {binding: 61, resource: textureView30},
    {binding: 10, resource: {buffer: buffer46, size: 3284}},
    {binding: 59, resource: {buffer: buffer46}},
    {binding: 312, resource: sampler14},
    {binding: 3, resource: textureView57},
    {binding: 308, resource: textureView12},
    {binding: 4, resource: {buffer: buffer22, size: 232}},
    {binding: 17, resource: externalTexture12},
    {binding: 109, resource: textureView99},
    {binding: 524, resource: textureView35},
    {binding: 153, resource: {buffer: buffer15}},
    {binding: 7, resource: {buffer: buffer105}},
  ],
});
let commandEncoder119 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer105, 8); };
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer98, 'uint32', 48, 17);
} catch {}
let arrayBuffer9 = buffer61.getMappedRange(88, 12);
try {
commandEncoder79.resolveQuerySet(querySet2, 0, 0, buffer24, 0);
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let veryExplicitBindGroupLayout29 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 3,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
    {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 7,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 59,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 61,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
    {
      binding: 109,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 308,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 312,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 524,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let bindGroup84 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 4, resource: textureView113},
    {binding: 73, resource: {buffer: buffer46}},
    {binding: 0, resource: {buffer: buffer36}},
    {binding: 154, resource: textureView103},
  ],
});
let sampler16 = device0.createSampler({addressModeU: 'repeat', minFilter: 'nearest', lodMaxClamp: 60.99});
try {
computePassEncoder31.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(3, buffer3, 0, 43);
} catch {}
try {
renderBundleEncoder23.insertDebugMarker('\ua6cc');
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let img4 = await imageWithData(146, 72, '#10101010', '#20202020');
let buffer115 = device0.createBuffer({size: 320, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let textureView152 = texture1.createView({label: '\u8df5\u00a1\u{1f805}\u88ae', dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 4});
let textureView153 = texture154.createView({dimension: '2d-array', format: 'rgba16uint'});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer103, 44); };
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder25.setBindGroup(1, bindGroup39);
} catch {}
try {
commandEncoder57.copyBufferToTexture({
  /* bytesInLastRow: 376 widthInBlocks: 94 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3936 */
  offset: 3936,
  buffer: buffer85,
}, {
  texture: texture98,
  mipLevel: 0,
  origin: {x: 100, y: 0, z: 0},
  aspect: 'all',
}, {width: 94, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder32.insertDebugMarker('\u74c8');
} catch {}
let commandEncoder120 = device0.createCommandEncoder({});
let textureView154 = texture97.createView({dimension: '2d-array'});
let textureView155 = texture129.createView({dimension: '2d-array'});
try {
computePassEncoder32.setBindGroup(0, bindGroup15, new Uint32Array(722), 82, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer32, 84); };
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup14);
} catch {}
let commandEncoder121 = device0.createCommandEncoder();
let commandBuffer15 = commandEncoder24.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); };
} catch {}
try {
device0.queue.writeBuffer(buffer32, 52, new DataView(new ArrayBuffer(57348)), 3147, 36);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 2, depthOrArrayLayers: 1}
*/
{
  source: videoFrame15,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture158,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline28 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0xdf9d069},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment5',
  targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule2,
    constants: {},
    buffers: [
      {
        arrayStride: 12,
        attributes: [
          {format: 'snorm16x2', offset: 0, shaderLocation: 10},
          {format: 'uint32x3', offset: 0, shaderLocation: 7},
          {format: 'float32x2', offset: 0, shaderLocation: 9},
          {format: 'float16x2', offset: 0, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
let imageData15 = new ImageData(68, 24);
let bindGroup85 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [
    {binding: 7, resource: {buffer: buffer81, offset: 0}},
    {binding: 49, resource: {buffer: buffer55}},
    {binding: 1, resource: {buffer: buffer81, size: 145}},
    {binding: 116, resource: textureView4},
    {binding: 153, resource: {buffer: buffer46}},
    {binding: 4, resource: {buffer: buffer15}},
    {binding: 3, resource: textureView0},
    {binding: 5, resource: externalTexture2},
    {binding: 524, resource: textureView80},
    {binding: 0, resource: textureView32},
    {binding: 308, resource: textureView12},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 109, resource: textureView23},
    {binding: 61, resource: textureView7},
    {binding: 17, resource: externalTexture20},
    {binding: 59, resource: {buffer: buffer15}},
    {binding: 312, resource: sampler0},
    {binding: 159, resource: sampler12},
    {binding: 2, resource: externalTexture19},
  ],
});
let textureView156 = texture74.createView({baseArrayLayer: 0});
try {
renderPassEncoder2.setIndexBuffer(buffer108, 'uint32', 36, 8);
} catch {}
try {
renderBundleEncoder21.setBindGroup(3, bindGroup80, []);
} catch {}
let bindGroup86 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 159, resource: sampler1},
    {binding: 524, resource: textureView80},
    {binding: 17, resource: externalTexture14},
    {binding: 1, resource: {buffer: buffer27, size: 57}},
    {binding: 153, resource: {buffer: buffer46}},
    {binding: 59, resource: {buffer: buffer15}},
    {binding: 109, resource: textureView23},
    {binding: 10, resource: {buffer: buffer46, size: 3220}},
    {binding: 116, resource: textureView4},
    {binding: 312, resource: sampler2},
    {binding: 4, resource: {buffer: buffer15}},
    {binding: 308, resource: textureView55},
    {binding: 2, resource: externalTexture7},
    {binding: 7, resource: {buffer: buffer61, size: 168}},
    {binding: 0, resource: textureView32},
    {binding: 61, resource: textureView9},
    {binding: 5, resource: externalTexture9},
    {binding: 3, resource: textureView41},
    {binding: 49, resource: {buffer: buffer79, size: 20}},
  ],
});
let commandEncoder122 = device0.createCommandEncoder({});
let textureView157 = texture158.createView({dimension: '2d-array'});
let texture163 = device0.createTexture({
  size: [414],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder12.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup28, []);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(5, buffer65, 4);
} catch {}
let arrayBuffer10 = buffer61.getMappedRange(104, 16);
try {
commandEncoder104.copyBufferToTexture({
  /* bytesInLastRow: 136 widthInBlocks: 34 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1816 */
  offset: 1816,
  bytesPerRow: 17408,
  buffer: buffer85,
}, {
  texture: texture119,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {width: 34, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder52.resolveQuerySet(querySet0, 646, 82, buffer106, 1792);
} catch {}
try {
device0.queue.writeBuffer(buffer102, 28, new Float32Array(15198).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.6452)), 439, 28);
} catch {}
let commandEncoder123 = device0.createCommandEncoder();
let texture164 = device0.createTexture({
  size: [256, 256, 19],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let externalTexture22 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'});
try {
computePassEncoder33.setBindGroup(0, bindGroup83, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(948);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer57, 'uint32', 24, 11);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(1, buffer6, 68);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer108, 'uint16', 12, 98);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline24);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1, 3); };
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 0, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, undefined, 0, 1_515_362_848);
} catch {}
try {
renderBundleEncoder8.setPipeline(pipeline28);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(3, buffer81, 64, 71);
} catch {}
try {
device0.queue.submit([commandBuffer15]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture118,
  mipLevel: 0,
  origin: {x: 107, y: 0, z: 9},
  aspect: 'all',
}, new Uint8Array(878_350).fill(75), /* required buffer size: 878_350 */
{offset: 110, bytesPerRow: 4990, rowsPerImage: 16}, {width: 1209, height: 0, depthOrArrayLayers: 12});
} catch {}
let promise18 = device0.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x92711f7b},
  fragment: {module: shaderModule3, targets: [{format: 'rgba16sint'}]},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 92,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 8, shaderLocation: 5},
          {format: 'float32x2', offset: 12, shaderLocation: 9},
          {format: 'sint8x2', offset: 2, shaderLocation: 8},
          {format: 'uint32x3', offset: 0, shaderLocation: 3},
          {format: 'snorm8x2', offset: 22, shaderLocation: 4},
          {format: 'uint8x2', offset: 2, shaderLocation: 7},
          {format: 'unorm16x4', offset: 24, shaderLocation: 14},
          {format: 'unorm16x2', offset: 8, shaderLocation: 12},
          {format: 'sint32x2', offset: 0, shaderLocation: 10},
          {format: 'uint32x3', offset: 4, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 15},
          {format: 'unorm16x4', offset: 8, shaderLocation: 1},
          {format: 'float32x4', offset: 20, shaderLocation: 0},
          {format: 'sint16x2', offset: 32, shaderLocation: 13},
          {format: 'snorm8x2', offset: 30, shaderLocation: 6},
        ],
      },
      {arrayStride: 120, attributes: [{format: 'uint32x2', offset: 16, shaderLocation: 11}]},
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: false},
});
try {
computePassEncoder30.setBindGroup(2, bindGroup5);
} catch {}
try {
computePassEncoder29.setBindGroup(0, bindGroup15, new Uint32Array(2337), 184, 0);
} catch {}
try {
renderBundleEncoder25.setBindGroup(2, bindGroup73, new Uint32Array(993), 77, 0);
} catch {}
try {
buffer25.unmap();
} catch {}
try {
commandEncoder60.copyBufferToTexture({
  /* bytesInLastRow: 276 widthInBlocks: 69 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2440 */
  offset: 2440,
  rowsPerImage: 1290,
  buffer: buffer85,
}, {
  texture: texture52,
  mipLevel: 0,
  origin: {x: 45, y: 0, z: 0},
  aspect: 'all',
}, {width: 69, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(26); };
} catch {}
document.body.append(canvas0);
let imageData16 = new ImageData(4, 100);
let buffer116 = device0.createBuffer({size: 520, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder124 = device0.createCommandEncoder({});
let commandBuffer16 = commandEncoder42.finish();
let texture165 = device0.createTexture({
  size: [345, 1, 46],
  mipLevelCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler17 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  lodMaxClamp: 96.52,
});
try {
computePassEncoder32.setBindGroup(1, bindGroup77);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer113, 8); };
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'film', transfer: 'linear'} });
let commandEncoder125 = device0.createCommandEncoder({});
let textureView158 = texture56.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
try {
computePassEncoder9.setBindGroup(3, bindGroup73, new Uint32Array(6026), 67, 0);
} catch {}
try {
commandEncoder124.copyBufferToBuffer(buffer32, 668, buffer107, 12, 0);
} catch {}
let bindGroup87 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 93, resource: textureView1}]});
try {
computePassEncoder28.setBindGroup(3, bindGroup54);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup36, new Uint32Array(300), 43, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer35, 'uint32', 8, 140);
} catch {}
try {
computePassEncoder29.insertDebugMarker('\u0024');
} catch {}
await gc();
let texture166 = device0.createTexture({
  size: [2],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView159 = texture108.createView({label: '\u026a'});
try {
renderBundleEncoder11.setBindGroup(2, bindGroup61);
} catch {}
try {
buffer42.destroy();
} catch {}
let buffer117 = device0.createBuffer({size: 1024, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder126 = device0.createCommandEncoder({});
let computePassEncoder34 = commandEncoder26.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer60, 4); };
} catch {}
try {
computePassEncoder34.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup36, new Uint32Array(6761), 1_004, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer84, 'uint32', 20, 27);
} catch {}
document.body.append(img2);
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderBundleEncoder23.setBindGroup(3, bindGroup26);
} catch {}
let bindGroup88 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]});
let buffer118 = device0.createBuffer({
  size: 56,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder127 = device0.createCommandEncoder();
try {
computePassEncoder32.setBindGroup(0, bindGroup55, new Uint32Array(845), 200, 0);
} catch {}
try {
renderPassEncoder18.setStencilReference(1143);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer4, 'uint16', 0, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer46, 996, new Float32Array(4679).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.2299)), 1599, 284);
} catch {}
let img5 = await imageWithData(76, 10, '#10101010', '#20202020');
let commandEncoder128 = device0.createCommandEncoder({});
try {
computePassEncoder27.setBindGroup(1, bindGroup22, new Uint32Array(3254), 416, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer117, 24); };
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer118, 'uint16', 2, 4);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline24);
} catch {}
document.body.prepend(canvas0);
let bindGroup89 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout12,
  entries: [
    {binding: 65, resource: externalTexture3},
    {binding: 16, resource: {buffer: buffer111}},
    {binding: 4, resource: textureView45},
  ],
});
let commandEncoder129 = device0.createCommandEncoder();
let texture167 = device0.createTexture({
  size: {width: 256, height: 256, depthOrArrayLayers: 19},
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView160 = texture27.createView({aspect: 'all', baseMipLevel: 0});
try {
computePassEncoder32.setBindGroup(1, bindGroup88);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); };
} catch {}
let commandEncoder130 = device0.createCommandEncoder({});
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer23, 20); };
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup21);
} catch {}
let bindGroup90 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 25, resource: {buffer: buffer81}},
    {binding: 239, resource: {buffer: buffer17}},
    {binding: 2, resource: textureView158},
  ],
});
let commandBuffer17 = commandEncoder9.finish();
try {
renderBundleEncoder22.setIndexBuffer(buffer45, 'uint16', 0, 2);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline21);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(0, buffer81, 28, 2);
} catch {}
try {
device0.queue.writeBuffer(buffer47, 4, new DataView(new Uint8Array(16945).map((_, i) => i).buffer), 5150, 4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture120,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 36},
  aspect: 'all',
}, new Uint8Array(555_918).fill(27), /* required buffer size: 555_918 */
{offset: 420, bytesPerRow: 486, rowsPerImage: 9}, {width: 96, height: 0, depthOrArrayLayers: 128});
} catch {}
let bindGroup91 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout11,
  entries: [
    {binding: 3, resource: {buffer: buffer22, size: 348}},
    {binding: 1, resource: textureView76},
    {binding: 2, resource: {buffer: buffer100}},
    {binding: 16, resource: textureView17},
    {binding: 7, resource: textureView79},
  ],
});
try {
renderPassEncoder10.setPipeline(pipeline24);
} catch {}
try {
commandEncoder111.insertDebugMarker('\u8ef4');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture75,
  mipLevel: 0,
  origin: {x: 43, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(181).fill(36), /* required buffer size: 181 */
{offset: 181, rowsPerImage: 4}, {width: 178, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView161 = texture159.createView({});
try {
renderBundleEncoder26.setBindGroup(1, bindGroup4, new Uint32Array(645), 20, 0);
} catch {}
try {
commandEncoder102.resolveQuerySet(querySet2, 0, 0, buffer106, 1792);
} catch {}
let imageData17 = new ImageData(12, 20);
let shaderModule8 = device0.createShaderModule({
  code: `
enable f16;

@group(0) @binding(60) var tex15: texture_multisampled_2d<i32>;

@group(0) @binding(116) var<storage, read_write> buffer121: array<array<array<f16, 46>, 4>>;

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

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

@group(0) @binding(2) var<storage, read_write> buffer119: array<array<array<array<f16, 1>, 3>, 18>>;

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

var<workgroup> vw25: vec4u;

@group(0) @binding(7) var<storage, read> buffer120: array<FragmentOutput7, 12>;

@group(0) @binding(15) var tex14: texture_2d<f32>;

@group(0) @binding(10) var sam10: sampler;

struct FragmentOutput7 {
  @builtin(sample_mask) sample_mask: u32,
  @location(0) @interpolate(perspective, sample) location_0: vec4f,
}

struct FragmentInput17 {
  @location(12) @interpolate(flat, centroid) location_12: u32,
  @location(5) @interpolate(flat, either) location_5: f32,
}

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

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

/* used global variables: st23, tex14, tex15 */
fn fn0() {
  textureStore(st23, unconst_i32(135257574), vec4i(vec4i(unconst_i32(200601611), unconst_i32(194766402), unconst_i32(616324407), unconst_i32(492260522))));
  _ = tex15;
  let vf38: vec2u = textureDimensions(tex14);
  textureStore(st23, unconst_i32(1438152654), vec4i(vec4i(unconst_i32(-9207828), unconst_i32(587368422), unconst_i32(-358000832), unconst_i32(1533278555))));
  let vf39: vec4<bool> = (vec4f(unconst_f32(0.2562e-14), unconst_f32(0.05000e-40), unconst_f32(0.5113e35), unconst_f32(0.03819e-2)) < unpack4x8unorm(textureNumLevels(tex14)));
  textureStore(st23, unconst_i32(155868591), vec4i(vec4i(unconst_i32(-136208690), unconst_i32(64506270), unconst_i32(1390549229), unconst_i32(-515731500))));
  let vf40: u32 = vf38[unconst_u32(251350984)];
  let vf41: u32 = vf40;
  _ = tex15;
  if bool(textureDimensions(tex15).r) {
  textureStore(st23, unconst_i32(547322645), vec4i(vec4i(unconst_i32(-209479507), unconst_i32(20205905), unconst_i32(699388851), unconst_i32(-40177669))));
  let vf42: f16 = step(unconst_f16(184.2), unconst_f16(9490.3));
  textureStore(st23, unconst_i32(24030066), vec4i(vec4i(unconst_i32(-185144303), unconst_i32(140738320), unconst_i32(1070603174), unconst_i32(598853440))));
  textureStore(st23, unconst_i32(198736452), vec4i(vec4i(unconst_i32(2121033184), unconst_i32(545110979), unconst_i32(922751420), unconst_i32(543744065))));
  return;
  _ = st23;
}
  textureStore(st23, unconst_i32(103798022), vec4i(vec4i(unconst_i32(2319336), unconst_i32(135090406), unconst_i32(128516202), unconst_i32(335465463))));
  _ = tex14;
  _ = st23;
  _ = tex15;
}

@group(0) @binding(1) var tex13: texture_depth_2d;

var<workgroup> vw24: atomic<i32>;

@group(0) @binding(3) var st23: texture_storage_1d<rgba16sint, write>;

var<workgroup> vw22: vec2<bool>;

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

struct FragmentOutput8 {
  @location(0) @interpolate(linear) location_0: vec4f,
  @builtin(sample_mask) sample_mask: u32,
  @location(5) location_5: vec4i,
}

@group(0) @binding(158) var st25: texture_storage_3d<r32sint, write>;

var<workgroup> vw23: atomic<i32>;

struct FragmentInput18 {
  @location(1) @interpolate(perspective) location_1: vec4f,
}

struct FragmentInput16 {
  @location(6) location_6: i32,
}

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

struct T0 {
  f0: array<u32>,
}

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

/* used global variables: tex14 */
@vertex
fn vertex6(@location(13) location_13: vec2f) -> @builtin(position) vec4f {
  var out: vec4f;
  _ = tex14;
  return out;
  _ = tex14;
}

/* used global variables: buffer120, et14, st23, st25, tex14, tex15 */
@fragment
fn fragment9(@builtin(sample_index) sample_index: u32, @builtin(front_facing) front_facing: bool, a2: FragmentInput15) -> FragmentOutput7 {
  var out: FragmentOutput7;
  let vf43: i32 = dot(vec2i(unconst_i32(352383682), unconst_i32(224905303)), vec2i(unconst_i32(209040543), unconst_i32(94837066)));
  fn0();
  textureStore(st23, unconst_i32(-290195862), vec4i(vec4i(unconst_i32(922455511), unconst_i32(122438683), unconst_i32(209123981), unconst_i32(-159279534))));
  var vf44: i32 = dot(vec2i(unconst_i32(150281062), unconst_i32(9782984)), vec2i(unconst_i32(25121621), unconst_i32(107433434)));
  while bool(atan(unconst_f16(7660.0))) {
  discard;
  fn0();
  for (var it2=pack4x8unorm(buffer120[unconst_u32(1627184055)].location_0); it2<(pack4x8snorm(buffer120[11].location_0) & 0xfff); it2++) {
  textureStore(st25, vec3i(unconst_i32(-98609587), unconst_i32(198671190), unconst_i32(236434293)), vec4i(vec4i(unconst_i32(72283617), unconst_i32(213452606), unconst_i32(153231797), unconst_i32(356609540))));
  out.location_0 = (*&buffer120)[11].location_0;
  _ = buffer120;
  _ = st25;
}
  textureStore(st23, unconst_i32(-845067666), vec4i(vec4i(unconst_i32(499350624), unconst_i32(504742284), unconst_i32(32219398), unconst_i32(154636165))));
  textureStore(st23, unconst_i32(837518273), vec4i(vec4i(unconst_i32(1158671250), unconst_i32(684397184), unconst_i32(-258427419), unconst_i32(549449454))));
  out.location_0 = buffer120[unconst_u32(85527939)].location_0;
  _ = tex15;
  _ = st23;
  _ = tex14;
  _ = st25;
  _ = buffer120;
}
  let vf45: f32 = buffer120[unconst_u32(372612533)].location_0[unconst_u32(36264063)];
  fn0();
  let ptr60: ptr<storage, array<FragmentOutput7, 12>, read> = &(*&buffer120);
  fn0();
  vf44 += insertBits(vec3i(unconst_i32(550388799), unconst_i32(147551262), unconst_i32(127336244)), bitcast<vec3i>(textureDimensions(et14).rgg), u32((*ptr60)[unconst_u32(393448472)].location_0[unconst_u32(313396283)]), textureDimensions(tex15)[0])[1];
  fn0();
  return out;
  _ = tex14;
  _ = st23;
  _ = et14;
  _ = st25;
  _ = tex15;
  _ = buffer120;
}

/* used global variables: buffer120, st23, tex14, tex15 */
@fragment
fn fragment10(@location(11) @interpolate(flat) location_11: vec4i, @location(8) @interpolate(flat, first) location_8: vec2u, a2: FragmentInput16, a3: FragmentInput17, a4: FragmentInput18) -> FragmentOutput8 {
  var out: FragmentOutput8;
  let ptr61: ptr<storage, vec4f, read> = &buffer120[unconst_u32(703424580)].location_0;
  var vf46: f32 = (*&buffer120)[(*&buffer120)[unconst_u32(1541729523)].sample_mask].location_0[unconst_u32(94214303)];
  if bool((*&buffer120)[unconst_u32(263638043)].sample_mask) {
  let ptr62: ptr<storage, array<FragmentOutput7, 12>, read> = &buffer120;
  fn0();
  let ptr63: ptr<storage, array<FragmentOutput7, 12>, read> = &(*&buffer120);
  let ptr64: ptr<storage, vec4f, read> = &buffer120[unconst_u32(615521613)].location_0;
  _ = tex14;
  _ = tex15;
  _ = st23;
  _ = buffer120;
}
  loop {
  let ptr65: ptr<function, vec4f> = &out.location_0;
  out.sample_mask -= pack4x8snorm((*&buffer120)[11].location_0);
  if bool(textureNumLevels(tex14)) {
  fn0();
  _ = tex14;
  _ = tex15;
  _ = st23;
}
  break;
  _ = tex15;
  _ = tex14;
  _ = buffer120;
  _ = st23;
}
  return out;
  _ = st23;
  _ = tex15;
  _ = tex14;
  _ = buffer120;
}

/* used global variables: buffer119, buffer121, sam10, st23, tex13, tex14, tex15 */
@compute @workgroup_size(1, 1, 1)
fn compute7(a0: ComputeInput8) {
  var vf47: vec4f = fma(vec4f(unconst_f32(0.01851e19), unconst_f32(0.6764), unconst_f32(0.07537), unconst_f32(0.1363e1)), vec4f(unconst_f32(0.2070), unconst_f32(0.1325), unconst_f32(-0.04097e35), unconst_f32(0.3198)), vec4f(unconst_f32(0.03020e-37), unconst_f32(0.06281), unconst_f32(-0.09973), unconst_f32(0.03530e-39)));
  fn0();
  textureStore(st23, unconst_i32(46991744), vec4i(vec4i(i32(vw22[u32(buffer121[arrayLength(&buffer121)][3][unconst_u32(82715308)])]))));
  switch atomicLoad(&vw24) { 
  default {
  fn0();
  atomicOr(&vw23, i32((*&buffer119)[arrayLength(&(*&buffer119))][unconst_u32(302968274)][unconst_u32(850018728)][0]));
  for (var jj4=0u; jj4<20; jj4++) { for (var jj6=0u; jj6<3; jj6++) { buffer119[unconst_u32(1613275247)][jj4][unconst_u32(335014650)][jj6] = f16(arrayLength(&(*&buffer119))); } }
  for (var ii4=0u; ii4<0x1000; ii4+=0x11) { for (var jj27=0u; jj27<20; jj27++) { for (var jj82=0u; jj82<3; jj82++) { buffer119[ii4][jj27][unconst_u32(510473887)][jj82] *= (*&buffer121)[arrayLength(&(*&buffer121))][bitcast<u32>(textureSampleLevel(tex13, sam10, vec2f(bitcast<f32>(atomicExchange(&(*&vw23), unconst_i32(-190860862)))), unconst_i32(158219427)))][45]; } } }
  let ptr66: ptr<storage, f16, read_write> = &(*&buffer121)[arrayLength(&(*&buffer121))][3][unconst_u32(3334477740)];
  return;
  _ = tex13;
  _ = buffer121;
  _ = tex15;
  _ = st23;
  _ = tex14;
  _ = sam10;
  _ = buffer119;
}
  }
  textureStore(st23, unconst_i32(7462161), vec4i(vec4i(unconst_i32(802776941), unconst_i32(1478641072), unconst_i32(461407004), unconst_i32(572960742))));
  let ptr67: ptr<storage, array<array<array<f16, 1>, 3>, 18>, read_write> = &buffer119[unconst_u32(266238168)];
  _ = tex14;
  _ = st23;
  _ = tex13;
  _ = buffer121;
  _ = buffer119;
  _ = tex15;
  _ = sam10;
}

/* used global variables: buffer119, buffer121, st23, tex14, tex15 */
@compute @workgroup_size(2, 1, 1)
fn compute8() {
  buffer119[unconst_u32(528187122)][unconst_u32(281405273)][unconst_u32(407669089)][unconst_u32(171782565)] = f16(arrayLength(&buffer121));
  buffer121[unconst_u32(589716621)][unconst_u32(145161861)][unconst_u32(114337289)] = (*&buffer119)[arrayLength(&(*&buffer119))][unconst_u32(105005836)][2][0];
  vw25 = unpack4xU8(u32(buffer121[unconst_u32(689400235)][3][unconst_u32(296827977)]));
  let ptr68: ptr<storage, f16, read_write> = &(*&buffer121)[arrayLength(&(*&buffer121))][unconst_u32(654045905)][45];
  fn0();
  let ptr69: ptr<storage, f16, read_write> = &(*&buffer119)[unconst_u32(88215760)][u32(buffer119[arrayLength(&buffer119)][unconst_u32(1041150117)][2][0])][unconst_u32(93927710)][0];
  buffer121[unconst_u32(447540459)][u32((*&buffer119)[arrayLength(&(*&buffer119))][unconst_u32(508012154)][2][unconst_u32(100701592)])][unconst_u32(1117704754)] = f16(atan2(unconst_f32(0.6058e-44), unconst_f32(0.01971e-36)));
  fn0();
  buffer119[unconst_u32(795180449)][pack4xU8(bitcast<vec4u>(textureLoad(tex14, vec2i(unconst_i32(8003183), unconst_i32(542563682)), unconst_i32(378728917)).abaa.raab))][2][unconst_u32(125786150)] = buffer121[arrayLength(&buffer121)][3][unconst_u32(556386543)];
  fn0();
  atomicExchange(&vw24, unconst_i32(467469745));
  let ptr70: ptr<workgroup, vec2<bool>> = &(*&vw22);
  return;
  _ = st23;
  _ = buffer119;
  _ = tex15;
  _ = tex14;
  _ = buffer121;
}`,
});
let bindGroup92 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 93, resource: textureView1}]});
let renderPassEncoder20 = commandEncoder92.beginRenderPass({
  colorAttachments: [{
  view: textureView77,
  clearValue: { r: 885.4, g: -128.2, b: -891.0, a: 930.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder31.setBindGroup(2, bindGroup68);
} catch {}
try {
renderPassEncoder8.setStencilReference(302);
} catch {}
let buffer122 = device0.createBuffer({size: 161, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false});
try {
computePassEncoder26.setBindGroup(3, bindGroup69, new Uint32Array(2400), 996, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer23, 12); };
} catch {}
try {
computePassEncoder22.end();
} catch {}
try {
renderPassEncoder11.setVertexBuffer(7, buffer76);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(3, buffer6);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(63); };
} catch {}
let commandEncoder131 = device0.createCommandEncoder({});
try {
computePassEncoder30.pushDebugGroup('\u{1fb42}');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer57, 124, new Float16Array(13664).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.935)), 145, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline29 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule6}});
let buffer123 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(3, 1); };
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup22);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(3, buffer38);
} catch {}
try {
device0.queue.submit([commandBuffer16]);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(9); };
} catch {}
let bindGroup93 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout23,
  entries: [
    {binding: 2, resource: {buffer: buffer7}},
    {binding: 158, resource: textureView37},
    {binding: 10, resource: sampler1},
    {binding: 227, resource: textureView20},
    {binding: 8, resource: externalTexture12},
    {binding: 15, resource: textureView158},
    {binding: 1, resource: textureView17},
    {binding: 116, resource: {buffer: buffer81}},
    {binding: 0, resource: externalTexture12},
    {binding: 4, resource: sampler2},
    {binding: 60, resource: textureView97},
    {binding: 3, resource: textureView99},
    {binding: 17, resource: textureView92},
    {binding: 7, resource: {buffer: buffer81}},
  ],
});
let sampler18 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  compare: 'equal',
  maxAnisotropy: 9,
});
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer101, 52); };
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline24);
} catch {}
try {
device0.queue.writeBuffer(buffer47, 4, new Float32Array(15100).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.652)), 4702, 0);
} catch {}
let buffer124 = device0.createBuffer({
  size: 64,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder132 = device0.createCommandEncoder({});
let computePassEncoder35 = commandEncoder106.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer1, 16); };
} catch {}
try {
computePassEncoder35.setPipeline(pipeline7);
} catch {}
try {
buffer86.unmap();
} catch {}
try {
  await promise17;
} catch {}
let texture168 = device0.createTexture({
  size: {width: 1656},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder20.setIndexBuffer(buffer36, 'uint16', 2, 0);
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup87, new Uint32Array(1164), 841, 0);
} catch {}
try {
buffer29.unmap();
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'pq'} });
let commandBuffer18 = commandEncoder32.finish();
let texture169 = device0.createTexture({
  size: {width: 1, height: 1, depthOrArrayLayers: 4},
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder34.setBindGroup(1, bindGroup32);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer113, 0); };
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer57, 'uint16', 44, 22);
} catch {}
let arrayBuffer11 = buffer61.getMappedRange(120, 8);
try {
computePassEncoder30.popDebugGroup();
} catch {}
document.body.append(canvas0);
let veryExplicitBindGroupLayout30 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 3,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '1d' },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 7,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 8, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {binding: 10, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
    {
      binding: 17,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 60,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {
      binding: 116,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 158,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 227,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let buffer125 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let texture170 = device0.createTexture({
  size: {width: 345, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer26, 8); };
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup25);
} catch {}
let arrayBuffer12 = buffer61.getMappedRange(128, 0);
let bindGroup94 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout27,
  entries: [
    {binding: 239, resource: {buffer: buffer27}},
    {binding: 25, resource: {buffer: buffer101}},
    {binding: 2, resource: textureView14},
  ],
});
let texture171 = device0.createTexture({
  size: [828, 1, 59],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler19 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 78.34,
  maxAnisotropy: 12,
});
try {
computePassEncoder12.setBindGroup(0, bindGroup8, new Uint32Array(1671), 64, 0);
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup74, new Uint32Array(590), 71, 0);
} catch {}
try {
buffer59.unmap();
} catch {}
try {
commandEncoder58.copyBufferToBuffer(buffer125, 0, buffer32, 204, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer2, 28, new Float64Array(13311).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/13311)), 5045, 0);
} catch {}
let buffer126 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let texture172 = device0.createTexture({size: [2760, 1, 1], mipLevelCount: 4, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
device0.queue.writeTexture({
  texture: texture97,
  mipLevel: 0,
  origin: {x: 164, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(262).fill(220), /* required buffer size: 262 */
{offset: 262}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1380, height: 1, depthOrArrayLayers: 3}
*/
{
  source: videoFrame11,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(50); };
} catch {}
document.body.append(canvas1);
await gc();
try {
computePassEncoder33.setBindGroup(3, bindGroup56, []);
} catch {}
try {
computePassEncoder12.setBindGroup(1, bindGroup18, new Uint32Array(3347), 1_272, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(2, 1); };
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup58, new Uint32Array(4207), 104, 0);
} catch {}
try {
renderPassEncoder0.setStencilReference(869);
} catch {}
try {
commandEncoder80.insertDebugMarker('\u3b57');
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let textureView162 = texture170.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder24.setBindGroup(2, bindGroup22);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer115, 20); };
} catch {}
try {
computePassEncoder5.end();
} catch {}
try {
renderPassEncoder14.setVertexBuffer(5, buffer62, 0, 20);
} catch {}
try {
commandEncoder25.copyTextureToTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 381, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture166,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder86.resolveQuerySet(querySet0, 363, 1, buffer7, 0);
} catch {}
let buffer127 = device0.createBuffer({size: 108, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder133 = device0.createCommandEncoder();
try {
computePassEncoder26.setBindGroup(2, bindGroup57, new Uint32Array(1003), 1, 0);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(7, buffer107, 200, 11);
} catch {}
try {
renderBundleEncoder21.setIndexBuffer(buffer118, 'uint32', 4, 10);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(1, buffer65);
} catch {}
await gc();
let buffer128 = device0.createBuffer({size: 56, usage: GPUBufferUsage.STORAGE});
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1, 3); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer125, 0); };
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
buffer115.unmap();
} catch {}
let bindGroup95 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout5,
  entries: [
    {binding: 2, resource: textureView80},
    {binding: 239, resource: {buffer: buffer22, size: 80}},
    {binding: 25, resource: {buffer: buffer25, size: 48}},
  ],
});
let texture173 = device0.createTexture({
  size: [8],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
commandEncoder47.copyTextureToTexture({
  texture: texture65,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture138,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 6},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder112.clearBuffer(buffer62);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.submit([commandBuffer18, commandBuffer17]);
} catch {}
let veryExplicitBindGroupLayout31 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 0,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 2,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 3, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 8,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 14,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
    {binding: 18, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 49,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '1d' },
    },
    {binding: 62, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }},
    {
      binding: 92,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 211,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 222,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 234,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 416,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '2d-array' },
    },
  ],
});
let textureView163 = texture123.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder36 = commandEncoder127.beginComputePass();
try {
renderPassEncoder1.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer45, 0, 22);
} catch {}
let bindGroup96 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout21,
  entries: [
    {binding: 4, resource: textureView87},
    {binding: 73, resource: {buffer: buffer46, offset: 0}},
    {binding: 0, resource: {buffer: buffer128, offset: 0}},
    {binding: 154, resource: textureView91},
  ],
});
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer1, 0); };
} catch {}
try {
computePassEncoder12.end();
} catch {}
try {
computePassEncoder36.setPipeline(pipeline0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; });
} catch {}
let veryExplicitBindGroupLayout32 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let texture174 = device0.createTexture({
  size: {width: 2},
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder34.setPipeline(pipeline9);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer124, 'uint32', 4, 14);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(3, buffer95, 0);
} catch {}
try {
buffer96.unmap();
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
try {
  await promise19;
} catch {}
let commandEncoder134 = device0.createCommandEncoder({});
let commandBuffer19 = commandEncoder16.finish();
let textureView164 = texture30.createView({mipLevelCount: 1});
try {
renderPassEncoder10.setPipeline(pipeline24);
} catch {}
let imageData18 = new ImageData(12, 20);
try {
computePassEncoder32.setBindGroup(0, bindGroup1);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer23, 4); };
} catch {}
try {
computePassEncoder33.end();
} catch {}
try {
computePassEncoder28.setPipeline(pipeline29);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer55, 'uint16', 30, 6);
} catch {}
await gc();
let buffer129 = device0.createBuffer({
  size: 362,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
let commandEncoder135 = device0.createCommandEncoder({});
let textureView165 = texture38.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroups(2, 2, 1); };
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, buffer84, 32, 12);
} catch {}
let offscreenCanvas4 = new OffscreenCanvas(7, 289);
let commandEncoder136 = device0.createCommandEncoder({});
let texture175 = device0.createTexture({
  size: [414, 1, 4],
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder37 = commandEncoder97.beginComputePass();
try {
renderPassEncoder0.setBindGroup(0, bindGroup30);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer124, 'uint32', 8, 29);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup67, new Uint32Array(609), 199, 0);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer4, 'uint32', 0, 1);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(6, buffer95, 36, 48);
} catch {}
try {
commandEncoder133.copyBufferToBuffer(buffer75, 4, buffer36, 4, 0);
} catch {}
let commandBuffer20 = commandEncoder29.finish();
let textureView166 = texture116.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1});
try {
renderBundleEncoder10.setBindGroup(3, bindGroup11);
} catch {}
let commandEncoder137 = device0.createCommandEncoder({});
try {
renderPassEncoder17.setVertexBuffer(0, buffer35, 48, 35);
} catch {}
try {
buffer115.unmap();
} catch {}
try {
commandEncoder104.copyTextureToTexture({
  texture: texture44,
  mipLevel: 1,
  origin: {x: 71, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture82,
  mipLevel: 0,
  origin: {x: 65, y: 0, z: 0},
  aspect: 'all',
},
{width: 43, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
computePassEncoder37.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(1, buffer26);
} catch {}
try {
device0.queue.writeBuffer(buffer32, 8, new DataView(new ArrayBuffer(108416)), 284, 32);
} catch {}
let pipeline30 = await promise15;
let buffer130 = device0.createBuffer({size: 248, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let commandEncoder138 = device0.createCommandEncoder({});
try {
computePassEncoder32.setBindGroup(1, bindGroup25);
} catch {}
try {
computePassEncoder32.setBindGroup(0, bindGroup24, new Uint32Array(234), 84, 0);
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet1, 200, 2, buffer99, 0);
} catch {}
document.body.prepend(canvas0);
let computePassEncoder38 = commandEncoder101.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder9.end();
} catch {}
try {
computePassEncoder38.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline24);
} catch {}
let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'film', transfer: 'linear'} });
try {
globalThis.someLabel = externalTexture11.label;
} catch {}
try {
computePassEncoder36.setBindGroup(1, bindGroup40, new Uint32Array(1823), 15, 0);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(5, buffer58);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer102, 'uint16', 32, 143);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(2, buffer3, 0);
} catch {}
let buffer131 = device0.createBuffer({
  size: 184,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer32, 20); };
} catch {}
try {
computePassEncoder32.end();
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer4, 'uint16', 0, 0);
} catch {}
let imageData19 = new ImageData(32, 8);
let commandEncoder139 = device0.createCommandEncoder({});
let texture176 = device0.createTexture({
  size: {width: 414, height: 1, depthOrArrayLayers: 51},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView167 = texture115.createView({mipLevelCount: 1, baseArrayLayer: 20, arrayLayerCount: 7});
try {
renderBundleEncoder27.setIndexBuffer(buffer55, 'uint16', 18, 1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture142,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(102).fill(43), /* required buffer size: 102 */
{offset: 102}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise20 = device0.queue.onSubmittedWorkDone();
try {
adapter1.label = '\uac77\u1d70';
} catch {}
let veryExplicitBindGroupLayout33 = device0.createBindGroupLayout({
  entries: [
    {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
    {binding: 7, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 18,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 301, visibility: 0, buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }},
    {
      binding: 362,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer107, 8, new Uint32Array(2303).map((_, i) => i * 9), 23, 0);
} catch {}
let commandEncoder140 = device0.createCommandEncoder({});
try {
computePassEncoder38.setBindGroup(2, bindGroup86, new Uint32Array(190), 13, 2);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder30.dispatchWorkgroupsIndirect(buffer36, 4);
} catch {}
try {
renderBundleEncoder24.setIndexBuffer(buffer35, 'uint16', 118, 54);
} catch {}
let imageData20 = new ImageData(32, 12);
let commandEncoder141 = device0.createCommandEncoder({});
try {
renderBundleEncoder23.setIndexBuffer(buffer124, 'uint16', 6, 4);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer63, 44, new Float32Array(2833).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.589)), 362, 0);
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let offscreenCanvas5 = new OffscreenCanvas(291, 55);
let buffer132 = device0.createBuffer({size: 84, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder142 = device0.createCommandEncoder({});
let texture177 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 1196},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder27.setBindGroup(0, bindGroup23);
} catch {}
try {
computePassEncoder37.setBindGroup(0, bindGroup83, new Uint32Array(1498), 422, 2);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(2); };
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer80, 'uint16', 8, 36);
} catch {}
try {
device0.queue.writeBuffer(buffer30, 12, new Float32Array(1927).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.799)), 317, 8);
} catch {}
let gpuCanvasContext5 = offscreenCanvas5.getContext('webgpu');
try {
gpuCanvasContext2.unconfigure();
} catch {}
document.body.append(canvas0);
await gc();
let texture178 = device0.createTexture({
  size: [345],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup30, new Uint32Array(1724), 151, 0);
} catch {}
let arrayBuffer13 = buffer61.getMappedRange(136, 4);
try {
  await buffer112.mapAsync(GPUMapMode.READ, 0, 0);
} catch {}
let computePassEncoder39 = commandEncoder43.beginComputePass();
try {
computePassEncoder26.setBindGroup(2, bindGroup12, new Uint32Array(2726), 187, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer97);
} catch {}
let gpuCanvasContext6 = offscreenCanvas4.getContext('webgpu');
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
  await promise20;
} catch {}
let autogeneratedBindGroupLayout9 = pipeline26.getBindGroupLayout(0);
let commandEncoder143 = device0.createCommandEncoder({});
let externalTexture23 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder27.end();
} catch {}
try {
computePassEncoder39.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup92, new Uint32Array(1711), 257, 0);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer24, 'uint32', 20, 37);
} catch {}
try {
device0.queue.writeBuffer(buffer113, 4, new DataView(new ArrayBuffer(20876)), 208, 0);
} catch {}
let texture179 = device0.createTexture({size: {width: 414}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.COPY_DST});
try {
renderPassEncoder11.setBindGroup(1, bindGroup94, []);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer84, 'uint32', 60, 19);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(5, buffer132, 0, 8);
} catch {}
document.body.append(canvas0);
try {
computePassEncoder28.setBindGroup(2, bindGroup41);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup84);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(6, buffer23);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline24);
} catch {}
try {
buffer62.unmap();
} catch {}
await gc();
let bindGroup97 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout6,
  entries: [
    {binding: 0, resource: {buffer: buffer22, size: 272}},
    {binding: 2, resource: textureView125},
    {binding: 38, resource: textureView85},
  ],
});
let buffer133 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandBuffer21 = commandEncoder53.finish();
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer81, 192, 59);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(6, buffer62, 0, 78);
} catch {}
let textureView168 = texture21.createView({dimension: '2d-array', mipLevelCount: 1});
let externalTexture24 = device0.importExternalTexture({source: videoFrame17, colorSpace: 'srgb'});
try {
renderPassEncoder10.setVertexBuffer(0, buffer38, 0);
} catch {}
try {
renderBundleEncoder26.setPipeline(pipeline30);
} catch {}
let commandEncoder144 = device0.createCommandEncoder();
let texture180 = device0.createTexture({
  size: [8],
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler20 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.16,
  compare: 'never',
  maxAnisotropy: 8,
});
try {
computePassEncoder16.setBindGroup(0, bindGroup21);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup54);
} catch {}
try {
commandEncoder31.copyTextureToBuffer({
  texture: texture106,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 296 widthInBlocks: 37 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1600 */
  offset: 1600,
  buffer: buffer46,
}, {width: 37, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer21, commandBuffer20]);
} catch {}
await gc();
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(2); };
} catch {}
try {
querySet0.destroy();
} catch {}
try {
  await buffer75.mapAsync(GPUMapMode.WRITE);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let commandEncoder145 = device0.createCommandEncoder({});
try {
computePassEncoder35.setBindGroup(0, bindGroup81, [0, 0]);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer60, 'uint32', 4, 0);
} catch {}
try {
commandEncoder80.clearBuffer(buffer5);
} catch {}
document.body.append(img3);
let buffer134 = device0.createBuffer({size: 216, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let texture181 = device0.createTexture({
  size: [414, 1, 21],
  mipLevelCount: 4,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder40 = commandEncoder118.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder40.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup33, new Uint32Array(428), 183, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer96, 'uint16', 32, 28);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(1, buffer58);
} catch {}
let commandEncoder146 = device0.createCommandEncoder();
let texture182 = device0.createTexture({
  size: {width: 2760, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler21 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
});
let externalTexture25 = device0.importExternalTexture({source: videoFrame13});
try {
renderPassEncoder7.setBindGroup(2, bindGroup80, new Uint32Array(4468), 455, 0);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer102, 'uint16', 106, 3);
} catch {}
try {
commandEncoder129.copyBufferToBuffer(buffer127, 44, buffer25, 28, 8);
} catch {}
try {
gpuCanvasContext5.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, colorSpace: 'srgb'});
} catch {}
let buffer135 = device0.createBuffer({size: 251, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder30.end();
} catch {}
try {
renderPassEncoder15.setVertexBuffer(3, buffer23, 8);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup11, new Uint32Array(1734), 225, 0);
} catch {}
let arrayBuffer14 = buffer61.getMappedRange(144, 0);
try {
buffer110.unmap();
} catch {}
let img6 = await imageWithData(10, 4, '#10101010', '#20202020');
let commandEncoder147 = device0.createCommandEncoder({});
try {
computePassEncoder31.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline24);
} catch {}
let veryExplicitBindGroupLayout34 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 1,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 14,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 21,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 242,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let buffer136 = device0.createBuffer({size: 36, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
try {
computePassEncoder35.setBindGroup(1, bindGroup60);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder39.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder10.setBindGroup(2, bindGroup91, new Uint32Array(2551), 349, 0);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline21);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let buffer137 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT});
let texture183 = device0.createTexture({
  size: [1656, 1, 17],
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView169 = texture8.createView({dimension: '3d'});
try {
renderPassEncoder19.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer35, 0);
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup87, new Uint32Array(704), 353, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let imageData21 = new ImageData(8, 12);
let bindGroup98 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout16,
  entries: [
    {binding: 1, resource: textureView44},
    {binding: 3, resource: {buffer: buffer79}},
    {binding: 16, resource: textureView45},
    {binding: 2, resource: {buffer: buffer61}},
    {binding: 7, resource: textureView21},
  ],
});
let commandBuffer22 = commandEncoder14.finish({});
let textureView170 = texture183.createView({});
let texture184 = device0.createTexture({
  size: {width: 4, height: 4, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder28.setBindGroup(2, bindGroup1, new Uint32Array(2678), 116, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup10, new Uint32Array(1516), 507, 0);
} catch {}
try {
renderBundleEncoder19.setBindGroup(3, bindGroup29);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(0, buffer6, 56, 3);
} catch {}
try {
commandEncoder84.copyTextureToBuffer({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 70, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 312 */
  offset: 312,
  buffer: buffer129,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img6);
let buffer138 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST});
try {
computePassEncoder28.setBindGroup(3, bindGroup81, new Uint32Array(1950), 106, 2);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer36, 0); };
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer4, 'uint32', 0, 0);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup30);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 690, height: 1, depthOrArrayLayers: 43}
*/
{
  source: offscreenCanvas4,
  origin: { x: 0, y: 72 },
  flipY: true,
}, {
  texture: texture135,
  mipLevel: 2,
  origin: {x: 109, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup99 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout24,
  entries: [
    {binding: 73, resource: {buffer: buffer46, offset: 0}},
    {binding: 154, resource: textureView103},
    {binding: 0, resource: {buffer: buffer100}},
    {binding: 4, resource: textureView156},
  ],
});
let commandEncoder148 = device0.createCommandEncoder({});
let texture185 = device0.createTexture({
  size: {width: 2, height: 2, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView171 = texture75.createView({});
try {
renderPassEncoder6.setVertexBuffer(3, buffer38, 0, 6);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder109.copyBufferToBuffer(buffer59, 0, buffer87, 0, 0);
} catch {}
try {
renderBundleEncoder16.insertDebugMarker('\u{1fc8c}');
} catch {}
let promise21 = device0.queue.onSubmittedWorkDone();
let renderPassEncoder21 = commandEncoder110.beginRenderPass({
  colorAttachments: [{
  view: textureView158,
  clearValue: { r: -738.8, g: 563.5, b: -931.9, a: -482.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet1,
});
try {
computePassEncoder37.setBindGroup(0, bindGroup85, [0, 0]);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(2); };
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 316 widthInBlocks: 79 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1412 */
  offset: 1412,
  bytesPerRow: 11776,
  rowsPerImage: 2904,
  buffer: buffer85,
}, {
  texture: texture129,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {width: 79, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise22 = device0.queue.onSubmittedWorkDone();
let buffer139 = device0.createBuffer({size: 16, usage: GPUBufferUsage.UNIFORM});
let commandEncoder149 = device0.createCommandEncoder({});
let computePassEncoder41 = commandEncoder115.beginComputePass();
try {
computePassEncoder41.setPipeline(pipeline29);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup84);
} catch {}
try {
  await promise21;
} catch {}
try {
externalTexture15.label = '\u{1fcba}\uda2a\uffe6\u{1f793}\u{1f84e}\u052b\ua95b\u6654\uc0f6\ucd68';
} catch {}
let texture186 = device0.createTexture({
  size: [1656, 1, 437],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16uint'],
});
try {
computePassEncoder35.setBindGroup(3, bindGroup9, new Uint32Array(2038), 499, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer117, 4); };
} catch {}
try {
renderBundleEncoder22.setIndexBuffer(buffer84, 'uint16', 18, 8);
} catch {}
try {
computePassEncoder37.end();
} catch {}
let arrayBuffer15 = buffer61.getMappedRange(152, 0);
let bindGroup100 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout2,
  entries: [
    {binding: 153, resource: {buffer: buffer15}},
    {binding: 116, resource: textureView2},
    {binding: 0, resource: textureView22},
    {binding: 49, resource: {buffer: buffer74, size: 48}},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 5, resource: externalTexture9},
    {binding: 3, resource: textureView0},
    {binding: 312, resource: sampler20},
    {binding: 159, resource: sampler13},
    {binding: 7, resource: {buffer: buffer61}},
    {binding: 59, resource: {buffer: buffer15}},
    {binding: 2, resource: externalTexture11},
    {binding: 308, resource: textureView73},
    {binding: 4, resource: {buffer: buffer116}},
    {binding: 17, resource: externalTexture25},
    {binding: 1, resource: {buffer: buffer131, size: 48}},
    {binding: 61, resource: textureView8},
    {binding: 109, resource: textureView94},
    {binding: 524, resource: textureView85},
  ],
});
try {
computePassEncoder38.setBindGroup(2, bindGroup91);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer23, 8); };
} catch {}
try {
computePassEncoder24.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer118, 0, 21);
} catch {}
try {
renderBundleEncoder1.setIndexBuffer(buffer129, 'uint16', 90, 56);
} catch {}
try {
buffer122.unmap();
} catch {}
let promise23 = device0.queue.onSubmittedWorkDone();
let texture187 = device0.createTexture({
  size: [2],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder36.setBindGroup(0, bindGroup55);
} catch {}
try {
renderBundleEncoder27.setIndexBuffer(buffer102, 'uint16', 14, 58);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder41.setPipeline(pipeline26);
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline24);
} catch {}
try {
device0.queue.submit([commandBuffer22]);
} catch {}
document.body.append(img6);
let computePassEncoder42 = commandEncoder112.beginComputePass();
try {
computePassEncoder42.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup28);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer4, 'uint32', 4, 0);
} catch {}
let pipeline31 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4, entryPoint: 'compute3'}});
try {
  await promise22;
} catch {}
let buffer140 = device0.createBuffer({size: 100, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false});
let commandEncoder150 = device0.createCommandEncoder({});
let textureView172 = texture183.createView({});
let texture188 = device0.createTexture({
  size: [828, 1, 103],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16sint'],
});
let sampler22 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 94.24,
  compare: 'not-equal',
});
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroupsIndirect(buffer137, 40); };
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline30);
} catch {}
try {
buffer104.unmap();
} catch {}
try {
commandEncoder38.copyTextureToTexture({
  texture: texture54,
  mipLevel: 0,
  origin: {x: 114, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture124,
  mipLevel: 0,
  origin: {x: 98, y: 0, z: 0},
  aspect: 'all',
},
{width: 51, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'standard'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer87, 0, new Uint32Array(222).map((_, i) => i * 3), 89, 0);
} catch {}
let commandEncoder151 = device0.createCommandEncoder({});
let texture189 = device0.createTexture({
  size: [1, 1, 146],
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView173 = texture171.createView({baseArrayLayer: 3, arrayLayerCount: 9});
try {
computePassEncoder40.setBindGroup(0, bindGroup70, [0, 0]);
} catch {}
try {
computePassEncoder35.end();
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup58, new Uint32Array(914), 26, 0);
} catch {}
let arrayBuffer16 = buffer61.getMappedRange(160, 0);
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  toneMapping: {mode: 'extended'},
});
} catch {}
try {
device0.queue.writeBuffer(buffer137, 76, new DataView(new ArrayBuffer(40836)), 1755, 0);
} catch {}
let bindGroup101 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout26,
  entries: [
    {binding: 2, resource: textureView35},
    {binding: 239, resource: {buffer: buffer87}},
    {binding: 25, resource: {buffer: buffer46, offset: 0, size: 632}},
  ],
});
let textureView174 = texture180.createView({});
try {
{ clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder21.setBindGroup(1, bindGroup79);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(1, buffer26, 4, 6);
} catch {}
let commandBuffer23 = commandEncoder88.finish();
let texture190 = device0.createTexture({
  size: {width: 414, height: 1, depthOrArrayLayers: 109},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder43 = commandEncoder103.beginComputePass();
try {
computePassEncoder31.setBindGroup(3, bindGroup69, new Uint32Array(37), 8, 0);
} catch {}
try {
buffer18.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer129, 124, new BigInt64Array(38234).map((_, i) => BigInt(i - 6)), 3501, 8);
} catch {}
let bindGroup102 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout34,
  entries: [
    {binding: 117, resource: textureView98},
    {binding: 242, resource: textureView76},
    {binding: 1, resource: {buffer: buffer46}},
    {binding: 21, resource: textureView23},
    {binding: 14, resource: textureView93},
  ],
});
let texture191 = device0.createTexture({
  size: {width: 2760, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  sampleCount: 1,
  dimension: '2d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder44 = commandEncoder141.beginComputePass();
try {
computePassEncoder36.end();
} catch {}
try {
computePassEncoder44.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(1, buffer97, 0);
} catch {}
let veryExplicitBindGroupLayout35 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 16,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let buffer141 = device0.createBuffer({size: 40, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false});
let commandEncoder152 = device0.createCommandEncoder({label: '\ue907\u{1f6d6}\u{1ffcb}\u00f0\u1ecc\u2679\u09c7\u0479\u8c0d'});
let texture192 = device0.createTexture({size: {width: 256}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.COPY_SRC});
try {
{ clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder43.setPipeline(pipeline20);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(2, buffer76, 0);
} catch {}
try {
commandEncoder40.clearBuffer(buffer117);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let offscreenCanvas6 = new OffscreenCanvas(191, 96);
let bindGroup103 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout7,
  entries: [
    {binding: 153, resource: {buffer: buffer46, offset: 256}},
    {binding: 7, resource: {buffer: buffer15, size: 236}},
    {binding: 0, resource: textureView160},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 312, resource: sampler18},
    {binding: 1, resource: {buffer: buffer84}},
    {binding: 3, resource: textureView28},
    {binding: 59, resource: {buffer: buffer116}},
    {binding: 308, resource: textureView130},
    {binding: 2, resource: externalTexture15},
    {binding: 17, resource: externalTexture7},
    {binding: 159, resource: sampler1},
    {binding: 524, resource: textureView35},
    {binding: 5, resource: externalTexture2},
    {binding: 49, resource: {buffer: buffer36}},
    {binding: 109, resource: textureView159},
    {binding: 61, resource: textureView9},
    {binding: 4, resource: {buffer: buffer81}},
    {binding: 116, resource: textureView4},
  ],
});
let texture193 = device0.createTexture({size: [828, 1, 120], mipLevelCount: 4, format: 'rgba16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
try {
{ clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer117, 76); };
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(457);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(7, buffer111);
} catch {}
let gpuCanvasContext7 = offscreenCanvas6.getContext('webgpu');
let textureView175 = texture132.createView({aspect: 'all', baseMipLevel: 0});
let computePassEncoder45 = commandEncoder130.beginComputePass();
try {
computePassEncoder40.setBindGroup(0, bindGroup85, [0, 0]);
} catch {}
try {
computePassEncoder43.setBindGroup(0, bindGroup83, new Uint32Array(918), 118, 2);
} catch {}
try {
computePassEncoder45.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer118, 'uint16', 0, 9);
} catch {}
try {
renderBundleEncoder28.setVertexBuffer(6, buffer26, 0, 16);
} catch {}
try {
buffer55.unmap();
} catch {}
try {
adapter1.label = '\u{1f69b}\u0cd4\u0615\u0925\u0e27\u{1f757}';
} catch {}
let bindGroup104 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout27,
  entries: [
    {binding: 25, resource: {buffer: buffer128}},
    {binding: 239, resource: {buffer: buffer132}},
    {binding: 2, resource: textureView80},
  ],
});
let texture194 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder17.setIndexBuffer(buffer35, 'uint16', 70, 127);
} catch {}
try {
renderBundleEncoder19.setBindGroup(3, bindGroup22);
} catch {}
try {
renderBundleEncoder2.setBindGroup(3, bindGroup10, new Uint32Array(2122), 1_281, 0);
} catch {}
try {
commandEncoder95.resolveQuerySet(querySet2, 0, 0, buffer7, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
  toneMapping: {mode: 'extended'},
});
} catch {}
let buffer142 = device0.createBuffer({size: 288, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let texture195 = device0.createTexture({
  size: {width: 8, height: 8, depthOrArrayLayers: 1},
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView176 = texture135.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 12});
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder21.setPipeline(pipeline24);
} catch {}
let arrayBuffer17 = buffer61.getMappedRange(168, 0);
try {
buffer6.unmap();
} catch {}
try {
renderPassEncoder12.insertDebugMarker('\u{1f800}');
} catch {}
try {
device0.queue.writeBuffer(buffer95, 12, new Float64Array(4588).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/4586)), 2069, 0);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer143 = device0.createBuffer({
  size: 32,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder41.setBindGroup(1, bindGroup68, new Uint32Array(799), 178, 0);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(297);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 63},
  aspect: 'all',
}, new Uint8Array(100).fill(241), /* required buffer size: 100 */
{offset: 100, bytesPerRow: 288}, {width: 58, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView177 = texture21.createView({mipLevelCount: 1});
let sampler23 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
});
try {
computePassEncoder40.end();
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer109, 'uint16', 0, 74);
} catch {}
try {
commandEncoder17.resolveQuerySet(querySet1, 175, 107, buffer85, 256);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
computePassEncoder26.setBindGroup(1, bindGroup78);
} catch {}
try {
computePassEncoder38.setBindGroup(2, bindGroup46, new Uint32Array(864), 369, 0);
} catch {}
try {
renderBundleEncoder28.setIndexBuffer(buffer109, 'uint32', 60, 88);
} catch {}
let bindGroup105 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let buffer144 = device0.createBuffer({size: 44, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
renderPassEncoder13.setVertexBuffer(1, buffer58, 0, 28);
} catch {}
try {
renderBundleEncoder17.setBindGroup(0, bindGroup104);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
  toneMapping: {mode: 'standard'},
});
} catch {}
document.body.prepend(img6);
let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpteSt4281', transfer: 'gamma28curve'} });
let bindGroup106 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]});
let texture196 = device0.createTexture({
  size: {width: 345},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder20.setVertexBuffer(2, buffer23, 44, 9);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer107, 'uint32', 8, 34);
} catch {}
try {
renderBundleEncoder11.insertDebugMarker('\u{1fb64}');
} catch {}
let pipeline32 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule6}});
let bindGroup107 = device0.createBindGroup({
  layout: veryExplicitBindGroupLayout0,
  entries: [
    {binding: 312, resource: sampler20},
    {binding: 3, resource: textureView75},
    {binding: 49, resource: {buffer: buffer111}},
    {binding: 61, resource: textureView90},
    {binding: 17, resource: externalTexture5},
    {binding: 5, resource: externalTexture4},
    {binding: 4, resource: {buffer: buffer116}},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 153, resource: {buffer: buffer15, offset: 0}},
    {binding: 0, resource: textureView22},
    {binding: 524, resource: textureView80},
    {binding: 7, resource: {buffer: buffer116}},
    {binding: 116, resource: textureView4},
    {binding: 308, resource: textureView73},
    {binding: 109, resource: textureView165},
    {binding: 2, resource: externalTexture23},
    {binding: 1, resource: {buffer: buffer130}},
    {binding: 159, resource: sampler1},
    {binding: 59, resource: {buffer: buffer15}},
  ],
});
let buffer145 = device0.createBuffer({size: 260, usage: GPUBufferUsage.UNIFORM});
let commandEncoder153 = device0.createCommandEncoder();
let texture197 = device0.createTexture({
  size: {width: 1656, height: 1, depthOrArrayLayers: 133},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView178 = texture178.createView({dimension: '1d', aspect: 'all', baseArrayLayer: 0});
try {
computePassEncoder39.setBindGroup(0, bindGroup86, [0, 0]);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer58, 80, 73);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer96, 'uint32', 12, 7);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(0, buffer110, 0);
} catch {}
let arrayBuffer18 = buffer75.getMappedRange(0, 4);
try {
device0.queue.writeBuffer(buffer63, 24, new Uint32Array(2661).map((_, i) => i * 1), 615, 0);
} catch {}
let commandEncoder154 = device0.createCommandEncoder({});
let texture198 = device0.createTexture({
  size: {width: 207, height: 1, depthOrArrayLayers: 47},
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView179 = texture120.createView({baseArrayLayer: 0});
let computePassEncoder46 = commandEncoder129.beginComputePass();
try {
renderBundleEncoder21.setBindGroup(3, bindGroup2);
} catch {}
try {
renderBundleEncoder23.setBindGroup(2, bindGroup19, new Uint32Array(2082), 114, 0);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline30);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt709', transfer: 'logSqrt'} });
let commandBuffer24 = commandEncoder118.finish();
let sampler24 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'nearest', lodMaxClamp: 98.88});
try {
renderPassEncoder12.setIndexBuffer(buffer118, 'uint32', 4, 5);
} catch {}
let texture199 = device0.createTexture({
  size: {width: 690, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder16.setBindGroup(1, bindGroup38);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroupsIndirect(buffer143, 0); };
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup104, new Uint32Array(4064), 1_105, 0);
} catch {}
try {
commandEncoder94.copyBufferToBuffer(buffer86, 228, buffer47, 4, 4);
} catch {}
try {
computePassEncoder24.insertDebugMarker('\u82bf');
} catch {}
let bindGroup108 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 93, resource: textureView1}]});
let buffer146 = device0.createBuffer({
  size: 8,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder155 = device0.createCommandEncoder({});
let textureView180 = texture64.createView({label: '\u4f03', format: 'rgba16sint', baseArrayLayer: 0});
let renderPassEncoder22 = commandEncoder100.beginRenderPass({
  colorAttachments: [{
  view: textureView158,
  clearValue: { r: -196.3, g: -747.0, b: 746.0, a: -233.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder34.setBindGroup(0, bindGroup55);
} catch {}
try {
computePassEncoder31.setBindGroup(3, bindGroup77, new Uint32Array(3187), 391, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer133, 60); };
} catch {}
try {
computePassEncoder46.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder24.setBindGroup(1, bindGroup27);
} catch {}
try {
renderBundleEncoder2.setPipeline(pipeline11);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(0, buffer97, 676);
} catch {}
try {
if (!arrayBuffer17.detached) { new Uint8Array(arrayBuffer17).fill(67); };
} catch {}
let commandEncoder156 = device0.createCommandEncoder({});
let textureView181 = texture65.createView({baseMipLevel: 0});
try {
renderPassEncoder1.setBindGroup(3, bindGroup95, new Uint32Array(228), 5, 0);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer36, 'uint32', 0, 9);
} catch {}
try {
renderBundleEncoder1.setVertexBuffer(0, buffer114, 0);
} catch {}
let imageData22 = new ImageData(28, 44);
let videoFrame28 = new VideoFrame(offscreenCanvas2, {timestamp: 0});
let bindGroup109 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 93, resource: textureView5}]});
let texture200 = device0.createTexture({
  size: [4, 4, 136],
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder12.setBindGroup(1, bindGroup36);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup94, new Uint32Array(56), 8, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer102, 'uint16', 42, 22);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(3, buffer3, 264, 18);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer38, 'uint16', 14, 1);
} catch {}
try {
  await shaderModule8.getCompilationInfo();
} catch {}
try {
commandEncoder137.resolveQuerySet(querySet2, 0, 0, buffer122, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroupsIndirect(buffer36, 0); };
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup82);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer96, 'uint16', 20, 14);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(4, buffer118, 12, 26);
} catch {}
try {
renderBundleEncoder19.setBindGroup(1, bindGroup44);
} catch {}
let commandEncoder157 = device0.createCommandEncoder({});
try {
renderBundleEncoder7.setBindGroup(1, bindGroup87, new Uint32Array(768), 136, 0);
} catch {}
let buffer147 = device0.createBuffer({
  size: 284,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder158 = device0.createCommandEncoder();
let sampler25 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 71.71,
  maxAnisotropy: 17,
});
try {
computePassEncoder24.setBindGroup(1, bindGroup32);
} catch {}
try {
computePassEncoder41.setBindGroup(0, bindGroup16, new Uint32Array(655), 2, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroups(1, 1); };
} catch {}
try {
  await shaderModule4.getCompilationInfo();
} catch {}
try {
buffer101.unmap();
} catch {}
try {
commandEncoder143.copyBufferToBuffer(buffer81, 264, buffer143, 0, 4);
} catch {}
try {
device0.queue.submit([commandBuffer24]);
} catch {}
let veryExplicitBindGroupLayout36 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 14,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: true },
    },
  ],
});
let textureView182 = texture85.createView({arrayLayerCount: 1});
try {
renderPassEncoder15.setBindGroup(1, bindGroup71);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer136, 'uint16', 6, 7);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(5, buffer58, 28);
} catch {}
let arrayBuffer19 = buffer61.getMappedRange(176, 0);
try {
device0.queue.writeTexture({
  texture: texture124,
  mipLevel: 1,
  origin: {x: 236, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(118_126).fill(23), /* required buffer size: 118_126 */
{offset: 19, bytesPerRow: 1193, rowsPerImage: 11}, {width: 148, height: 0, depthOrArrayLayers: 10});
} catch {}
let textureView183 = texture68.createView({dimension: '1d', baseMipLevel: 0});
try {
renderPassEncoder12.setVertexBuffer(6, buffer84, 0);
} catch {}
try {
renderBundleEncoder27.setBindGroup(1, bindGroup109);
} catch {}
try {
renderBundleEncoder22.setPipeline(pipeline30);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let arrayBuffer20 = buffer75.getMappedRange(8, 0);
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer148 = device0.createBuffer({size: 152, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder159 = device0.createCommandEncoder({});
let textureView184 = texture142.createView({dimension: '2d-array'});
let texture201 = device0.createTexture({
  size: [2, 2, 1],
  dimension: '2d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder17.setPipeline(pipeline24);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer148, 'uint32', 20, 22);
} catch {}
let bindGroup110 = device0.createBindGroup({
  layout: recycledExplicitBindGroupLayout6,
  entries: [
    {binding: 2, resource: externalTexture25},
    {binding: 116, resource: textureView4},
    {binding: 3, resource: textureView0},
    {binding: 10, resource: {buffer: buffer46}},
    {binding: 0, resource: textureView32},
    {binding: 59, resource: {buffer: buffer116}},
    {binding: 109, resource: textureView94},
    {binding: 61, resource: textureView90},
    {binding: 4, resource: {buffer: buffer15, size: 1088}},
    {binding: 49, resource: {buffer: buffer142}},
    {binding: 1, resource: {buffer: buffer130, offset: 0}},
    {binding: 308, resource: textureView16},
    {binding: 524, resource: textureView80},
    {binding: 312, resource: sampler18},
    {binding: 159, resource: sampler12},
    {binding: 5, resource: externalTexture21},
    {binding: 17, resource: externalTexture10},
    {binding: 7, resource: {buffer: buffer74, size: 184}},
    {binding: 153, resource: {buffer: buffer46}},
  ],
});
let commandEncoder160 = device0.createCommandEncoder({});
let commandBuffer25 = commandEncoder97.finish();
let texture202 = device0.createTexture({
  size: [345, 1, 1],
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder2.setVertexBuffer(5, buffer6, 0, 22);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.submit([commandBuffer23, commandBuffer25]);
} catch {}
try {
device0.queue.writeBuffer(buffer23, 12, new DataView(new ArrayBuffer(15688)), 57, 4);
} catch {}
videoFrame0.close();
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame5.close();
videoFrame6.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame16.close();
videoFrame18.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
await gc();

}

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);
      
    }
  }
  console.debug('Pass');
  globalThis.testRunner?.dumpAsText();
  globalThis.testRunner?.notifyDone();
};
</script>
Pass