<!-- webkit-test-runner [ enableMetalShaderValidation=true ] -->
<script src="../../../resources/js-test-pre.js"></script>
<style>
  :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; }
</style>
<script id="shared">

async function gc() {
  await 0;
  if (globalThis.GCController) {
    globalThis.GCController.collect();
  } else if (globalThis.$vm) {
    globalThis.$vm.gc();
  }
}

/**
 * @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);
}

const videoUrls = [

];

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

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

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

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

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


async function window0() {
let adapter0 = await navigator.gpu.requestAdapter({});
let adapter1 = await navigator.gpu.requestAdapter({});
let device0 = await adapter1.requestDevice({
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxColorAttachmentBytesPerSample: 32,
    maxVertexBufferArrayStride: 2048,
    maxTextureArrayLayers: 256,
    maxUniformBufferBindingSize: 38913575,
    maxStorageBufferBindingSize: 177377121,
    maxSampledTexturesPerShaderStage: 16,
    maxInterStageShaderComponents: 64,
    maxSamplersPerShaderStage: 16,
  },
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let buffer0 = device0.createBuffer({
  label: '\u9447\u3852',
  size: 567,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture0 = device0.createTexture({
  size: {width: 1080, height: 60, depthOrArrayLayers: 1},
  format: 'etc2-rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler0 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 72.25,
  lodMaxClamp: 94.03,
});
let buffer1 = device0.createBuffer({
  size: 2089,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder0 = device0.createCommandEncoder({});
let sampler1 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 87.74,
  lodMaxClamp: 89.77,
});
try {
device0.queue.submit([]);
} catch {}
let buffer2 = device0.createBuffer({size: 2332, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let texture1 = device0.createTexture({
  size: {width: 1080, height: 60, depthOrArrayLayers: 8},
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView0 = texture0.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
try {
buffer1.unmap();
} catch {}
let texture2 = device0.createTexture({
  label: '\u0b0b\u063f\u303b\u0d1b\ufc91\u3a45\ueec3',
  size: [272, 60, 1],
  mipLevelCount: 3,
  format: 'etc2-rgb8a1unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let computePassEncoder0 = commandEncoder0.beginComputePass({});
let sampler2 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 99.04,
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 19,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 477,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let commandEncoder1 = device0.createCommandEncoder({label: '\u77b1\ud7e6\u09c1\u{1ffe5}\u7e8a\uc41b\uacdf'});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 467});
let textureView1 = texture0.createView({dimension: '2d-array'});
let texture3 = device0.createTexture({
  size: {width: 270},
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder1 = commandEncoder1.beginComputePass({});
await gc();
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 1197});
let texture4 = device0.createTexture({
  label: '\u{1fda8}\u0b89\u3ca6\u{1fc07}\u{1fcc6}\uddbc\ua94c',
  size: {width: 272, height: 60, depthOrArrayLayers: 414},
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 4, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(39).fill(99), /* required buffer size: 39 */
{offset: 39, bytesPerRow: 90}, {width: 12, height: 16, depthOrArrayLayers: 0});
} catch {}
let buffer3 = device0.createBuffer({
  size: 20802,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView2 = texture4.createView({dimension: '3d', mipLevelCount: 1, arrayLayerCount: 1});
let textureView3 = texture3.createView({});
await gc();
let commandEncoder2 = device0.createCommandEncoder({});
let texture5 = device0.createTexture({
  size: [135, 7, 51],
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder2 = commandEncoder2.beginComputePass();
let buffer4 = device0.createBuffer({
  size: 2721,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let texture6 = device0.createTexture({
  size: {width: 270},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture7 = device0.createTexture({
  size: [136, 30, 1],
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder1.pushDebugGroup('\u098b');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 2,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(156).fill(141), /* required buffer size: 156 */
{offset: 156, bytesPerRow: 17}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let textureView4 = texture6.createView({dimension: '1d', baseArrayLayer: 0});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout0]});
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 2007});
let textureView5 = texture3.createView({label: '\u{1fe68}\u06a2\u3dda\u{1fb43}\u0dde\u62b9\u07b8\u3c99\uca79', baseArrayLayer: 0});
try {
device0.queue.writeBuffer(buffer1, 416, new Int16Array(5327), 1328, 224);
} catch {}
await gc();
let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder3 = device0.createCommandEncoder({label: '\u01b9\uda24\u9500\u2529\u080a\u3b12\u{1f974}\u0a9d'});
try {
device0.queue.writeBuffer(buffer3, 2084, new Int16Array(4674), 83, 2708);
} catch {}
let bindGroup0 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView4}, {binding: 19, resource: textureView2}],
});
let commandEncoder4 = device0.createCommandEncoder({});
let texture8 = device0.createTexture({
  size: [34],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder2.setBindGroup(3, bindGroup0);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
commandEncoder3.copyTextureToTexture({
  texture: texture2,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 80, height: 8, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout0]});
let commandEncoder5 = device0.createCommandEncoder({});
try {
commandEncoder3.copyTextureToTexture({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 4, y: 16, z: 1},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer3, 4152, new BigUint64Array(48579), 7929, 272);
} catch {}
let buffer5 = device0.createBuffer({
  size: 15405,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let computePassEncoder3 = commandEncoder3.beginComputePass({});
let sampler3 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 59.82,
  lodMaxClamp: 98.42,
});
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
buffer4.unmap();
} catch {}
try {
commandEncoder5.copyBufferToBuffer(buffer5, 1796, buffer0, 28, 116);
} catch {}
try {
commandEncoder4.copyBufferToTexture({
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1864 */
  offset: 1864,
  buffer: buffer5,
}, {
  texture: texture7,
  mipLevel: 2,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer5, 8532, new Float32Array(22917), 1148, 472);
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

struct T0 {
  @size(80) f0: atomic<u32>,
  @size(320) f1: array<mat4x2f>,
}

struct T1 {
  @align(32) @size(96) f0: array<array<array<i32, 12>, 1>, 1>,
  @size(32) f1: array<vec4u, 1>,
  @align(8) @size(96) f2: u32,
}

struct VertexOutput0 {
  @location(4) f0: vec4f,
  @builtin(position) f1: vec4f,
  @location(6) @interpolate(flat, centroid) f2: u32,
  @location(12) @interpolate(flat, sample) f3: vec2i,
}

alias vec3b = vec3<bool>;

var<private> vp0: f16 = f16(4287.7);

var<private> vp1: array<array<i32, 1>, 43> = array(array(i32(50)), array<i32, 1>(i32(129)), array(i32(74)), array<i32, 1>(), array<i32, 1>(i32(91)), array(i32(323)), array<i32, 1>(i32(13)), array(i32(203)), array<i32, 1>(i32(324)), array<i32, 1>(i32(202)), array(i32(128)), array(i32(149)), array<i32, 1>(), array(i32(191)), array(i32(519)), array(i32(229)), array(i32(32)), array(i32(-178)), array<i32, 1>(), array<i32, 1>(i32(-238)), array<i32, 1>(), array<i32, 1>(), array<i32, 1>(i32(374)), array<i32, 1>(), array(i32(317)), array<i32, 1>(), array(i32(149)), array(i32(180)), array(i32(226)), array<i32, 1>(i32(238)), array<i32, 1>(), array(i32(-64)), array(i32(91)), array(i32(15)), array<i32, 1>(), array<i32, 1>(), array<i32, 1>(), array(i32(-126)), array<i32, 1>(), array<i32, 1>(i32(516)), array(i32(163)), array(i32(455)), array(i32(100)));

@vertex
fn vertex0(@location(15) a0: u32) -> VertexOutput0 {
  var out: VertexOutput0;
  vp0 = vec4h(unpack4x8unorm(bitcast<u32>(unpack2x16float(u32(unconst_u32(20))).x)))[3];
  let ptr0: ptr<private, i32> = &vp1[u32(unconst_u32(129))][0];
  let vf0: vec2f = unpack2x16float(u32(unconst_u32(9)));
  vp0 = f16(unpack2x16float(u32(unconst_u32(7))).y);
  var vf1: vec2f = vf0;
  out.f2 *= pack2x16snorm(vf0);
  out.f3 = vec2i(vp1[u32(unconst_u32(48))][u32(unconst_u32(78))]);
  let ptr1: ptr<private, i32> = &vp1[u32(unconst_u32(123))][0];
  let ptr2: ptr<private, i32> = &vp1[42][0];
  out.f1 = vec4f(f32(vp0));
  var vf2: vec2f = unpack2x16snorm(u32(unconst_u32(24)));
  vp1[u32(unconst_u32(544))][0] -= bitcast<i32>(vf0[u32(unconst_u32(325))]);
  vf2 = vec2f(f32(vp1[u32(unconst_u32(130))][0]));
  let ptr3: ptr<private, i32> = &(*ptr1);
  var vf3: f32 = vf1[u32(unconst_u32(154))];
  let ptr4: ptr<private, f16> = &vp0;
  var vf4: f32 = vf2[u32(unconst_u32(411))];
  let ptr5: ptr<private, array<i32, 1>> = &vp1[pack2x16float(vf1)];
  vp1[u32(unconst_u32(1))][0] = bitcast<i32>(vf1[u32(unconst_u32(151))]);
  out.f1 = vec4f(f32(vp1[42][0]));
  out.f0 *= unpack2x16snorm(u32(unconst_u32(418))).xxxx;
  vp0 = f16(vp1[u32(vf1[u32(unconst_u32(374))])][u32(unconst_u32(733))]);
  out = VertexOutput0(vec4f(f32((*ptr5)[u32(unconst_u32(148))])), vec4f(f32((*ptr5)[u32(unconst_u32(148))])), bitcast<u32>((*ptr5)[u32(unconst_u32(148))]), vec2i((*ptr5)[u32(unconst_u32(148))]));
  vf4 = f32((*ptr2));
  return out;
}

@fragment
fn fragment0(@location(4) @interpolate(perspective, centroid) a0: vec4f) -> @location(200) @interpolate(linear) vec4f {
  var out: vec4f;
  let ptr6: ptr<private, i32> = &vp1[u32(unconst_u32(29))][0];
  vp0 -= f16(atanh(f32(unconst_f32(0.02314))));
  vp1[42][0] = vec4i(atan2(vec4h(unconst_f16(5435.6), unconst_f16(1039.4), unconst_f16(2467.9), unconst_f16(27963.1)), vec4h(unconst_f16(6038.9), unconst_f16(13058.0), unconst_f16(752.4), unconst_f16(8781.8)))).b;
  var vf5: vec3f = log2(vec3f(unconst_f32(0.01947), unconst_f32(0.09116), unconst_f32(0.4033)));
  var vf6: vec3i = firstTrailingBit(vec3i(unconst_i32(10), unconst_i32(89), unconst_i32(22)));
  vp1[u32(pow(vec4h(unconst_f16(2788.1), unconst_f16(9624.6), unconst_f16(4652.3), unconst_f16(15230.5)), vec4h(unconst_f16(56.41), unconst_f16(6952.9), unconst_f16(13993.6), unconst_f16(6654.6)))[3])][u32(unconst_u32(65))] *= vf6[0];
  vf5 = atanh(vec2f(unconst_f32(0.01359), unconst_f32(0.06078))).rgg;
  let ptr7: ptr<private, array<i32, 1>> = &vp1[42];
  vf5 = vec3f(bitcast<f32>((*ptr7)[0]));
  let ptr8: ptr<private, i32> = &vp1[42][u32(unconst_u32(217))];
  vf6 ^= vec3i(vp1[u32(unconst_u32(295))][0]);
  let ptr9: ptr<private, i32> = &vp1[u32(unconst_u32(361))][u32(unconst_u32(574))];
  var vf7: f16 = floor(f16(unconst_f16(16875.0)));
  let ptr10: ptr<private, i32> = &vp1[u32(unconst_u32(123))][u32(unconst_u32(82))];
  vf6 |= vec3i((*ptr9));
  var vf8: vec3i = firstTrailingBit(vec3i(unconst_i32(-5), unconst_i32(44), unconst_i32(450)));
  vf7 -= sin(vec2h(unconst_f16(20177.8), unconst_f16(16247.7))).r;
  let ptr11: ptr<private, array<i32, 1>> = &vp1[42];
  let ptr12: ptr<private, i32> = &(*ptr9);
  vp0 -= f16((*ptr9));
  let ptr13: ptr<private, i32> = &vp1[42][u32(unconst_u32(222))];
  var vf9: u32 = pack4xI8(vec4i(unconst_i32(29), unconst_i32(-30), unconst_i32(383), unconst_i32(-411)));
  return out;
}

@fragment
fn fragment1(@location(4) a0: vec4f) -> @location(200) vec4u {
  var out: vec4u;
  out |= unpack4xU8(bitcast<u32>(vp1[42][0]));
  let ptr14: ptr<private, array<i32, 1>> = &vp1[u32(unconst_u32(49))];
  vp1[u32(unconst_u32(97))][u32(unconst_u32(7))] &= (*ptr14)[0];
  let vf10: vec2f = unpack2x16float(u32(unconst_u32(144)));
  let ptr15: ptr<private, i32> = &vp1[42][u32(unconst_u32(4))];
  let ptr16: ptr<private, i32> = &(*ptr14)[0];
  let ptr17: ptr<private, f16> = &vp0;
  let ptr18: ptr<private, array<array<i32, 1>, 43>> = &vp1;
  out = vec4u(u32((*ptr18)[42][0]));
  let ptr19: ptr<private, i32> = &vp1[u32(unconst_u32(81))][u32((*ptr18)[42][0])];
  vp0 -= f16(vp1[u32(unconst_u32(37))][0]);
  let ptr20: ptr<private, array<i32, 1>> = &(*ptr18)[u32(unconst_u32(42))];
  let vf11: f32 = a0[u32(unconst_u32(68))];
  vp1[u32(unconst_u32(0))][u32(unconst_u32(51))] += (*ptr20)[u32(unconst_u32(92))];
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder6 = device0.createCommandEncoder();
let texture9 = device0.createTexture({
  size: {width: 420, height: 10, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView6 = texture9.createView({baseMipLevel: 0});
let computePassEncoder4 = commandEncoder6.beginComputePass({});
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(112).fill(50), /* required buffer size: 112 */
{offset: 112, bytesPerRow: 1208}, {width: 146, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {
  fullRange: true,
  matrix: 'unspecified',
  primaries: 'smpteSt4281',
  transfer: 'bt1361ExtendedColourGamut',
} });
let commandEncoder7 = device0.createCommandEncoder({});
let sampler4 = device0.createSampler({
  label: '\u0368\ud364',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 80.33,
  lodMaxClamp: 80.58,
  compare: 'less-equal',
});
try {
computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(505), 141, 0);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder7.copyTextureToTexture({
  texture: texture2,
  mipLevel: 1,
  origin: {x: 52, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 2,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup1 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView2}, {binding: 477, resource: textureView4}],
});
let buffer6 = device0.createBuffer({size: 1087, usage: GPUBufferUsage.MAP_READ});
let computePassEncoder5 = commandEncoder5.beginComputePass();
let sampler5 = device0.createSampler({
  label: '\u0094\u2af3\u8ea3\u9f8c\u6449\ue541\u02df\u{1f8ef}\u0059\u07a2',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 62.70,
  lodMaxClamp: 97.15,
});
try {
computePassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(3422), 1_127, 0);
} catch {}
try {
commandEncoder4.insertDebugMarker('\ue041');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 1,
  origin: {x: 2, y: 9, z: 0},
  aspect: 'all',
}, new Uint8Array(19).fill(62), /* required buffer size: 19 */
{offset: 19, bytesPerRow: 38}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
let bindGroup2 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView4}, {binding: 19, resource: textureView2}],
});
let commandEncoder8 = device0.createCommandEncoder({});
let computePassEncoder6 = commandEncoder8.beginComputePass({label: '\u91e6\u{1fc74}\u0baa\u09be\u6db6\u53ff\u005c\u06ba\ua232'});
try {
computePassEncoder1.setBindGroup(0, bindGroup1, new Uint32Array(4688), 423, 0);
} catch {}
try {
commandEncoder4.copyBufferToBuffer(buffer2, 136, buffer5, 3516, 704);
} catch {}
try {
commandEncoder7.copyBufferToTexture({
  /* bytesInLastRow: 184 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1792 */
  offset: 1792,
  rowsPerImage: 296,
  buffer: buffer4,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder4.copyTextureToBuffer({
  texture: texture2,
  mipLevel: 2,
  origin: {x: 28, y: 4, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 248 */
  offset: 248,
  bytesPerRow: 19456,
  buffer: buffer1,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer7 = device0.createBuffer({size: 11579, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let texture10 = device0.createTexture({
  label: '\u0e03\u{1fa7b}\u{1ffbd}\u0350\u28b5\u{1fb67}',
  size: {width: 48, height: 5, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView7 = texture3.createView({});
try {
commandEncoder4.copyBufferToBuffer(buffer3, 8648, buffer5, 2500, 228);
} catch {}
try {
commandEncoder4.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup3 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView4}, {binding: 19, resource: textureView2}],
});
let texture11 = device0.createTexture({
  size: {width: 12, height: 1, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder6.setBindGroup(3, bindGroup2, new Uint32Array(721), 14, 0);
} catch {}
let buffer8 = device0.createBuffer({
  size: 1037,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture12 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 746},
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder6.setBindGroup(3, bindGroup0);
} catch {}
try {
commandEncoder4.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1816 */
  offset: 1816,
  bytesPerRow: 33536,
  buffer: buffer4,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder1.popDebugGroup();
} catch {}
let buffer9 = device0.createBuffer({
  size: 6317,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView8 = texture6.createView({label: '\u9888\u252b\u2432\u{1f63c}\uaff4\u51e2', aspect: 'all', arrayLayerCount: 1});
let textureView9 = texture10.createView({dimension: '2d-array', baseMipLevel: 0, arrayLayerCount: 1});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'display-p3'});
let offscreenCanvas0 = new OffscreenCanvas(61, 73);
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 37});
let texture13 = device0.createTexture({
  size: {width: 840, height: 20, depthOrArrayLayers: 89},
  mipLevelCount: 3,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 48, height: 5, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let computePassEncoder7 = commandEncoder7.beginComputePass({});
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
let querySet4 = device0.createQuerySet({type: 'occlusion', count: 441});
let texture14 = device0.createTexture({size: [840], dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder1.setBindGroup(3, bindGroup3, []);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 1,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(157).fill(116), /* required buffer size: 157 */
{offset: 157, bytesPerRow: 34}, {width: 4, height: 8, depthOrArrayLayers: 0});
} catch {}
let promise0 = device0.queue.onSubmittedWorkDone();
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 1407});
let computePassEncoder8 = commandEncoder9.beginComputePass({});
try {
computePassEncoder5.setBindGroup(3, bindGroup2);
} catch {}
try {
buffer9.unmap();
} catch {}
let computePassEncoder9 = commandEncoder4.beginComputePass({});
try {
computePassEncoder2.setBindGroup(1, bindGroup2);
} catch {}
let bindGroup4 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView8}, {binding: 19, resource: textureView2}],
});
let sampler6 = device0.createSampler({
  label: '\u51f1\u{1fbf0}\u{1fd11}\uf6a0',
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  lodMinClamp: 87.95,
  lodMaxClamp: 92.68,
});
let externalTexture1 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder9.setBindGroup(2, bindGroup1);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder10 = device0.createCommandEncoder();
let computePassEncoder10 = commandEncoder10.beginComputePass();
try {
computePassEncoder5.setBindGroup(3, bindGroup1, []);
} catch {}
try {
computePassEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(310), 50, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer8, 104, new DataView(new ArrayBuffer(17686)), 2154, 12);
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(19) var st0: texture_storage_3d<rgba8uint, write>;

@group(0) @binding(477) var tex1: texture_1d<u32>;

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

struct T1 {
  f0: vec4h,
}

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

struct FragmentOutput0 {
  @builtin(sample_mask) f0: u32,
  @location(5) f1: vec4u,
  @location(0) @interpolate(flat, center) f2: vec2u,
  @builtin(frag_depth) f3: f32,
}

struct FragmentOutput1 {
  @builtin(frag_depth) f0: f32,
  @location(0) @interpolate(flat) f1: vec2u,
  @location(4) f2: vec4u,
}

fn fn0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  let vf12: f16 = floor(f16(unconst_f16(7757.0)));
  let vf13: u32 = dot4U8Packed(u32(unconst_u32(507)), u32(unconst_u32(118)));
  out.f0 = vp4.f2[0];
  let ptr21: ptr<private, vec4u> = &vp4.f1;
  vp3 = VertexOutput1(vec4f(vp5.whole));
  let vf14: u32 = vp4.f1[u32(unconst_u32(222))];
  out.f1 &= vp4.f2.rggg;
  return out;
}

fn fn1(a0: array<array<array<vec2h, 7>, 1>, 3>, a1: ptr<storage, array<array<mat3x4h, 1>>, read_write>) -> array<FragmentOutput1, 1> {
  var out: array<FragmentOutput1, 1>;
  var vf15: f16 = exp(f16(unconst_f16(6297.7)));
  vp2.fract -= vec4h(vw0[0].f4);
  let ptr22: ptr<storage, mat3x4h, read_write> = &(*a1)[arrayLength(&(*a1))][pack4x8snorm(vw0[0].f4)];
  workgroupBarrier();
  let ptr23: ptr<workgroup, vec4f> = &(*&vw0)[0].f4;
  var vf16 = fn0();
  return out;
}

fn fn2(a0: ptr<function, array<vec2i, 3>>, a1: mat3x2f, a2: array<T1, 1>, a3: array<vec4h, 1>) {
  var vf17: f16 = dot(vec4h(unconst_f16(13704.7), unconst_f16(4810.8), unconst_f16(2467.1), unconst_f16(5626.2)), vec4h(unconst_f16(1809.4), unconst_f16(-17957.1), unconst_f16(15814.4), unconst_f16(30604.2)));
  var vf18: array<vec4h, 1> = a3;
  let vf19: array<T1, 1> = a2;
  let ptr24: ptr<private, vec2u> = &vp4.f2;
  vp3.f4 = vec4f(a2[0].f0);
  let vf20: f16 = vf18[0][u32(unconst_u32(103))];
  vp6 = bitcast<vec4h>((*a0)[2]);
  let vf21: u32 = (*ptr24)[u32(unconst_u32(140))];
  let ptr25: ptr<private, vec4h> = &vp2.whole;
  let ptr26: ptr<private, vec2u> = &(*ptr24);
  var vf22: T1 = vf19[u32(unconst_u32(185))];
  vp5.fract = vec4h(f16(vp4.f3));
  vf22 = T1(vec4h(f16((*a0)[u32(unconst_u32(660))][bitcast<u32>(sinh(vec3f(unconst_f32(0.1932), unconst_f32(0.06384), unconst_f32(0.01489)))[2])])));
  vp2.fract = a2[u32(unconst_u32(415))].f0;
  let vf23: vec3h = cross(vec3h(unconst_f16(1725.1), unconst_f16(608.2), unconst_f16(8047.3)), vec3h(unconst_f16(5729.6), unconst_f16(6353.1), unconst_f16(2210.4)));
  var vf24: f16 = a3[u32(unconst_u32(566))][u32(unconst_u32(16))];
  (*a0)[u32(a2[u32(unconst_u32(223))].f0[u32(unconst_u32(413))])] += vec2i(vf23.gb);
  vp4 = FragmentOutput0(u32(a2[0].f0[0]), vec4u(a2[0].f0), bitcast<vec2u>(a2[0].f0), vec4f(a2[0].f0)[2]);
  let vf25: f16 = dot(vec4h(unconst_f16(15531.3), unconst_f16(8543.2), unconst_f16(3242.9), unconst_f16(19422.8)), vec4h(unconst_f16(14713.6), unconst_f16(3132.4), unconst_f16(98.64), unconst_f16(2850.6)));
  let vf26: vec3h = vf23;
  let ptr27: ptr<function, vec4h> = &vf22.f0;
}

var<workgroup> vw0: array<VertexOutput1, 1>;

var<private> vp2 = modf(vec4h(5953.3, -1983.9, 10238.4, 676.3));

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

var<private> vp4: FragmentOutput0 = FragmentOutput0(u32(11), vec4u(239, 133, 138, 43), vec2u(79, 85), f32(0.6666));

var<private> vp5 = modf(vec4h(21839.3, 2047.0, 5676.4, -1167.6));

var<private> vp6: vec4h = vec4h(7412.4, 10742.8, 7581.7, 1776.5);

@vertex
fn vertex1(@location(10) @interpolate(flat) a0: vec2i, @builtin(instance_index) a1: u32) -> VertexOutput1 {
  var out: VertexOutput1;
  var vf27: vec3h = step(vec3h(unconst_f16(7958.8), unconst_f16(15588.3), unconst_f16(27138.7)), vec3h(unconst_f16(22155.4), unconst_f16(1347.9), unconst_f16(6943.1)));
  var vf28 = fn0();
  let vf29: u32 = vf28.f1[u32(unconst_u32(86))];
  out.f4 = vec4f(vp4.f3);
  vp2.whole *= vec4h(unpack4x8snorm(vf29));
  return out;
}

@fragment
fn fragment2() -> FragmentOutput0 {
  var out: FragmentOutput0;
  out.f2 = vec2u(pack4xU8(vec4u(unconst_u32(532), unconst_u32(14), unconst_u32(220), unconst_u32(588))));
  let ptr28: ptr<private, vec4h> = &vp5.whole;
  let vf30: f16 = acos(f16(unconst_f16(35954.3)));
  vp3.f4 += bitcast<vec4f>(unpack4xU8(u32(unconst_u32(92))));
  vp4.f1 &= vec4u(vp2.fract);
  var vf31: vec2f = tan(vec2f(unconst_f32(0.1299), unconst_f32(0.03062)));
  textureStore(st0, vec3i(unconst_i32(389), unconst_i32(497), unconst_i32(84)), vec4u(vec4u(max(vec4h(unconst_f16(1626.8), unconst_f16(2087.8), unconst_f16(29268.3), unconst_f16(3441.6)), vec4h(unconst_f16(2508.1), unconst_f16(268.1), unconst_f16(10105.6), unconst_f16(6243.8))))));
  let ptr29: ptr<function, vec2f> = &vf31;
  out.f3 = f32(countTrailingZeros(vec3i(unconst_i32(-115), unconst_i32(51), unconst_i32(44))).g);
  out.f3 = vec4f(unpack4xU8(u32(unconst_u32(159))))[1];
  let ptr30: ptr<function, vec2f> = &vf31;
  return out;
}

@fragment
fn fragment3(@builtin(front_facing) a0: bool) -> FragmentOutput1 {
  var out: FragmentOutput1;
  vp4 = FragmentOutput0(bitcast<u32>(smoothstep(f32(unconst_f32(0.04961)), f32(unconst_f32(0.1853)), f32(unconst_f32(0.1048)))), vec4u(bitcast<u32>(smoothstep(f32(unconst_f32(0.04961)), f32(unconst_f32(0.1853)), f32(unconst_f32(0.1048))))), vec2u(bitcast<u32>(smoothstep(f32(unconst_f32(0.04961)), f32(unconst_f32(0.1853)), f32(unconst_f32(0.1048))))), smoothstep(f32(unconst_f32(0.04961)), f32(unconst_f32(0.1853)), f32(unconst_f32(0.1048))));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute0() {
  vp5.fract *= vec4h(vp6[u32(unconst_u32(14))]);
  let ptr31: ptr<private, vec4f> = &vp3.f4;
  vp2.fract += vec4h(f16(vp3.f4[u32(unconst_u32(33))]));
  vp6 += vec4h(f16(vp4.f3));
  let ptr32: ptr<workgroup, array<VertexOutput1, 1>> = &(*&vw0);
  vw0[u32(unconst_u32(403))].f4 = vw0[0].f4;
  fn0();
  let ptr33: ptr<workgroup, vec4f> = &(*&vw0)[u32(unconst_u32(26))].f4;
  var vf32 = fn0();
  textureBarrier();
  var vf33 = fn0();
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder11 = device0.createCommandEncoder({label: '\u6a83\u0a13\u0562\u0136\u9ab5\u{1facb}\u2f8d\ud279'});
let texture15 = device0.createTexture({
  label: '\u{1fff3}\ud82c\u0e82\u{1faa5}\u{1fd71}\u091c\uc0f7\u{1f653}\u8bbf',
  size: [420, 10, 1],
  sampleCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder11 = commandEncoder11.beginComputePass({});
let sampler7 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 1.507,
  lodMaxClamp: 30.02,
  maxAnisotropy: 10,
});
try {
buffer5.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer3, 3540, new BigUint64Array(19842), 1716, 108);
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
let commandEncoder12 = device0.createCommandEncoder({label: '\uf6ea\u0cd1\u{1f73c}\u0009\u{1fc9f}\ufe31'});
let computePassEncoder12 = commandEncoder12.beginComputePass();
let sampler8 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 30.30,
  maxAnisotropy: 4,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture16 = device0.createTexture({size: [68], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_SRC});
let sampler9 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 88.26,
  maxAnisotropy: 13,
});
try {
computePassEncoder6.setBindGroup(3, bindGroup1, new Uint32Array(4740), 137, 0);
} catch {}
try {
  await promise0;
} catch {}
try {
texture5.label = '\u{1f702}\u{1ff99}\u0120\u{1f887}';
} catch {}
let texture17 = device0.createTexture({
  size: {width: 136, height: 30, depthOrArrayLayers: 1},
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView10 = texture12.createView({aspect: 'all'});
try {
device0.queue.writeBuffer(buffer5, 1636, new BigUint64Array(4950), 1719, 484);
} catch {}
let bindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 183,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let buffer10 = device0.createBuffer({
  size: 16747,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let texture18 = device0.createTexture({
  size: [16, 16, 14],
  format: 'astc-8x8-unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView11 = texture16.createView({});
try {
buffer4.unmap();
} catch {}
let imageBitmap0 = await createImageBitmap(offscreenCanvas0);
let shaderModule2 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

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

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

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

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

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

@group(0) @binding(19) var st1: texture_storage_3d<rgba8uint, write>;

@group(0) @binding(477) var tex2: texture_1d<u32>;

struct T0 {
  f0: array<u32>,
}

struct T1 {
  @size(36) f0: T0,
}

struct VertexOutput2 {
  @location(6) @interpolate(flat, centroid) f5: vec4u,
  @location(8) @interpolate(flat, centroid) f6: vec4i,
  @builtin(position) f7: vec4f,
}

struct VertexOutput3 {
  @builtin(position) f8: vec4f,
  @location(13) f9: i32,
  @location(6) f10: vec4i,
}

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

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

alias vec3b = vec3<bool>;

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

@vertex
fn vertex2(@location(3) a0: vec2f, @location(14) a1: u32, @location(7) @interpolate(perspective) a2: vec2h, @location(10) @interpolate(flat) a3: vec4u, @location(13) a4: f16) -> VertexOutput2 {
  var out: VertexOutput2;
  let vf34: vec4h = fract(vec4h(unconst_f16(1336.1), unconst_f16(4572.7), unconst_f16(2097.5), unconst_f16(1920.8)));
  var vf35: vec4i = unpack4xI8(u32(unconst_u32(14)));
  return out;
}

@vertex
fn vertex3(@location(11) @interpolate(perspective, center) a0: vec4f) -> VertexOutput3 {
  var out: VertexOutput3;
  out = VertexOutput3(vec4f(f32(distance(f16(unconst_f16(4007.3)), f16(unconst_f16(-29087.0))))), i32(distance(f16(unconst_f16(4007.3)), f16(unconst_f16(-29087.0)))), vec4i(i32(distance(f16(unconst_f16(4007.3)), f16(unconst_f16(-29087.0))))));
  out.f9 = vec2i(abs(vec2f(unconst_f32(0.1631), unconst_f32(0.1446)))).r;
  out.f10 = firstLeadingBit(vec2i(unconst_i32(332), unconst_i32(-115))).rrrr;
  var vf36: f32 = determinant(mat4x4f(unconst_f32(0.1056), unconst_f32(0.4934), unconst_f32(0.06337), unconst_f32(-0.8602), unconst_f32(-0.3573), unconst_f32(0.1982), unconst_f32(0.01525), unconst_f32(0.4010), unconst_f32(0.01050), unconst_f32(0.3164), unconst_f32(0.3496), unconst_f32(0.02509), unconst_f32(-0.3388), unconst_f32(0.3805), unconst_f32(0.1028), unconst_f32(0.3851)));
  out.f10 -= vec4i(normalize(vec3h(distance(f16(unconst_f16(20244.0)), f16(unconst_f16(16943.6))))).bbgr);
  var vf37: vec4f = unpack4x8snorm(u32(unconst_u32(141)));
  let vf38: vec3h = refract(vec3h(unconst_f16(30406.0), unconst_f16(611.6), unconst_f16(1174.4)), vec3h(unconst_f16(47257.4), unconst_f16(60000.0), unconst_f16(8775.9)), f16(unconst_f16(45329.2)));
  vf37 = vec4f(a0[reverseBits(vec2u(bitcast<u32>(vf36))).x]);
  var vf39: vec2f = abs(vec2f(unconst_f32(0.04988), unconst_f32(-0.2227)));
  vf39 = vec2f(refract(vec3h(unconst_f16(-9113.0), unconst_f16(11125.1), unconst_f16(3470.9)), vec3h(unconst_f16(6309.6), unconst_f16(7667.5), unconst_f16(9992.0)), f16(unconst_f16(10414.4))).gg);
  out.f8 = min(vec3f(unconst_f32(0.2271), unconst_f32(0.08703), unconst_f32(0.1643)), vec3f(f32(min(i32(unconst_i32(-454)), i32(unconst_i32(217)))))).zyyy;
  let vf40: i32 = min(i32(unconst_i32(12)), i32(unconst_i32(390)));
  var vf41: f32 = vf39[u32(unconst_u32(2))];
  out.f9 &= i32(vf38[u32(unconst_u32(28))]);
  var vf42: i32 = vf40;
  return out;
}

@vertex
fn vertex4() -> VertexOutput4 {
  var out: VertexOutput4;
  var vf43: vec3h = cos(vec3h(unconst_f16(6491.1), unconst_f16(5329.5), unconst_f16(6065.3)));
  return out;
}

@fragment
fn fragment4(@location(4) a0: vec4f) -> FragmentOutput2 {
  var out: FragmentOutput2;
  var vf44: f32 = determinant(mat2x2f(unconst_f32(0.03241), unconst_f32(0.2079), unconst_f32(0.04300), unconst_f32(0.1730)));
  var vf45: f32 = acos(f32(unconst_f32(-0.1656)));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute1(@builtin(num_workgroups) a0: vec3u) {
  textureStore(st1, vec3i(unconst_i32(64), unconst_i32(89), unconst_i32(17)), vec4u(vec4u(unconst_u32(137), unconst_u32(273), unconst_u32(459), unconst_u32(110))));
  var vf46: u32 = atomicExchange(&vw1[0], u32(unconst_u32(55)));
  var vf47: u32 = a0[u32(unconst_u32(5))];
  var vf48: u32 = atomicLoad(&(*&vw1)[u32(unconst_u32(41))]);
  let ptr34: ptr<workgroup, atomic<u32>> = &vw1[u32(unconst_u32(23))];
  let ptr35: ptr<function, u32> = &vf48;
  vf48 <<= a0[u32(unconst_u32(153))];
  let vf49: u32 = atomicLoad(&vw1[u32(unconst_u32(724))]);
}`,
  sourceMap: {},
});
let buffer11 = device0.createBuffer({size: 289, usage: GPUBufferUsage.MAP_READ});
let texture19 = device0.createTexture({
  label: '\u{1f917}\u{1ffd7}\ua783\u0df2\u91be\u{1fc71}\u0d68\uf7a0\u6e6e',
  size: [840, 20, 100],
  format: 'astc-8x5-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture20 = gpuCanvasContext0.getCurrentTexture();
try {
computePassEncoder9.setBindGroup(0, bindGroup4, new Uint32Array(1065), 109, 0);
} catch {}
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpteSt4281', transfer: 'smpte170m'} });
let bindGroup5 = device0.createBindGroup({
  label: '\u414f\u0184\u792f\uc90d\u{1ffbb}\u087f\ua684\u3a94',
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView2}, {binding: 477, resource: textureView4}],
});
let commandEncoder13 = device0.createCommandEncoder({});
let textureView12 = texture15.createView({baseMipLevel: 0});
try {
commandEncoder13.copyTextureToTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 53},
  aspect: 'all',
},
{
  texture: texture10,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 20, y: 8, z: 0},
  aspect: 'all',
}, new Uint8Array(258).fill(131), /* required buffer size: 258 */
{offset: 258}, {width: 88, height: 4, depthOrArrayLayers: 0});
} catch {}
let commandEncoder14 = device0.createCommandEncoder({});
let texture21 = device0.createTexture({
  size: {width: 272, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler10 = device0.createSampler({
  label: '\u00b7\u{1fb28}\u{1fb16}\ufc9c\u0dcf\u{1f933}\u1638\ue50c\u7a20\u2e50\uaf71',
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 22.19,
});
try {
computePassEncoder2.setBindGroup(2, bindGroup1);
} catch {}
try {
computePassEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(5114), 547, 0);
} catch {}
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2844 */
  offset: 2844,
  bytesPerRow: 6912,
  rowsPerImage: 530,
  buffer: buffer5,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder14.copyTextureToTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 48, height: 5, depthOrArrayLayers: 1}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 9, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView13 = texture21.createView({
  label: '\ud23e\u3979\u0afb\u2a2e\ucf6f\u69fc\u5325\u{1f699}\ua7bb',
  mipLevelCount: 1,
  arrayLayerCount: 1,
});
let textureView14 = texture16.createView({arrayLayerCount: 1});
let computePassEncoder13 = commandEncoder14.beginComputePass({});
let sampler11 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 66.90,
  lodMaxClamp: 69.48,
  compare: 'always',
});
try {
computePassEncoder12.setBindGroup(2, bindGroup3, []);
} catch {}
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2824 */
  offset: 2824,
  bytesPerRow: 3840,
  rowsPerImage: 256,
  buffer: buffer3,
}, {
  texture: texture7,
  mipLevel: 1,
  origin: {x: 6, y: 8, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer12 = device0.createBuffer({size: 23038, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture22 = device0.createTexture({size: [68, 15, 28], format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder6.setBindGroup(0, bindGroup2, new Uint32Array(3890), 1_156, 0);
} catch {}
let buffer13 = device0.createBuffer({size: 4083, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let textureView15 = texture14.createView({dimension: '1d'});
try {
computePassEncoder2.setBindGroup(1, bindGroup3);
} catch {}
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1836 */
  offset: 1836,
  rowsPerImage: 808,
  buffer: buffer4,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

@group(0) @binding(19) var st2: texture_storage_3d<rgba8uint, write>;

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

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

struct T2 {
  @size(144) f0: mat4x3f,
  @size(928) f1: array<mat2x2h>,
}

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

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

struct S0 {
  @location(15) f0: vec4h,
}

struct S1 {
  @location(14) @interpolate(perspective) f0: vec2f,
  @location(13) f1: vec2f,
  @location(1) f2: vec2i,
  @location(2) @interpolate(flat) f3: vec2i,
  @location(11) f4: vec4f,
  @location(6) @interpolate(flat, centroid) f5: vec2i,
  @location(8) @interpolate(flat, center) f6: vec2i,
  @location(7) @interpolate(perspective) f7: vec4h,
}

struct VertexOutput6 {
  @builtin(position) f13: vec4f,
  @location(1) @interpolate(perspective, sample) f14: vec4h,
}

struct FragmentOutput3 {
  @location(0) @interpolate(flat, sample) f0: vec4f,
}

alias vec3b = vec3<bool>;

fn fn0(a0: f32) -> mat2x2f {
  var out: mat2x2f;
  let vf50: vec4f = fma(vec4f(unconst_f32(0.1446), unconst_f32(0.1005), unconst_f32(0.2722), unconst_f32(0.01569)), vec4f(unconst_f32(0.09131), unconst_f32(0.1179), unconst_f32(0.02268), unconst_f32(0.2512)), vec4f(unconst_f32(0.6020), unconst_f32(0.3525), unconst_f32(0.1443), unconst_f32(-0.07869)));
  var vf51: vec2f = unpack2x16float(u32(unconst_u32(193)));
  vf51 = atanh(vec2f(unconst_f32(0.5082), unconst_f32(0.01263)));
  var vf52: vec4h = sign(vec4h(unconst_f16(1997.7), unconst_f16(9618.3), unconst_f16(227.2), unconst_f16(6076.0)));
  var vf53: f32 = ceil(f32(unconst_f32(0.05609)));
  textureStore(st2, vec3i(i32(pack4x8snorm(vec4f(sign(vec4h(unconst_f16(22452.3), unconst_f16(28968.9), unconst_f16(1332.4), unconst_f16(4287.8))))))), vec4u(vec4u(unconst_u32(2), unconst_u32(224), unconst_u32(62), unconst_u32(52))));
  vf52 *= vec4h(select(f16(unconst_f16(15770.1)), f16(unconst_f16(1360.0)), bool(unconst_bool(true))));
  var vf54: u32 = pack4x8unorm(vec4f(unconst_f32(0.07712), unconst_f32(0.02618), unconst_f32(0.06636), unconst_f32(0.5421)));
  vp7.fract *= vec2h(atanh(vec2f(unconst_f32(-0.02412), unconst_f32(0.06165))));
  return out;
}

var<workgroup> vw2: FragmentOutput3;

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

var<workgroup> vw4: atomic<i32>;

var<private> vp7 = modf(vec2h(8280.2, 16984.0));

@vertex
fn vertex5(@builtin(vertex_index) a0: u32, @location(12) a1: vec2h, @location(15) a2: vec4h, @location(14) @interpolate(flat, centroid) a3: vec4h, @location(5) @interpolate(flat) a4: vec2u) -> VertexOutput5 {
  var out: VertexOutput5;
  out.f12 -= vec4f(a1.yyyx);
  out = VertexOutput5(unpack2x16float(u32(unconst_u32(220))).yyyy);
  var vf55: f16 = atan(f16(unconst_f16(28549.7)));
  out = VertexOutput5(vec4f(a1.xyxx));
  vp7.fract = vec2h(reflect(vec4f(a2), vec4f(unconst_f32(0.03573), unconst_f32(0.03244), unconst_f32(0.06058), unconst_f32(0.05659))).br);
  out.f12 -= unpack4x8unorm(a4[u32(atan2(vp7.whole[1], f16(unconst_f16(24634.8))))]);
  out = VertexOutput5(vec4f(vp7.fract.xxyx));
  out.f12 = vec4f(smoothstep(vec3h(unconst_f16(3597.2), unconst_f16(60000.0), unconst_f16(31188.2)), vec3h(unconst_f16(9590.1), unconst_f16(-757.2), unconst_f16(-6962.9)), vec3h(unconst_f16(3755.6), unconst_f16(4239.5), unconst_f16(-1802.3))).bbgr);
  var vf56: f16 = atan2(f16(unconst_f16(10944.8)), f16(unconst_f16(25131.1)));
  var vf57: f16 = atan(f16(unconst_f16(5345.9)));
  out.f12 = vec4f(f32(a1[u32(unconst_u32(26))]));
  var vf58: f32 = step(bitcast<f32>(pack4x8snorm(vec4f(unconst_f32(0.03094), unconst_f32(0.03975), unconst_f32(0.3296), unconst_f32(-0.1755)))), f32(unconst_f32(0.1095)));
  out.f12 *= vec4f(vp7.whole.yyxx);
  vf58 = bitcast<f32>(radians(vec2h(unconst_f16(581.3), unconst_f16(25152.0))));
  out.f12 *= vec4f(f32(a2[u32(unconst_u32(535))]));
  var vf59: vec4h = a3;
  var vf60: u32 = pack4x8snorm(vec4f(unconst_f32(0.2257), unconst_f32(0.9499), unconst_f32(0.2204), unconst_f32(0.1155)));
  return out;
}

@vertex
fn vertex6(@location(3) @interpolate(flat) a0: vec2f, @location(0) a1: vec4u, a2: S0, a3: S1, @location(9) @interpolate(perspective, center) a4: f32) -> VertexOutput6 {
  var out: VertexOutput6;
  let vf61: f32 = sin(f32(unconst_f32(0.1465)));
  out.f13 = normalize(vec3f(unconst_f32(0.5168), unconst_f32(0.4034), unconst_f32(0.01391))).brgg;
  let vf62: f32 = a3.f4[u32(unconst_u32(365))];
  return out;
}

@fragment
fn fragment5() -> FragmentOutput3 {
  var out: FragmentOutput3;
  out.f0 = unpack2x16snorm(u32(unconst_u32(118))).rrrr;
  var vf63 = fn0(f32(unconst_f32(0.03770)));
  let vf64: vec3h = min(vec3h(unconst_f16(3267.3), unconst_f16(-1802.5), unconst_f16(2976.4)), vec3h(unconst_f16(10287.8), unconst_f16(791.2), unconst_f16(-1301.4)));
  vp7 = modf(vec2h(atanh(f16(unconst_f16(152.4)))));
  fn0(f32(unpack4xI8(u32(unconst_u32(290))).x));
  out.f0 += bitcast<vec4f>(unpack4xI8(u32(unconst_u32(46))));
  fn0(unpack2x16snorm(u32(unconst_u32(130)))[0]);
  let vf65: u32 = pack2x16float(vec2f(unconst_f32(0.05716), unconst_f32(0.09719)));
  let ptr36: ptr<private, vec2h> = &vp7.whole;
  fn0(length(vec3f(unconst_f32(0.2542), unconst_f32(0.7007), unconst_f32(0.3141))));
  let vf66: u32 = pack2x16unorm(vec2f(unconst_f32(0.02464), unconst_f32(0.3209)));
  let vf67: vec2f = unpack2x16snorm(u32(unconst_u32(426)));
  let ptr37 = &vp7;
  var vf68: vec2f = unpack2x16snorm(u32(unconst_u32(124)));
  var vf69: f32 = vf67[u32(unconst_u32(291))];
  fn0(f32(pack4xU8Clamp(min(vec4u(unconst_u32(10), unconst_u32(35), unconst_u32(70), unconst_u32(68)), vec4u(unconst_u32(28), unconst_u32(279), unconst_u32(295), unconst_u32(6))))));
  let vf70: u32 = vf65;
  out.f0 *= vec4f(vf67[u32(unconst_u32(107))]);
  out = FragmentOutput3(vec4f(vf68[u32(unconst_u32(0))]));
  var vf71 = fn0(vf63[unconst_i32(0)].g);
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let computePassEncoder14 = commandEncoder13.beginComputePass({label: '\udc72\u069c\u3873\u8ce0\uea01\u{1f94d}\ub882\ub504\u{1f685}'});
await gc();
let imageData0 = new ImageData(72, 8);
let commandEncoder15 = device0.createCommandEncoder({});
let computePassEncoder15 = commandEncoder15.beginComputePass({label: '\u0c9f\u{1fad8}\ue082\u8968\u3f9e\ua598\u3acd\u1b7f\u0f7e\uc2a7'});
try {
computePassEncoder0.setBindGroup(2, bindGroup3);
} catch {}
let commandEncoder16 = device0.createCommandEncoder({});
let textureView16 = texture12.createView({});
let computePassEncoder16 = commandEncoder16.beginComputePass();
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
await gc();
let commandEncoder17 = device0.createCommandEncoder({});
try {
computePassEncoder12.setBindGroup(1, bindGroup0, []);
} catch {}
try {
computePassEncoder14.setBindGroup(2, bindGroup1, new Uint32Array(2299), 274, 0);
} catch {}
let imageBitmap1 = await createImageBitmap(videoFrame1);
let buffer14 = device0.createBuffer({
  size: 11422,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder18 = device0.createCommandEncoder({label: '\uc20c\ue56d\ud8c4'});
let texture23 = device0.createTexture({
  size: {width: 135, height: 7, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture24 = device0.createTexture({
  label: '\u7c48\u0089\u029c\u41e1\u6457\u{1f6b6}\u0d33\uaa62\u09aa\u{1fde9}\u7f95',
  size: {width: 68, height: 15, depthOrArrayLayers: 32},
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView17 = texture6.createView({label: '\u0717\u0cbb\u2b00\u{1f6ea}\u5300\u0ecb\u{1fd02}'});
let computePassEncoder17 = commandEncoder17.beginComputePass({label: '\u0352\u72f1\uc1c5\u0a30'});
try {
computePassEncoder11.setBindGroup(1, bindGroup0, new Uint32Array(2312), 192, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(171).fill(173), /* required buffer size: 171 */
{offset: 171}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout2 = device0.createBindGroupLayout({
  label: '\uf37d\u6cc0\u87c5',
  entries: [
    {
      binding: 221,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let buffer15 = device0.createBuffer({size: 1556, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture25 = device0.createTexture({
  size: [136, 30, 100],
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder9.setBindGroup(2, bindGroup4);
} catch {}
try {
commandEncoder18.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1952 */
  offset: 1952,
  buffer: buffer9,
}, {
  texture: texture17,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
let canvas0 = document.createElement('canvas');
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte432', transfer: 'bt2020_10bit'} });
let buffer16 = device0.createBuffer({
  size: 25053,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder19 = device0.createCommandEncoder({});
let textureView18 = texture18.createView({dimension: 'cube-array', arrayLayerCount: 6});
let texture26 = device0.createTexture({
  size: [12, 1, 1],
  sampleCount: 1,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder18 = commandEncoder19.beginComputePass({});
let renderPassEncoder0 = commandEncoder18.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -501.3, g: 365.3, b: 184.6, a: 364.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet3,
});
let sampler12 = device0.createSampler({
  label: '\u{1fc7d}\u{1f9ea}\u{1f8e3}\u026b\u1899\uac21\u{1fe60}\u3d59\ud19a\u5649\u10db',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 18.78,
  lodMaxClamp: 33.16,
});
try {
computePassEncoder1.setBindGroup(2, bindGroup4);
} catch {}
try {
renderPassEncoder0.setViewport(35.608517494702845, 1.7719566696739941, 9.845761656604282, 2.6816562923298393, 0.5909633159614219, 0.6304618206631893);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let sampler13 = device0.createSampler({
  label: '\u{1fc21}\u0ca4\u{1fb8b}\u0a4f\u8cd0\u51c7',
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 91.16,
  compare: 'less-equal',
});
let texture27 = device0.createTexture({size: [68], dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_SRC});
let textureView19 = texture27.createView({});
let sampler14 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 41.31,
  maxAnisotropy: 7,
});
try {
computePassEncoder13.setBindGroup(3, bindGroup2, []);
} catch {}
try {
computePassEncoder18.setBindGroup(2, bindGroup5, new Uint32Array(162), 18, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder0.setStencilReference(211);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.append(canvas0);
let bindGroup6 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 183, resource: textureView13}]});
let buffer17 = device0.createBuffer({size: 15393, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
try {
computePassEncoder14.end();
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(5);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer5, 'uint32', 2_300, 61);
} catch {}
try {
commandEncoder13.copyBufferToBuffer(buffer0, 12, buffer1, 136, 216);
} catch {}
let imageData1 = new ImageData(28, 4);
let bindGroup7 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView18}]});
let textureView20 = texture6.createView({baseMipLevel: 0});
let computePassEncoder19 = commandEncoder13.beginComputePass({});
try {
computePassEncoder13.setBindGroup(3, bindGroup6);
} catch {}
try {
computePassEncoder15.setBindGroup(3, bindGroup2, new Uint32Array(853), 8, 0);
} catch {}
let pipeline0 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule2}});
let gpuCanvasContext1 = canvas0.getContext('webgpu');
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpteSt4281', transfer: 'unspecified'} });
let texture28 = device0.createTexture({
  size: [210, 5, 44],
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView21 = texture19.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 12});
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup5);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView22 = texture22.createView({aspect: 'all', baseArrayLayer: 4, arrayLayerCount: 6});
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer5, 0, 1_022);
} catch {}
let pipeline1 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule3,
  constants: {},
  targets: [{
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'zero', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.ALPHA,
}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 1728,
        stepMode: 'instance',
        attributes: [{format: 'sint16x4', offset: 96, shaderLocation: 10}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let img0 = await imageWithData(63, 111, '#10101010', '#20202020');
let commandEncoder20 = device0.createCommandEncoder({label: '\u{1fa7e}\u6356\ube8a\uffec'});
let textureView23 = texture9.createView({dimension: '2d', baseArrayLayer: 0});
let computePassEncoder20 = commandEncoder20.beginComputePass();
try {
computePassEncoder7.setBindGroup(3, bindGroup6);
} catch {}
try {
computePassEncoder8.setBindGroup(3, bindGroup0, new Uint32Array(276), 15, 0);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(8);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer16, 'uint16', 1_436, 12_203);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(3, buffer8, 340, 398);
} catch {}
let imageData2 = new ImageData(12, 48);
let textureView24 = texture21.createView({mipLevelCount: 1, baseArrayLayer: 0});
let textureView25 = texture13.createView({label: '\u0801\u04fe\u37cb\u72a2\ub82e\udc1f\u{1fe5b}\u7eb4', mipLevelCount: 1, arrayLayerCount: 8});
let sampler15 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 64.01,
  lodMaxClamp: 66.77,
  maxAnisotropy: 17,
});
try {
computePassEncoder20.setBindGroup(1, bindGroup6);
} catch {}
try {
computePassEncoder19.setBindGroup(1, bindGroup7, new Uint32Array(48), 2, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer5, 1_964);
} catch {}
let buffer18 = device0.createBuffer({
  size: 12338,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let texture29 = device0.createTexture({
  label: '\ub75d\u0861\u756c\u0d4e',
  size: [210, 5, 1],
  sampleCount: 4,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup6, new Uint32Array(119), 56, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 28},
  aspect: 'stencil-only',
}, new Uint8Array(4_158).fill(141), /* required buffer size: 4_158 */
{offset: 142, bytesPerRow: 251, rowsPerImage: 16}, {width: 210, height: 0, depthOrArrayLayers: 2});
} catch {}
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 15});
let texture30 = device0.createTexture({
  size: {width: 420, height: 10, depthOrArrayLayers: 3},
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '2d',
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer1, 96); };
} catch {}
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
buffer4.unmap();
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
document.body.prepend(img0);
let canvas1 = document.createElement('canvas');
let bindGroup8 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 183, resource: textureView13}]});
let commandEncoder21 = device0.createCommandEncoder({});
let sampler16 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMaxClamp: 98.24,
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder0.end();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 2,
  origin: {x: 10, y: 0, z: 12},
  aspect: 'all',
}, new Uint8Array(215_583).fill(209), /* required buffer size: 215_583 */
{offset: 15, bytesPerRow: 120, rowsPerImage: 78}, {width: 12, height: 3, depthOrArrayLayers: 24});
} catch {}
let pipeline2 = device0.createRenderPipeline({
  layout: pipelineLayout0,
  multisample: {mask: 0xe58d024},
  fragment: {
  module: shaderModule2,
  targets: [{
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'src-alpha-saturated'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'dst'},
  },
}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 140,
        stepMode: 'vertex',
        attributes: [{format: 'uint32x3', offset: 12, shaderLocation: 15}],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let commandEncoder22 = device0.createCommandEncoder();
let texture31 = device0.createTexture({
  size: {width: 1080, height: 60, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder1 = commandEncoder21.beginRenderPass({
  label: '\u0936\u{1fb52}\uaa2a\u0d91\u0e07\u0fce\u0091\u069d',
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -999.5, g: -253.1, b: -322.4, a: -941.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet3,
});
try {
computePassEncoder12.setBindGroup(1, bindGroup2, new Uint32Array(513), 92, 0);
} catch {}
try {
computePassEncoder19.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer8, 0);
} catch {}
try {
commandEncoder18.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2508 */
  offset: 2508,
  buffer: buffer3,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder22.copyTextureToBuffer({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {
  /* bytesInLastRow: 420 widthInBlocks: 420 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 3604 */
  offset: 3604,
  buffer: buffer5,
}, {width: 420, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer19 = device0.createBuffer({size: 556, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView26 = texture18.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 5, arrayLayerCount: 6});
let texture32 = device0.createTexture({
  label: '\u0a66\u05dd\u{1ffa3}\u0152\u1671\u013e',
  size: [136],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer18, 1_776); };
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer5, 'uint16', 3_372, 2_106);
} catch {}
try {
commandEncoder22.clearBuffer(buffer8, 128, 92);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(41_352).fill(9), /* required buffer size: 41_352 */
{offset: 432, bytesPerRow: 124, rowsPerImage: 55}, {width: 68, height: 0, depthOrArrayLayers: 7});
} catch {}
try {
  await promise2;
} catch {}
let imageData3 = new ImageData(12, 72);
let textureView27 = texture15.createView({});
let textureView28 = texture11.createView({dimension: '2d-array', mipLevelCount: 1});
let renderPassEncoder2 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: 987.7, g: 434.9, b: 903.8, a: 719.7, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup7, new Uint32Array(4930), 611, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer5, 'uint16', 1_878, 277);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer9);
} catch {}
try {
commandEncoder18.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1056 */
  offset: 1056,
  bytesPerRow: 38656,
  buffer: buffer1,
}, {
  texture: texture7,
  mipLevel: 1,
  origin: {x: 4, y: 1, z: 0},
  aspect: 'all',
}, {width: 7, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder18.clearBuffer(buffer0, 72, 60);
} catch {}
document.body.prepend(canvas1);
try {
globalThis.someLabel = externalTexture1.label;
} catch {}
let commandEncoder23 = device0.createCommandEncoder({label: '\u837d\u{1f7ee}\uc4da\u76aa\u939f'});
let computePassEncoder21 = commandEncoder18.beginComputePass({label: '\u{1f83a}\u36c6\u03b4\uc41a\u{1f84d}\ub220\u022d\uf18d\u9efa\u55f2'});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder18.setBindGroup(3, bindGroup6);
} catch {}
try {
computePassEncoder6.setBindGroup(2, bindGroup8, new Uint32Array(1713), 32, 0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer16, 'uint32', 11_772, 679);
} catch {}
try {
renderBundleEncoder0.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(5, buffer0, 0, 60);
} catch {}
try {
commandEncoder23.copyBufferToBuffer(buffer13, 508, buffer9, 320, 1604);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
});
} catch {}
let texture33 = device0.createTexture({
  size: [420, 10, 123],
  sampleCount: 1,
  dimension: '3d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder22 = commandEncoder23.beginComputePass({label: '\u615f\u56fa\u0edd\u4083\uf98a\u4f3d\u{1f81e}\u{1f8fa}\u{1f8a8}'});
let renderBundle0 = renderBundleEncoder0.finish({label: '\u1451\u077b\u{1fc93}\ub185\u598b\u{1f890}\u0d4e\u19fb\u4719'});
try {
renderPassEncoder2.setBindGroup(3, bindGroup6, new Uint32Array(124), 27, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer5, 'uint32', 1_680, 1_272);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 48, height: 5, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap1,
  origin: { x: 1, y: 1 },
  flipY: false,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let texture34 = device0.createTexture({
  size: [34, 7, 1],
  mipLevelCount: 5,
  sampleCount: 1,
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView29 = texture33.createView({});
let buffer20 = device0.createBuffer({
  size: 6011,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder24 = device0.createCommandEncoder();
let texture35 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 14},
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderPassEncoder3 = commandEncoder24.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: 725.0, g: 832.1, b: 945.6, a: 683.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet5,
  maxDrawCount: 25131805,
});
try {
renderPassEncoder3.setVertexBuffer(1, buffer7, 4_564);
} catch {}
let bindGroup9 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView8}, {binding: 19, resource: textureView2}],
});
let textureView30 = texture7.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
let sampler17 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 66.42,
  lodMaxClamp: 87.71,
  compare: 'always',
});
try {
computePassEncoder17.setBindGroup(0, bindGroup4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 3, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(259).fill(83), /* required buffer size: 259 */
{offset: 259, bytesPerRow: 49}, {width: 12, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
computePassEncoder7.setBindGroup(3, bindGroup4, new Uint32Array(3178), 1_078, 0);
} catch {}
try {
computePassEncoder6.end();
} catch {}
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer0, 0, 188);
} catch {}
let bindGroup10 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 183, resource: textureView24}]});
let commandEncoder25 = device0.createCommandEncoder({label: '\u{1f659}\u2762\u2621\u2db1\uc729\u399e'});
let computePassEncoder23 = commandEncoder8.beginComputePass({});
let sampler18 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 88.83,
  lodMaxClamp: 98.88,
  maxAnisotropy: 2,
});
try {
computePassEncoder3.setBindGroup(2, bindGroup1, new Uint32Array(4742), 885, 0);
} catch {}
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(6, buffer20, 0, 2_403);
} catch {}
let computePassEncoder24 = commandEncoder25.beginComputePass({});
try {
renderPassEncoder2.setBindGroup(1, bindGroup9, new Uint32Array(288), 43, 0);
} catch {}
try {
canvas1.getContext('2d');
} catch {}
try {
texture29.label = '\u8455\uffa0\u{1f8ce}\u{1fcbf}\u2a99\uecc2\u{1fa6d}\u{1f88d}\u{1fa19}\u{1f7ca}';
} catch {}
let bindGroupLayout3 = device0.createBindGroupLayout({entries: [{binding: 44, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }}]});
let buffer21 = device0.createBuffer({
  size: 12157,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView31 = texture4.createView({arrayLayerCount: 1});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], sampleCount: 1});
try {
computePassEncoder12.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder22.setBindGroup(1, bindGroup6, new Uint32Array(822), 300, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer20, 400); };
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup8, new Uint32Array(307), 31, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer18, 'uint32', 512, 758);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer8, 156, new Float32Array(1122), 5, 116);
} catch {}
let pipeline3 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule1}});
let bindGroup11 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView4}, {binding: 19, resource: textureView2}],
});
let commandEncoder26 = device0.createCommandEncoder();
let texture36 = device0.createTexture({
  size: {width: 24, height: 2, depthOrArrayLayers: 1},
  sampleCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup6, new Uint32Array(4436), 75, 0);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(7, buffer9);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup11, []);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup11, new Uint32Array(1484), 354, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'opaque',
});
} catch {}
let bindGroup12 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView31}, {binding: 477, resource: textureView17}],
});
let commandEncoder27 = device0.createCommandEncoder();
let texture37 = device0.createTexture({
  size: [24, 2, 58],
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder12.setBindGroup(0, bindGroup3, []);
} catch {}
try {
renderPassEncoder1.setViewport(43.682567897890955, 2.9032238057942306, 0.4725701753159519, 0.519927665845138, 0.7945890621992484, 0.9703459691531137);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer21, 'uint32', 5_204, 3_979);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline2);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 68 widthInBlocks: 68 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 412 */
  offset: 412,
  buffer: buffer5,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 1},
  aspect: 'stencil-only',
}, {width: 68, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpteSt4281', transfer: 'linear'} });
let commandEncoder28 = device0.createCommandEncoder();
let textureView32 = texture8.createView({mipLevelCount: 1});
try {
renderPassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(527), 49, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
try {
renderBundleEncoder1.setBindGroup(2, bindGroup12);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup9, new Uint32Array(612), 47, 0);
} catch {}
try {
commandEncoder28.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1320 */
  offset: 1320,
  buffer: buffer20,
}, {
  texture: texture7,
  mipLevel: 2,
  origin: {x: 7, y: 1, z: 0},
  aspect: 'all',
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder27.resolveQuerySet(querySet1, 49, 46, buffer20, 1280);
} catch {}
try {
commandEncoder28.insertDebugMarker('\u3b02');
} catch {}
let bindGroup13 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView31}, {binding: 477, resource: textureView20}],
});
let commandEncoder29 = device0.createCommandEncoder({});
let textureView33 = texture25.createView({dimension: '2d', baseArrayLayer: 3});
let sampler19 = device0.createSampler({
  label: '\ud8bf\ue8a3\u{1fd15}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.63,
  lodMaxClamp: 99.96,
});
try {
computePassEncoder4.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer4, 'uint32', 564, 602);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(6, buffer16, 11_476, 814);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup3);
} catch {}
document.body.prepend(img0);
await gc();
let imageData4 = new ImageData(72, 4);
let textureView34 = texture12.createView({});
let computePassEncoder25 = commandEncoder28.beginComputePass({label: '\u0cdd\u8b0a\uf348\uddc7'});
let renderBundle1 = renderBundleEncoder1.finish({});
try {
computePassEncoder24.setBindGroup(3, bindGroup3, new Uint32Array(540), 115, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0]);
} catch {}
let pipeline4 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  multisample: {count: 1},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment4',
  constants: {},
  targets: [{
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'add', srcFactor: 'dst', dstFactor: 'one-minus-src-alpha'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [{arrayStride: 0, attributes: [{format: 'uint32x4', offset: 476, shaderLocation: 15}]}],
  },
  primitive: {topology: 'line-list', cullMode: 'front'},
});
let buffer22 = device0.createBuffer({
  size: 1846,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder30 = device0.createCommandEncoder({});
let texture38 = device0.createTexture({
  size: {width: 96, height: 10, depthOrArrayLayers: 235},
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder26 = commandEncoder30.beginComputePass({});
try {
computePassEncoder9.setBindGroup(2, bindGroup13);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder2.setViewport(46.61507192403703, 4.910701527239262, 0.5580318488353053, 0.006499518007489693, 0.4956895646131082, 0.8663766335848662);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer21, 'uint16', 2_260, 1_114);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer21);
} catch {}
let texture39 = device0.createTexture({
  size: [270, 15, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler20 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 22.98,
  lodMaxClamp: 72.33,
});
try {
computePassEncoder10.setBindGroup(0, bindGroup4);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer18, 1_204); };
} catch {}
try {
computePassEncoder5.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup10, new Uint32Array(787), 5, 0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(6, undefined);
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView20}, {binding: 19, resource: textureView2}],
});
let pipelineLayout3 = device0.createPipelineLayout({label: '\u03ea\u5328\u1260\ufa82\u{1f838}\u097f\u0ff1\uf9da\u0fdf\u09f2\u0345', bindGroupLayouts: []});
let commandEncoder31 = device0.createCommandEncoder();
let computePassEncoder27 = commandEncoder29.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer8, 424); };
} catch {}
try {
computePassEncoder21.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder9.insertDebugMarker('\u{1fefa}');
} catch {}
let bindGroup15 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView17}, {binding: 19, resource: textureView2}],
});
let commandEncoder32 = device0.createCommandEncoder();
let texture40 = device0.createTexture({
  size: [16, 16, 14],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView35 = texture24.createView({aspect: 'depth-only', baseArrayLayer: 18});
try {
renderPassEncoder2.setBindGroup(0, bindGroup4, []);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(1);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle0, renderBundle1, renderBundle0, renderBundle1]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer4, 'uint32', 664, 1_302);
} catch {}
try {
commandEncoder32.clearBuffer(buffer8, 132, 52);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 8, new Int16Array(8424), 1511, 132);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 1,
  origin: {x: 4, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(339).fill(20), /* required buffer size: 339 */
{offset: 339}, {width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder2.setBindGroup(0, bindGroup5, new Uint32Array(898), 13, 0);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setViewport(0.9432530425577674, 1.5369773007166683, 2.96500846905262, 2.5445142565650856, 0.6801791919971116, 0.9565604703895998);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer10, 'uint32', 2_020, 3_671);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline4);
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 652 */
  offset: 652,
  rowsPerImage: 575,
  buffer: buffer5,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer23 = device0.createBuffer({
  size: 590,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder33 = device0.createCommandEncoder({});
let texture41 = device0.createTexture({
  size: [12, 1, 29],
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder28 = commandEncoder27.beginComputePass({label: '\u7729\uc088\u0e3d\ue552\u0e0a\u337e\u5475\ufeb7'});
let sampler21 = device0.createSampler({
  label: '\ubb62\u0043\u248d',
  addressModeU: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 94.45,
  lodMaxClamp: 98.15,
});
try {
computePassEncoder8.setBindGroup(1, bindGroup6);
} catch {}
try {
computePassEncoder26.setBindGroup(1, bindGroup4, new Uint32Array(468), 5, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer22, 56); };
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup5);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline4);
} catch {}
let commandEncoder34 = device0.createCommandEncoder();
let computePassEncoder29 = commandEncoder33.beginComputePass({});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({
  label: '\u0885\u{1f7da}\u0c16\u7d86\u027d\u95f7\u{1f9dd}\u{1fa9b}',
  colorFormats: ['bgra8unorm-srgb'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle2 = renderBundleEncoder2.finish();
try {
computePassEncoder9.setBindGroup(1, bindGroup15, new Uint32Array(924), 52, 0);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 48, height: 5, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 67, y: 19 },
  flipY: false,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 20, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup16 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 44, resource: sampler4}]});
try {
computePassEncoder18.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup3, []);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle2]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer5, 'uint32', 1_268, 3_176);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'stencil-only',
}, new Uint8Array(128_867).fill(236), /* required buffer size: 128_867 */
{offset: 137, bytesPerRow: 255, rowsPerImage: 100}, {width: 210, height: 5, depthOrArrayLayers: 6});
} catch {}
try {
computePassEncoder4.setBindGroup(0, bindGroup12);
} catch {}
try {
computePassEncoder18.setBindGroup(0, bindGroup13, new Uint32Array(8960), 3_488, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer18, 4_712); };
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(1958), 453, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer16, 'uint32', 10_148, 202);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, buffer7, 0);
} catch {}
try {
commandEncoder31.insertDebugMarker('\u3f37');
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'pq'} });
let querySet7 = device0.createQuerySet({type: 'occlusion', count: 825});
let computePassEncoder30 = commandEncoder34.beginComputePass();
let renderPassEncoder4 = commandEncoder32.beginRenderPass({colorAttachments: [{view: textureView9, loadOp: 'load', storeOp: 'discard'}]});
try {
computePassEncoder28.setBindGroup(3, bindGroup15, []);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer23, 0);
} catch {}
document.body.prepend(canvas1);
let computePassEncoder31 = commandEncoder31.beginComputePass({});
try {
commandEncoder26.copyBufferToBuffer(buffer20, 1396, buffer17, 820, 1176);
} catch {}
let buffer24 = device0.createBuffer({
  size: 20410,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView36 = texture4.createView({mipLevelCount: 1});
let texture42 = device0.createTexture({
  size: [48],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler22 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMinClamp: 49.66,
  lodMaxClamp: 54.46,
});
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer4, 12); };
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup4, new Uint32Array(8212), 6_182, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer5, 'uint16', 6_426, 1_326);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer3, 3_756, 3_940);
} catch {}
try {
adapter1.label = '\u{1fb8e}\u004b\u{1f9a3}\u{1f64b}\u054e\u7ed9\u{1fa16}\u{1fce9}\u0ab9';
} catch {}
let commandEncoder35 = device0.createCommandEncoder({label: '\u0863\u{1f9e5}\u0617\u{1fd32}\u12bc\u6585\u0af0\ud8a3\u0b33\u{1f853}\u0222'});
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 24});
let textureView37 = texture4.createView({format: 'rgba8uint'});
let computePassEncoder32 = commandEncoder35.beginComputePass({});
try {
computePassEncoder22.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup16, []);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle2]);
} catch {}
try {
commandEncoder26.copyBufferToTexture({
  /* bytesInLastRow: 456 widthInBlocks: 57 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 784 */
  offset: 784,
  bytesPerRow: 5120,
  buffer: buffer10,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 57, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder5.pushDebugGroup('\u78ad');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 1, depthOrArrayLayers: 29}
*/
{
  source: canvas1,
  origin: { x: 29, y: 23 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 13},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder36 = device0.createCommandEncoder({});
let texture43 = device0.createTexture({
  size: [34, 7, 1],
  sampleCount: 1,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView38 = texture8.createView({});
let computePassEncoder33 = commandEncoder36.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(3); };
} catch {}
try {
commandEncoder26.copyBufferToBuffer(buffer24, 2168, buffer9, 812, 740);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 4, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise1;
} catch {}
let buffer25 = device0.createBuffer({
  label: '\ue305\u020b\u8cc2\ud3b0\u2589\u{1fa27}\u08fc\u4faf\u02c3\u3fad',
  size: 18865,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView39 = texture40.createView({dimension: '2d-array', format: 'depth32float-stencil8', mipLevelCount: 1, arrayLayerCount: 5});
let computePassEncoder34 = commandEncoder26.beginComputePass({});
try {
computePassEncoder23.setBindGroup(0, bindGroup14, []);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup7, []);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle2, renderBundle1, renderBundle2]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer8, 0, 123);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, colorSpace: 'srgb'});
} catch {}
let texture44 = device0.createTexture({
  size: [1080, 60, 1],
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let sampler23 = device0.createSampler({
  label: '\u1131\uc139\ua925',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 69.16,
  lodMaxClamp: 82.12,
});
try {
computePassEncoder25.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup16, new Uint32Array(167), 30, 0);
} catch {}
try {
computePassEncoder5.popDebugGroup();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 1, depthOrArrayLayers: 29}
*/
{
  source: img0,
  origin: { x: 4, y: 33 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let bindGroup17 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 44, resource: sampler11}]});
let textureView40 = texture25.createView({dimension: '2d', baseArrayLayer: 21});
let sampler24 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 97.99,
  maxAnisotropy: 11,
});
try {
renderPassEncoder3.setBindGroup(0, bindGroup15, new Uint32Array(894), 111, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle2, renderBundle2, renderBundle1, renderBundle1, renderBundle2, renderBundle0, renderBundle0]);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer18, 'uint16', 8_814, 288);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer16, 0, 3_129);
} catch {}
let bindGroup18 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView17}, {binding: 19, resource: textureView2}],
});
let buffer26 = device0.createBuffer({
  size: 123,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture45 = device0.createTexture({
  size: {width: 1080, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView41 = texture16.createView({});
try {
computePassEncoder21.setBindGroup(2, bindGroup7, new Uint32Array(2235), 895, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder2.setStencilReference(114);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer16, 'uint32', 856, 2_498);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer0, 16);
} catch {}
let texture46 = device0.createTexture({
  label: '\u9e14\u{1fa86}\u{1fd2d}',
  size: [136, 30, 89],
  dimension: '2d',
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.pushDebugGroup('\u94bb');
} catch {}
let pipeline5 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule2, constants: {}}});
document.body.prepend(canvas0);
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(19) var st3: texture_storage_3d<rgba8uint, write>;

@group(0) @binding(477) var tex4: texture_1d<u32>;

struct T0 {
  @align(32) @size(96) f0: mat3x2f,
  @align(8) @size(32) f1: array<mat2x2h, 2>,
  @size(32) f2: u32,
  @align(32) @size(1984) f3: mat2x3h,
}

struct S2 {
  @location(6) f0: vec4f,
  @location(11) f1: i32,
  @location(8) f2: f32,
  @location(15) @interpolate(flat, center) f3: vec4f,
}

struct VertexOutput7 {
  @location(0) f15: vec4u,
  @builtin(position) f16: vec4f,
  @location(15) @interpolate(perspective, sample) f17: f32,
}

struct S3 {
  @location(15) @interpolate(perspective, sample) f0: f32,
  @builtin(sample_index) f1: u32,
}

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

alias vec3b = vec3<bool>;

@id(7363) override override0: f32;

@id(5500) override override1: u32;

@id(10124) override override2: f16;

override override3: i32;

@id(63426) override override4: u32;

override override5: f16;

@id(7828) override override6 = -0.09858;

fn fn0() {
  vw7.f0 = (*&vw6)[unconst_i32(1)].yyzx;
  vw9 *= vec2f(override6);
  vw8 -= mat2x4h(log(vec4h(unconst_f16(4726.3), unconst_f16(-3653.8), unconst_f16(24070.0), unconst_f16(22728.4))), log(vec4h(unconst_f16(4726.3), unconst_f16(-3653.8), unconst_f16(24070.0), unconst_f16(22728.4))));
  let ptr38: ptr<private, mat4x4h> = &vp8;
  vp8 = (*ptr38);
  atomicCompareExchangeWeak(&vw5, unconst_u32(109), unconst_u32(292));
  vw7.f2 += f32((*ptr38)[unconst_i32(3)][0]);
  var vf72: vec4u = textureLoad(tex4, i32(unconst_i32(57)), i32(unconst_i32(75)));
  let ptr39: ptr<workgroup, vec4f> = &vw10.f0;
  atomicAdd(&vw5, u32(unconst_u32(77)));
  vw9 *= bitcast<vec2f>((*ptr38)[u32(unconst_u32(30))]);
  var vf73: S2 = workgroupUniformLoad(&vw7);
  var vf74: f16 = vw8[u32(vw7.f2)][u32(unconst_u32(482))];
  vw7 = S2(vec4f((*&vw8)[u32(unconst_u32(185))]), i32((*&vw8)[u32(unconst_u32(185))].w), vec4f((*&vw8)[u32(unconst_u32(185))])[0], vec4f((*&vw8)[u32(unconst_u32(185))]));
  storageBarrier();
  _ = override6;
}

var<workgroup> vw5: atomic<u32>;

var<workgroup> vw6: mat2x3f;

var<workgroup> vw7: S2;

var<workgroup> vw8: mat2x4h;

var<workgroup> vw9: vec2f;

var<workgroup> vw10: FragmentOutput4;

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

var<private> vp9 = modf(f32(0.3697));

@vertex @must_use
fn vertex7(@location(4) a0: vec2i, a1: S2) -> VertexOutput7 {
  var out: VertexOutput7;
  var vf75: u32 = override1;
  var vf76: f32 = quantizeToF16(f32(unconst_f32(0.1310)));
  return out;
  _ = override1;
}

@fragment
fn fragment6(@location(0) @interpolate(flat, sample) a0: vec4u, a1: S3) -> FragmentOutput4 {
  var out: FragmentOutput4;
  var vf77: f16 = vp8[u32(unconst_u32(143))][u32(unconst_u32(314))];
  let vf78: f32 = inverseSqrt(f32(unconst_f32(0.08426)));
  vp9.whole += a1.f0;
  var vf79: vec4u = a0;
  vp8 -= mat4x4h(f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole), f16(vp9.whole));
  var vf80: f32 = inverseSqrt(f32(unconst_f32(0.00713)));
  let ptr40: ptr<function, f16> = &vf77;
  let vf81: u32 = override4;
  let ptr41 = &vp9;
  vf79 |= unpack4xU8(bitcast<u32>(round(f32(unconst_f32(0.3108)))));
  out.f0 = exp2(vec2f(unconst_f32(0.1762), unconst_f32(-0.05250))).yxxy;
  vp9.fract -= (*ptr41).fract;
  vf77 = override2;
  var vf82: f32 = a1.f0;
  out.f0 *= unpack2x16float(u32(unconst_u32(59))).grgg;
  vf79 = vec4u(bitcast<u32>(override0));
  let ptr42: ptr<function, f32> = &vf80;
  let vf83: vec2f = unpack2x16float(u32(unconst_u32(268)));
  let vf84: vec2h = asinh(vec2h(unconst_f16(7290.9), unconst_f16(21517.1)));
  vp8 = mat4x4h(f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1), f16(a1.f1));
  vf79 = unpack4xU8(u32(inverseSqrt(f32(unconst_f32(1.000)))));
  return out;
  _ = override4;
  _ = override2;
  _ = override0;
}

@compute @workgroup_size(1, 1, 1)
fn compute2(@builtin(local_invocation_index) a0: u32) {
  fn0();
  vw10.f0 = vec4f(bitcast<f32>(workgroupUniformLoad(&vw7).f1));
  var vf85: vec2f = unpack2x16unorm(u32(unconst_u32(63)));
  textureStore(st3, vec3i(unconst_i32(144), unconst_i32(228), unconst_i32(504)), vec4u(vec4u(unconst_u32(6), unconst_u32(197), unconst_u32(141), unconst_u32(305))));
  vp8 = mat4x4h(bitcast<vec4h>(vf85), bitcast<vec4h>(vf85), bitcast<vec4h>(vf85), bitcast<vec4h>(vf85));
  vw8 = mat2x4h(vp8[u32(unconst_u32(5))], vp8[u32(unconst_u32(5))]);
  let ptr43 = &vp9;
  vw10 = FragmentOutput4(vec4f(f32((*&vw8)[u32(unconst_u32(13))][u32(unconst_u32(83))])));
  var vf86: u32 = textureDimensions(tex4, 0i);
  vw8 += mat2x4h(bitcast<vec4h>(unpack2x16unorm(bitcast<u32>(vw7.f3[u32(unconst_u32(124))]))), bitcast<vec4h>(unpack2x16unorm(bitcast<u32>(vw7.f3[u32(unconst_u32(124))]))));
  vf85 = (*&vw6)[u32(unconst_u32(63))].rg;
  let ptr44: ptr<workgroup, i32> = &(*&vw7).f1;
  vf85 = unpack2x16snorm(a0);
  let ptr45: ptr<workgroup, vec4f> = &vw7.f0;
  vw10 = FragmentOutput4(unpack4x8snorm(atomicLoad(&(*&vw5))));
  fn0();
  atomicSub(&vw5, u32((*&vw8)[u32(unconst_u32(32))][u32((*&vw7).f0[bitcast<u32>(workgroupUniformLoad(&vw6)[unconst_i32(1)].x)])]));
  fn0();
  atomicXor(&vw5, u32(unconst_u32(98)));
  let ptr46 = &vp9;
  vw8 -= mat2x4h(f16(all(bool((*ptr43).whole))), f16(all(bool((*ptr43).whole))), f16(all(bool((*ptr43).whole))), f16(all(bool((*ptr43).whole))), f16(all(bool((*ptr43).whole))), f16(all(bool((*ptr43).whole))), f16(all(bool((*ptr43).whole))), f16(all(bool((*ptr43).whole))));
  _ = override6;
}

@compute @workgroup_size(3, 1, 3)
fn compute3() {
  vw7 = S2(vw10.f0, bitcast<vec4i>(vw10.f0).w, vw10.f0[2], vw10.f0);
  vw8 = mat2x4h(f16(atomicLoad(&vw5)), f16(atomicLoad(&vw5)), f16(atomicLoad(&vw5)), f16(atomicLoad(&vw5)), f16(atomicLoad(&vw5)), f16(atomicLoad(&vw5)), f16(atomicLoad(&vw5)), f16(atomicLoad(&vw5)));
  fn0();
  fn0();
  fn0();
  var vf87: f16 = override2;
  fn0();
  let ptr47: ptr<workgroup, vec4f> = &vw7.f3;
  textureStore(st3, clamp(vec2i(unconst_i32(61), unconst_i32(67)), vec2i(unconst_i32(163), unconst_i32(71)), vec2i(unconst_i32(103), unconst_i32(38))).yyy, vec4u(vec4u(vw6[unconst_i32(1)].yzyz)));
  atomicOr(&vw5, u32(unconst_u32(98)));
  let vf88: vec3i = sign(vec3i(unconst_i32(103), unconst_i32(-7), unconst_i32(142)));
  vw7.f1 ^= bitcast<i32>((*&vw7).f2);
  let ptr48: ptr<private, mat4x4h> = &vp8;
  var vf89: vec4h = vp8[u32(unconst_u32(335))];
  fn0();
  var vf90: vec3i = vf88;
  vp9.whole = bitcast<f32>(textureDimensions(tex4));
  fn0();
  _ = override2;
  _ = override6;
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup19 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 44, resource: sampler11}]});
let buffer27 = device0.createBuffer({size: 134, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder37 = device0.createCommandEncoder();
let texture47 = device0.createTexture({
  label: '\u75f5\u1bc3\ue8ef\u88d7\u0f27\u69c0\u{1fcd3}\u018f\u7f41\u16c6',
  size: [135, 7, 18],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let texture48 = gpuCanvasContext1.getCurrentTexture();
let sampler25 = device0.createSampler({
  label: '\u{1fda7}\u0951\uf8d3\ud0ab',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 97.60,
  lodMaxClamp: 99.79,
  maxAnisotropy: 9,
});
try {
renderPassEncoder3.setBindGroup(0, bindGroup2, new Uint32Array(329), 6, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
buffer2.unmap();
} catch {}
try {
renderPassEncoder4.popDebugGroup();
} catch {}
try {
  await promise3;
} catch {}
let textureView42 = texture40.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 2});
try {
computePassEncoder1.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle2, renderBundle1, renderBundle0]);
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte170m', transfer: 'gamma22curve'} });
let commandEncoder38 = device0.createCommandEncoder({label: '\u06cf\u0f77\u{1fdf2}\u{1fdae}\u00a0\u51df'});
try {
computePassEncoder11.setBindGroup(0, bindGroup18);
} catch {}
try {
computePassEncoder10.setBindGroup(0, bindGroup14, new Uint32Array(938), 390, 0);
} catch {}
try {
commandEncoder37.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 384 */
  offset: 384,
  buffer: buffer9,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder37.copyTextureToBuffer({
  texture: texture21,
  mipLevel: 3,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 26 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1808 */
  offset: 1808,
  buffer: buffer9,
}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 17, height: 3, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture34,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture49 = device0.createTexture({
  size: [105, 2, 29],
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder35 = commandEncoder37.beginComputePass({});
try {
computePassEncoder10.setBindGroup(3, bindGroup6, new Uint32Array(3911), 579, 0);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer1, 'uint16', 1_940, 36);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline2);
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1000 */
  offset: 1000,
  bytesPerRow: 7680,
  buffer: buffer2,
}, {
  texture: texture17,
  mipLevel: 0,
  origin: {x: 27, y: 5, z: 0},
  aspect: 'all',
}, {width: 11, height: 4, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let canvas2 = document.createElement('canvas');
try {
computePassEncoder9.setPipeline(pipeline3);
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 1752 widthInBlocks: 219 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 552 */
  offset: 552,
  bytesPerRow: 5120,
  rowsPerImage: 2351,
  buffer: buffer1,
}, {
  texture: texture45,
  mipLevel: 0,
  origin: {x: 360, y: 1, z: 0},
  aspect: 'all',
}, {width: 219, height: 22, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder38.resolveQuerySet(querySet1, 167, 199, buffer21, 2560);
} catch {}
try {
device0.queue.writeBuffer(buffer18, 1672, new DataView(new ArrayBuffer(34056)), 9436, 68);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup20 = device0.createBindGroup({
  label: '\uc7b6\ua223\ud3ed\u0a47\u8d64\u1b06',
  layout: bindGroupLayout3,
  entries: [{binding: 44, resource: sampler17}],
});
let buffer28 = device0.createBuffer({
  size: 11410,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder39 = device0.createCommandEncoder();
let renderPassEncoder5 = commandEncoder38.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -292.9, g: 118.4, b: -131.4, a: 878.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder13.setBindGroup(0, bindGroup8);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup19, new Uint32Array(1591), 194, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
commandEncoder39.clearBuffer(buffer9, 264, 2476);
} catch {}
try {
commandEncoder39.insertDebugMarker('\uaf50');
} catch {}
let textureView43 = texture17.createView({mipLevelCount: 1});
let computePassEncoder36 = commandEncoder39.beginComputePass();
try {
computePassEncoder15.setBindGroup(3, bindGroup13, new Uint32Array(515), 218, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroups(1, 2); };
} catch {}
try {
computePassEncoder33.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup7);
} catch {}
let commandEncoder40 = device0.createCommandEncoder({});
let computePassEncoder37 = commandEncoder40.beginComputePass({});
let sampler26 = device0.createSampler({
  label: '\u93e9\u{1fdcf}\u2838\u0bbc\u4b99\u{1f966}\uafbe\u2f75\u4402\u01b4\u056d',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 0.1928,
  lodMaxClamp: 18.99,
});
try {
computePassEncoder20.setBindGroup(0, bindGroup15);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer20);
} catch {}
try {
computePassEncoder37.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setViewport(0.6773354320106382, 4.220681108427031, 43.058770057292016, 0.5214407581885526, 0.07049414642276342, 0.5667854342382059);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer8);
} catch {}
let pipeline6 = device0.createComputePipeline({
  label: '\uc380\u0763\uddce\u7081\ub695\u3ba9\ud46d\u7e88\u288c\u058e',
  layout: pipelineLayout2,
  compute: {module: shaderModule2},
});
let pipeline7 = device0.createRenderPipeline({
  label: '\u0924\u{1f821}\u47d5\u017f\u544c\ufe3b\u4a47\u0069\uac82\u7921',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment3',
  constants: {},
  targets: [{format: 'rg32uint', writeMask: 0}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilFront: {compare: 'not-equal', failOp: 'decrement-wrap', depthFailOp: 'zero', passOp: 'decrement-clamp'},
    stencilBack: {
      compare: 'less-equal',
      failOp: 'decrement-clamp',
      depthFailOp: 'increment-wrap',
      passOp: 'increment-wrap',
    },
    stencilReadMask: 485073821,
    stencilWriteMask: 113796908,
    depthBiasClamp: 662.6345311941603,
  },
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {
        arrayStride: 144,
        stepMode: 'instance',
        attributes: [{format: 'uint8x2', offset: 4, shaderLocation: 15}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front', unclippedDepth: true},
});
document.body.prepend(img0);
let buffer29 = device0.createBuffer({
  size: 304,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture50 = device0.createTexture({
  label: '\u{1f8b7}\ua356\u0cc9\u6ce1',
  size: [210, 5, 1],
  mipLevelCount: 1,
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder15.setBindGroup(3, bindGroup4, new Uint32Array(206), 19, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup4, new Uint32Array(630), 29, 0);
} catch {}
try {
renderPassEncoder4.setViewport(13.253253285367135, 3.337638263294353, 6.341530011551211, 0.36879818211940335, 0.22532187523576463, 0.5505559271203089);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup21 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 44, resource: sampler17}]});
let buffer30 = device0.createBuffer({size: 4028, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let sampler27 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 78.12,
  lodMaxClamp: 81.49,
  maxAnisotropy: 14,
});
try {
computePassEncoder31.setBindGroup(1, bindGroup20, new Uint32Array(1482), 147, 0);
} catch {}
try {
computePassEncoder15.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer4, 'uint16', 624, 91);
} catch {}
let pipeline8 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment2',
  constants: {},
  targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilFront: {compare: 'less-equal', depthFailOp: 'increment-wrap', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'equal', failOp: 'zero', depthFailOp: 'decrement-clamp', passOp: 'increment-wrap'},
    stencilReadMask: 2661882186,
    stencilWriteMask: 310314414,
    depthBias: -1153214259,
    depthBiasClamp: 464.789293859621,
  },
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex5',
    constants: {},
    buffers: [
      {
        arrayStride: 88,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 4, shaderLocation: 5},
          {format: 'snorm16x4', offset: 8, shaderLocation: 14},
          {format: 'snorm16x2', offset: 4, shaderLocation: 12},
          {format: 'float32x3', offset: 4, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {cullMode: 'back'},
});
let gpuCanvasContext2 = canvas2.getContext('webgpu');
let imageData5 = new ImageData(16, 36);
let commandEncoder41 = device0.createCommandEncoder({});
let textureView44 = texture10.createView({dimension: '2d-array'});
let renderPassEncoder6 = commandEncoder41.beginRenderPass({
  colorAttachments: [{
  view: textureView44,
  clearValue: { r: -609.5, g: 248.2, b: -249.8, a: -32.34, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 234359156,
});
let sampler28 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', mipmapFilter: 'nearest', lodMinClamp: 11.57});
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder10.end();
} catch {}
try {
commandEncoder10.copyTextureToTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 12, y: 12, z: 0},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 0,
  origin: {x: 104, y: 4, z: 0},
  aspect: 'all',
},
{width: 8, height: 16, depthOrArrayLayers: 0});
} catch {}
let pipeline9 = device0.createRenderPipeline({
  layout: pipelineLayout0,
  fragment: {module: shaderModule1, entryPoint: 'fragment3', constants: {}, targets: [{format: 'rg32uint'}]},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilFront: {
      compare: 'greater-equal',
      failOp: 'decrement-clamp',
      depthFailOp: 'decrement-clamp',
      passOp: 'decrement-wrap',
    },
    stencilBack: {failOp: 'decrement-clamp', depthFailOp: 'decrement-wrap', passOp: 'decrement-wrap'},
    stencilReadMask: 4294967295,
    stencilWriteMask: 4294967295,
    depthBiasSlopeScale: 504.3318711243528,
  },
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex6',
    buffers: [
      {
        arrayStride: 32,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 0, shaderLocation: 0},
          {format: 'snorm8x4', offset: 0, shaderLocation: 9},
          {format: 'unorm8x2', offset: 0, shaderLocation: 7},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 11},
          {format: 'sint16x4', offset: 0, shaderLocation: 8},
          {format: 'snorm16x2', offset: 0, shaderLocation: 15},
          {format: 'sint32x3', offset: 0, shaderLocation: 6},
          {format: 'snorm8x2', offset: 0, shaderLocation: 14},
          {format: 'sint32x3', offset: 4, shaderLocation: 2},
          {format: 'sint32x2', offset: 4, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 124,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x2', offset: 12, shaderLocation: 13},
          {format: 'snorm16x2', offset: 0, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front', unclippedDepth: true},
});
try {
adapter0.label = '\ud96c\u012b\u{1fa1d}\u0334\u364c\u7f2d\u089f\u04d7\u{1fd08}';
} catch {}
let bindGroup22 = device0.createBindGroup({
  label: '\u{1fade}\u07bf',
  layout: bindGroupLayout2,
  entries: [{binding: 221, resource: textureView18}],
});
let textureView45 = texture8.createView({format: 'bgra8unorm-srgb'});
let computePassEncoder38 = commandEncoder10.beginComputePass({label: '\u0456\u801e\u{1fe8c}\ud6c5\u17d8\u{1fdfc}\u0c0c\uc346\u7685\ua750\u03d9'});
let sampler29 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 7.523,
  lodMaxClamp: 44.31,
  maxAnisotropy: 8,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup13);
} catch {}
try {
computePassEncoder19.setBindGroup(0, bindGroup22, new Uint32Array(978), 56, 0);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup16, new Uint32Array(1848), 1_455, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer18, 'uint32', 1_656, 9);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline4);
} catch {}
try {
device0.queue.writeBuffer(buffer17, 5096, new Float32Array(5162), 374, 656);
} catch {}
let bindGroup23 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView26}]});
let commandEncoder42 = device0.createCommandEncoder({});
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 175});
let computePassEncoder39 = commandEncoder42.beginComputePass({});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthStencilFormat: 'depth32float-stencil8', depthReadOnly: false});
let renderBundle3 = renderBundleEncoder3.finish({});
try {
computePassEncoder38.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup19, new Uint32Array(50), 8, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer5, 'uint16', 478, 234);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(19) var st4: texture_storage_3d<rgba8uint, write>;

struct T0 {
  @align(32) @size(736) f0: atomic<i32>,
  @align(8) @size(2944) f1: array<u32>,
}

struct VertexOutput8 {
  @location(4) f18: f16,
  @builtin(position) f19: vec4f,
  @location(0) @interpolate(flat, center) f20: f32,
  @location(15) f21: vec4f,
}

struct VertexOutput9 {
  @builtin(position) f22: vec4f,
  @location(13) f23: vec2h,
}

struct VertexOutput10 {
  @location(5) @interpolate(perspective, centroid) f24: f16,
  @builtin(position) f25: vec4f,
  @location(2) @interpolate(flat, centroid) f26: vec2f,
  @location(13) f27: vec2h,
}

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

fn fn0() -> array<FragmentOutput5, 2> {
  var out: array<FragmentOutput5, 2>;
  let vf91: i32 = firstTrailingBit(i32(unconst_i32(750)));
  let vf92: vec3i = extractBits(vec3i(unconst_i32(25), unconst_i32(126), unconst_i32(-2)), u32(unconst_u32(34)), u32(unconst_u32(21)));
  var vf93: vec2f = log(vec2f(extractBits(vec3i(unconst_i32(-71), unconst_i32(34), unconst_i32(82)), u32(unconst_u32(241)), u32(unconst_u32(67))).gr));
  var vf94: i32 = firstTrailingBit(i32(unconst_i32(22)));
  let vf95: i32 = firstTrailingBit(i32(unconst_i32(67)));
  let vf96: f32 = vf93[u32(unconst_u32(144))];
  var vf97: i32 = firstTrailingBit(i32(unconst_i32(696)));
  vf94 += vec2i(log(vec2f(unconst_f32(0.08314), unconst_f32(0.3170)))).y;
  vf93 = log(bitcast<vec2f>(vf92.xx));
  var vf98: vec3i = vf92;
  vf93 = vf93;
  vf93 *= log(vec2f(unconst_f32(0.01029), unconst_f32(0.03109)));
  vf93 = vec2f(extractBits(vec3i(unconst_i32(76), unconst_i32(656), unconst_i32(6)), u32(unconst_u32(176)), u32(unconst_u32(173))).bg);
  var vf99: i32 = vf95;
  let ptr49: ptr<function, i32> = &vf99;
  var vf100: vec2f = log(vec2f(unconst_f32(0.04355), unconst_f32(-0.1339)));
  vf98 ^= vec3i(firstTrailingBit(i32(unconst_i32(22))));
  out[u32(unconst_u32(198))] = FragmentOutput5(vec4f(bitcast<f32>(vf94)));
  var vf101: f32 = vf100[u32(unconst_u32(194))];
  out[1] = FragmentOutput5(vf93.gggg);
  return out;
}

fn fn1(a0: ptr<storage, atomic<u32>, read_write>) -> array<array<FragmentOutput5, 1>, 1> {
  var out: array<array<FragmentOutput5, 1>, 1>;
  var vf102: vec3h = min(vec3h(unconst_f16(-9125.8), unconst_f16(5611.6), unconst_f16(7817.8)), vec3h(unconst_f16(14544.1), unconst_f16(9990.6), unconst_f16(4603.8)));
  var vf103: vec2i = reverseBits(vec2i(unconst_i32(142), unconst_i32(176)));
  var vf104: u32 = pack4xI8(vec4i(unconst_i32(19), unconst_i32(-56), unconst_i32(388), unconst_i32(236)));
  let vf105: f16 = vf102[u32(unconst_u32(682))];
  out[0][u32(unconst_u32(214))] = FragmentOutput5(sin(vec2f(unconst_f32(0.1473), unconst_f32(0.9314))).yxxx);
  var vf106: u32 = pack4xI8(vec4i(unconst_i32(202), unconst_i32(38), unconst_i32(298), unconst_i32(129)));
  return out;
}

fn fn2() {
  textureStore(st4, vec3i(unconst_i32(49), unconst_i32(57), unconst_i32(257)), vec4u(vec4u(unconst_u32(95), unconst_u32(280), unconst_u32(364), unconst_u32(56))));
  textureStore(st4, vec3i(mix(vec4h(unconst_f16(-10153.8), unconst_f16(-4267.9), unconst_f16(15762.6), unconst_f16(6694.1)), vec4h(unconst_f16(22283.9), unconst_f16(32495.6), unconst_f16(17802.4), unconst_f16(10012.9)), f16(unconst_f16(-6792.4))).grr), vec4u(vec4u(unconst_u32(146), unconst_u32(73), unconst_u32(55), unconst_u32(107))));
  textureStore(st4, vec3i(transpose(mat2x2h())[unconst_i32(0)].xxx), vec4u(vec4u(unconst_u32(575), unconst_u32(25), unconst_u32(76), unconst_u32(35))));
  textureStore(st4, vec3i(unconst_i32(119), unconst_i32(12), unconst_i32(108)), vec4u(vec4u(unconst_u32(67), unconst_u32(96), unconst_u32(99), unconst_u32(113))));
  textureStore(st4, vec3i(unconst_i32(-169), unconst_i32(-41), unconst_i32(414)), vec4u(vec4u(unconst_u32(91), unconst_u32(117), unconst_u32(130), unconst_u32(218))));
  textureStore(st4, vec3i(unconst_i32(122), unconst_i32(495), unconst_i32(174)), vec4u(vec4u(clamp(vec4h(unconst_f16(-17239.0), unconst_f16(12060.5), unconst_f16(7696.6), unconst_f16(9164.2)), vec4h(unconst_f16(-3659.0), unconst_f16(27996.0), unconst_f16(5987.4), unconst_f16(15519.3)), vec4h(unconst_f16(15325.1), unconst_f16(8579.5), unconst_f16(-2149.6), unconst_f16(52355.3))))));
  fn0();
  fn0();
  var vf107: f16 = sign(f16(unconst_f16(14005.1)));
  vf107 = f16(inverseSqrt(f32(unconst_f32(0.00299))));
  vf107 = f16(unpack4xI8(u32(unconst_u32(9)))[0]);
  let vf108: u32 = pack2x16unorm(vec2f(unconst_f32(-0.03340), unconst_f32(0.2155)));
  fn0();
}

var<workgroup> vw11: array<VertexOutput10, 1>;

@vertex
fn vertex8(@location(1) @interpolate(flat, sample) a0: vec2i, @location(9) @interpolate(perspective) a1: vec4f) -> VertexOutput8 {
  var out: VertexOutput8;
  let vf109: f32 = smoothstep(f32(unconst_f32(-0.2199)), acos(vec4f(unconst_f32(0.00847), unconst_f32(-0.09006), unconst_f32(0.07983), unconst_f32(0.04029))).x, f32(unconst_f32(0.00526)));
  out.f20 = vec4f(atanh(vec4h(unconst_f16(2536.4), unconst_f16(-24281.2), unconst_f16(1926.5), unconst_f16(-8512.3))))[0];
  out.f18 = atanh(vec4h(unconst_f16(1758.5), unconst_f16(14791.0), unconst_f16(23299.6), unconst_f16(2744.4)))[3];
  var vf110: f32 = smoothstep(f32(unconst_f32(0.3369)), bitcast<f32>(a0[0]), f32(unconst_f32(0.1627)));
  let ptr50: ptr<function, f32> = &vf110;
  let vf111: vec4f = unpack4x8snorm(u32(unconst_u32(93)));
  return out;
}

@vertex
fn vertex9(@location(4) @interpolate(flat, centroid) a0: vec4u, @location(14) a1: i32, @location(7) @interpolate(flat) a2: vec2u) -> VertexOutput9 {
  var out: VertexOutput9;
  out.f23 += vec2h(a2);
  let vf112: u32 = pack2x16snorm(vec2f(unconst_f32(0.2833), unconst_f32(0.2014)));
  out.f23 = vec2h(smoothstep(vec4f(unconst_f32(0.04606), unconst_f32(0.05960), unconst_f32(0.09202), unconst_f32(0.2621)), vec4f(unconst_f32(0.03746), unconst_f32(0.07835), unconst_f32(0.01621), unconst_f32(-0.06880)), unpack2x16snorm(u32(unconst_u32(23))).yyyx).gb);
  let vf113: vec2f = unpack2x16snorm(u32(unconst_u32(565)));
  out.f23 -= vec2h(f16(all(vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false)))));
  out.f23 = bitcast<vec2h>(dot4U8Packed(u32(unconst_u32(33)), u32(step(f32(unconst_f32(0.3357)), unpack2x16snorm(u32(unconst_u32(171)))[0]))));
  return out;
}

@vertex
fn vertex10(@location(10) a0: f32, @location(0) @interpolate(flat, center) a1: vec4u, @location(6) a2: vec2u) -> VertexOutput10 {
  var out: VertexOutput10;
  out = VertexOutput10(f16(trunc(vec2f(unconst_f32(0.06429), unconst_f32(0.03584))).g), trunc(vec2f(unconst_f32(0.06429), unconst_f32(0.03584))).rrrg, trunc(vec2f(unconst_f32(0.06429), unconst_f32(0.03584))), vec2h(trunc(vec2f(unconst_f32(0.06429), unconst_f32(0.03584)))));
  out.f24 *= f16(a2.r);
  out.f27 = vec2h(a1.yz);
  let vf114: vec2h = faceForward(vec2h(unconst_f16(6331.5), unconst_f16(7646.4)), vec2h(unconst_f16(3677.1), unconst_f16(1186.4)), vec2h(unconst_f16(3287.4), unconst_f16(-15797.5)));
  var vf115: vec2f = unpack2x16snorm(u32(unconst_u32(6)));
  out.f27 = log2(bitcast<vec4h>(unpack2x16snorm(u32(unconst_u32(668))))).ga;
  out.f27 += vec2h(min(vec3f(unconst_f32(0.1099), unconst_f32(0.02464), unconst_f32(0.2137)), vec3f(unconst_f32(-0.07880), unconst_f32(0.2066), unconst_f32(0.1415))).zz);
  return out;
}

@fragment
fn fragment7(@builtin(sample_mask) a0: u32) -> FragmentOutput5 {
  var out: FragmentOutput5;
  fn2();
  var vf116 = fn0();
  vf116[u32(unconst_u32(115))] = vf116[1];
  let vf117: vec4i = unpack4xI8(u32(unconst_u32(331)));
  let ptr51: ptr<function, FragmentOutput5> = &vf116[u32(unconst_u32(289))];
  out.f0 *= log((*ptr51).f0.ar).rrgr;
  let ptr52: ptr<function, vec4f> = &vf116[1].f0;
  textureStore(st4, vec3i(unconst_i32(222), unconst_i32(24), unconst_i32(154)), vec4u(vec4u(unconst_u32(163), unconst_u32(517), unconst_u32(102), unconst_u32(76))));
  out.f0 = vec4f(log(vec3h(unconst_f16(6351.1), unconst_f16(6249.2), unconst_f16(18730.6))).gbrg);
  fn2();
  let ptr53: ptr<function, vec4f> = &vf116[u32(unconst_u32(165))].f0;
  let ptr54: ptr<function, vec4f> = &vf116[pack4xU8Clamp(vec4u(unconst_u32(265), unconst_u32(729), unconst_u32(296), unconst_u32(360)))].f0;
  let ptr55: ptr<function, FragmentOutput5> = &vf116[1];
  var vf118: f32 = (*ptr55).f0[u32(unconst_u32(532))];
  textureStore(st4, vec3i(unconst_i32(124), unconst_i32(78), unconst_i32(183)), vec4u(vec4u(unconst_u32(4), unconst_u32(2), unconst_u32(408), unconst_u32(43))));
  var vf119 = fn0();
  let vf120: vec2u = select(vec2u(vf116[1].f0.zy), vec2u(unconst_u32(18), unconst_u32(71)), bool(unconst_bool(true)));
  textureStore(st4, vec3i(unconst_i32(179), unconst_i32(864), unconst_i32(110)), vec4u(vec4u(unconst_u32(211), unconst_u32(152), unconst_u32(260), unconst_u32(48))));
  var vf121: vec4u = unpack4xU8(u32(unconst_u32(9)));
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder43 = device0.createCommandEncoder({});
let textureView46 = texture22.createView({label: '\ub7f6\uad2b\u{1f7cc}\uc2b9\u0c67\u0891\u{1fbc7}\ua12e\u{1fcfc}\u798e', dimension: '2d'});
let computePassEncoder40 = commandEncoder43.beginComputePass();
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(5, buffer28, 0, 410);
} catch {}
try {
buffer4.unmap();
} catch {}
let textureView47 = texture37.createView({aspect: 'all', baseMipLevel: 0});
let sampler30 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'repeat', lodMinClamp: 39.40, lodMaxClamp: 76.20});
try {
computePassEncoder8.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(12);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer23, 'uint32', 8, 58);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline2);
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

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

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

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

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

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

@group(0) @binding(19) var st5: texture_storage_3d<rgba8uint, write>;

@group(0) @binding(477) var tex6: texture_1d<u32>;

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

struct VertexOutput11 {
  @builtin(position) f28: vec4f,
}

struct FragmentOutput6 {
  @location(0) f0: vec4f,
}

alias vec3b = vec3<bool>;

@id(821) override override7: f16 = 15324.7;

override override8: u32 = 84;

override override9: f16;

override override10 = 0.1505;

fn fn0(a0: ptr<private, mat2x4h>) {
  let vf122: u32 = override8;
  _ = override8;
}

fn fn1() -> bool {
  var out: bool;
  let vf123: vec2f = unpack2x16snorm(u32(unconst_u32(361)));
  let ptr56 = &vp12[u32(unconst_u32(127))];
  return out;
}

var<workgroup> vw12: atomic<u32>;

var<workgroup> vw13: vec4<bool>;

var<workgroup> vw14: array<VertexOutput11, 14>;

var<workgroup> vw15: mat2x2h;

var<workgroup> vw16: atomic<u32>;

var<workgroup> vw17: atomic<u32>;

var<private> vp10: array<bool, 25> = array(bool(false), bool(true), bool(true), bool(false), bool(true), bool(false), bool(true), bool(true), bool(false), bool(false), bool(false), bool(true), bool(true), bool(false), bool(true), bool(true), bool(false), bool(true), bool(false), bool(false), bool(true), bool(true), bool(false), bool(true), bool(true));

var<private> vp11: FragmentOutput6 = FragmentOutput6(vec4f(0.1520, 0.1313, 0.1023, 0.1129));

var<private> vp12 = array(modf(f16(6023.9)));

var<private> vp13: array<u32, 22> = array(u32(181), u32(215), u32(264), u32(90), u32(7), u32(453), u32(195), u32(1), u32(94), u32(37), u32(68), u32(240), u32(555), u32(10), u32(20), u32(19), u32(95), u32(20), u32(69), u32(584), u32(231), u32(52));

@vertex
fn vertex11() -> VertexOutput11 {
  var out: VertexOutput11;
  vp12[u32(unconst_u32(119))].fract = f16(refract(vec4f(f32(vp12[0].fract)), vec4f(unconst_f32(0.1722), unconst_f32(0.05405), unconst_f32(0.06100), unconst_f32(-0.5951)), f32(unconst_f32(0.07013)))[3]);
  var vf124: vec4f = refract(vec4f(unconst_f32(0.01625), unconst_f32(-0.02779), unconst_f32(0.6172), unconst_f32(0.1477)), vec4f(unconst_f32(0.1345), unconst_f32(0.6400), unconst_f32(0.8087), unconst_f32(0.1075)), f32(unconst_f32(0.1498)));
  vp10[u32(unconst_u32(15))] = bool(vp12[u32(unconst_u32(189))].whole);
  vp13[u32(unconst_u32(3))] |= u32(vp12[0].whole);
  let ptr57: ptr<function, vec4f> = &vf124;
  out = VertexOutput11(unpack4x8unorm(vp13[u32(unconst_u32(375))]));
  let ptr58: ptr<private, array<u32, 22>> = &vp13;
  vp11 = FragmentOutput6(vec4f(f32(vp12[0].whole)));
  vf124 = vec4f(override10);
  return out;
  _ = override10;
}

@vertex
fn vertex12(@builtin(vertex_index) a0: u32, @location(14) a1: f16, @location(7) @interpolate(flat, center) a2: u32, @location(13) a3: vec4u, @location(3) a4: u32, @location(8) a5: u32, @location(0) @interpolate(flat, center) a6: i32, @location(6) @interpolate(flat, sample) a7: vec4i, @location(2) a8: i32, @location(12) a9: vec4i, @location(10) @interpolate(flat) a10: vec4h, @location(5) a11: i32, @location(15) @interpolate(flat) a12: vec2u, @builtin(instance_index) a13: u32, @location(1) a14: f16, @location(9) a15: f32, @location(11) @interpolate(linear) a16: f32, @location(4) @interpolate(flat) a17: vec2f) -> @builtin(position) vec4f {
  var out: vec4f;
  vp12[0] = modf(f16(a7[u32(unconst_u32(101))]));
  vp11 = FragmentOutput6(vec4f(bitcast<f32>(a7[u32(unconst_u32(212))])));
  vp11 = FragmentOutput6(vec4f(tanh(vec2h(vp12[0].whole)).xyyx));
  out = vec4f(smoothstep(f32(unconst_f32(0.1738)), f32(unconst_f32(0.4013)), f32(unconst_f32(0.2356))));
  return out;
}

@fragment
fn fragment8() -> FragmentOutput6 {
  var out: FragmentOutput6;
  vp12[vp13[21]].whole = vp12[0].fract;
  let ptr59: ptr<private, bool> = &vp10[24];
  discard;
  fn1();
  let ptr60: ptr<private, bool> = &vp10[24];
  vp12[u32(unconst_u32(93))].fract *= f16(vp13[u32((*ptr60))]);
  var vf125 = fn1();
  vf125 = (*ptr60);
  discard;
  var vf126 = fn1();
  let ptr61 = &vp12[0];
  fn1();
  let ptr62: ptr<private, u32> = &vp13[u32(unconst_u32(34))];
  return out;
}

@compute @workgroup_size(2, 1, 2)
fn compute4() {
  vw15 -= mat2x2h(f16(vp13[21]), f16(vp13[21]), f16(vp13[21]), f16(vp13[21]));
  vp13[u32(vp12[u32(unconst_u32(50))].fract)] = u32(vp12[0].fract);
  let vf127: vec4u = textureLoad(tex6, i32(unconst_i32(85)), i32(unconst_i32(138)));
  vw13 = vec4<bool>(bool(atomicLoad(&vw17)));
}`,
  hints: {},
});
let buffer31 = device0.createBuffer({size: 33485, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder44 = device0.createCommandEncoder({});
let texture51 = device0.createTexture({
  size: [210],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder41 = commandEncoder44.beginComputePass({});
try {
computePassEncoder8.setBindGroup(0, bindGroup3);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer1, 428); };
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup6, new Uint32Array(205), 80, 0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder15.insertDebugMarker('\u00f8');
} catch {}
let buffer32 = device0.createBuffer({
  size: 7115,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder28.setBindGroup(3, bindGroup16);
} catch {}
try {
computePassEncoder23.end();
} catch {}
try {
renderPassEncoder4.setScissorRect(3, 0, 14, 1);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer1, 'uint32', 24, 163);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
try {
commandEncoder8.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1128 */
  offset: 1128,
  rowsPerImage: 242,
  buffer: buffer2,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder8.copyTextureToBuffer({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 68 */
  offset: 68,
  buffer: buffer25,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 321, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 1,
  origin: {x: 6, y: 2, z: 0},
  aspect: 'all',
},
{width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder8.resolveQuerySet(querySet0, 34, 34, buffer24, 2816);
} catch {}
let bindGroup24 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView2}, {binding: 477, resource: textureView4}],
});
let buffer33 = device0.createBuffer({size: 10141, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder45 = device0.createCommandEncoder({label: '\udd33\u{1f940}\u512e\u{1f7b9}\u4866\u{1fe3d}\u08be\u596a\ub1aa'});
let texture52 = device0.createTexture({
  size: [210, 5, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder5.setBindGroup(3, bindGroup10);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup0);
} catch {}
let promise4 = shaderModule1.getCompilationInfo();
try {
commandEncoder45.copyTextureToBuffer({
  texture: texture30,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 420 widthInBlocks: 105 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 808 */
  offset: 808,
  bytesPerRow: 36608,
  buffer: buffer1,
}, {width: 105, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
document.body.prepend(canvas1);
let commandBuffer0 = commandEncoder8.finish();
let sampler31 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 36.79,
  lodMaxClamp: 43.62,
  compare: 'never',
  maxAnisotropy: 3,
});
try {
computePassEncoder37.setBindGroup(3, bindGroup6);
} catch {}
try {
computePassEncoder39.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle0, renderBundle1]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer20, 0, 608);
} catch {}
try {
commandEncoder45.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1032 */
  offset: 1032,
  buffer: buffer10,
}, {
  texture: texture45,
  mipLevel: 3,
  origin: {x: 17, y: 1, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup25 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView26}]});
let computePassEncoder42 = commandEncoder45.beginComputePass({});
try {
renderPassEncoder6.setVertexBuffer(5, buffer3, 896, 2_138);
} catch {}
try {
  await promise4;
} catch {}
try {
computePassEncoder33.setBindGroup(0, bindGroup5, new Uint32Array(497), 42, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 135, height: 7, depthOrArrayLayers: 18}
*/
{
  source: imageData4,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 7, y: 1, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 22, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let buffer34 = device0.createBuffer({
  size: 3635,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder46 = device0.createCommandEncoder();
let textureView48 = texture14.createView({});
try {
computePassEncoder4.setBindGroup(2, bindGroup19, new Uint32Array(543), 155, 0);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup0, new Uint32Array(1922), 142, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer14, 'uint32', 936, 1_178);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
commandEncoder46.copyBufferToBuffer(buffer10, 880, buffer32, 1204, 0);
} catch {}
let commandEncoder47 = device0.createCommandEncoder({});
let textureView49 = texture41.createView({arrayLayerCount: 1});
let computePassEncoder43 = commandEncoder47.beginComputePass({});
let renderPassEncoder7 = commandEncoder46.beginRenderPass({
  label: '\u8e02\u09a5\u0ef2\u5f00\ua0ed\u0ef3\u749b\u{1fc1e}\u0b76\ue722\u073d',
  colorAttachments: [{view: textureView44, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet3,
});
try {
computePassEncoder18.setBindGroup(1, bindGroup23);
} catch {}
try {
computePassEncoder43.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup1, new Uint32Array(5149), 288, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer18, 'uint16', 2_132, 668);
} catch {}
canvas0.height = 222;
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true});
let renderBundle4 = renderBundleEncoder4.finish({});
try {
computePassEncoder36.setBindGroup(1, bindGroup8, []);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup12, new Uint32Array(2433), 358, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer18, 'uint32', 276, 5_656);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
adapter0.label = '\u{1f686}\u{1faca}\u526f\u615b\u{1fe2c}\u1a9d\u6b3b\u06e9\u20dc\u0310';
} catch {}
let bindGroup26 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView26}]});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({label: '\u0a5f\u{1f96b}\u5ba1', colorFormats: ['bgra8unorm-srgb'], stencilReadOnly: true});
let sampler32 = device0.createSampler({addressModeU: 'mirror-repeat', magFilter: 'nearest', lodMinClamp: 84.62, lodMaxClamp: 95.46});
try {
computePassEncoder40.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup7, new Uint32Array(2091), 119, 0);
} catch {}
let commandEncoder48 = device0.createCommandEncoder({});
let textureView50 = texture31.createView({label: '\u{1f910}\ud49a\u013c\u9c70\u{1fae2}\u{1fdb9}\u063a\u8ffa\uf288'});
let sampler33 = device0.createSampler({
  label: '\u99b7\u0a0a\u4269\u67c7\u8b70\u00d0\u0b58\u671c\u{1fc55}\u0b91\u05c2',
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 22.51,
  lodMaxClamp: 60.52,
});
try {
computePassEncoder41.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle0, renderBundle1, renderBundle2, renderBundle4]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer18, 'uint16', 154, 30);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer8, 0, 278);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup7, new Uint32Array(969), 42, 0);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline2);
} catch {}
try {
commandEncoder48.resolveQuerySet(querySet1, 39, 68, buffer21, 1024);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(250).fill(141), /* required buffer size: 250 */
{offset: 10, bytesPerRow: 30, rowsPerImage: 1}, {width: 4, height: 0, depthOrArrayLayers: 9});
} catch {}
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder49 = device0.createCommandEncoder();
let textureView51 = texture36.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder21.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder31.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup0, new Uint32Array(142), 47, 0);
} catch {}
try {
renderPassEncoder6.setViewport(14.008697550091654, 3.656213559796095, 15.093232377304076, 0.9693818842138705, 0.37861278953435584, 0.6582804547153773);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(5, buffer8, 176);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'stencil-only',
}, new Uint8Array(92_176).fill(9), /* required buffer size: 92_176 */
{offset: 186, bytesPerRow: 115, rowsPerImage: 57}, {width: 105, height: 2, depthOrArrayLayers: 15});
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
await gc();
let commandEncoder50 = device0.createCommandEncoder({label: '\u0a23\u1b44\u08a8\u0bed\u0485\u1250\u0337\u183f\u487d\u0688\u{1fa97}'});
let computePassEncoder44 = commandEncoder48.beginComputePass();
let renderPassEncoder8 = commandEncoder49.beginRenderPass({colorAttachments: [{view: textureView47, depthSlice: 51, loadOp: 'clear', storeOp: 'store'}]});
try {
computePassEncoder17.setBindGroup(0, bindGroup16, new Uint32Array(448), 48, 0);
} catch {}
try {
renderPassEncoder6.draw(0, 98, 0, 26_599);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer26, 8);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer21, 'uint16', 1_108, 224);
} catch {}
try {
commandEncoder50.copyBufferToBuffer(buffer23, 16, buffer21, 1952, 24);
} catch {}
let computePassEncoder45 = commandEncoder50.beginComputePass({});
try {
computePassEncoder2.setBindGroup(2, bindGroup5, new Uint32Array(913), 128, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup23);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup8, new Uint32Array(1345), 106, 0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(9);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder6.drawIndexed(9, 141, 4, 579_630_410, 199_486_007);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer28, 500);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer28);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(7, buffer22, 140, 71);
} catch {}
let bindGroup27 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView18}]});
try {
computePassEncoder25.setBindGroup(3, bindGroup17);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer28, 1_440); };
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(278);
} catch {}
try {
renderPassEncoder7.setBlendConstant({ r: -986.9, g: 138.2, b: 541.9, a: -190.2, });
} catch {}
try {
renderPassEncoder6.draw(0, 108, 0, 133_177_022);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(3, buffer26, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer4, 'uint16', 376, 363);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
try {
  await promise5;
} catch {}
await gc();
let commandEncoder51 = device0.createCommandEncoder({});
let texture53 = device0.createTexture({
  label: '\u2b5a\u0267\u8392\uf175\u0e1f\ue561\u4d89\u39ad\u{1f9d5}\u{1ffac}',
  size: {width: 540, height: 30, depthOrArrayLayers: 10},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder28.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup26, new Uint32Array(306), 197, 0);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer33, 180);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer23, 'uint16', 90, 182);
} catch {}
try {
renderBundleEncoder5.setPipeline(pipeline1);
} catch {}
try {
commandEncoder51.copyBufferToBuffer(buffer24, 980, buffer5, 1888, 4620);
} catch {}
try {
commandEncoder51.copyBufferToTexture({
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 672 */
  offset: 672,
  bytesPerRow: 2304,
  buffer: buffer16,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(130).fill(198), /* required buffer size: 130 */
{offset: 130}, {width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder52 = device0.createCommandEncoder({});
let computePassEncoder46 = commandEncoder51.beginComputePass();
let renderBundle5 = renderBundleEncoder5.finish({});
let sampler34 = device0.createSampler({
  label: '\u9bf8\u4254\u3c82\ud11c\u7ae9\ua7be\ucd49\u{1fcf1}\ubc03',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 99.10,
  lodMaxClamp: 99.61,
  compare: 'always',
});
try {
computePassEncoder38.setBindGroup(3, bindGroup25);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder6.drawIndexed(0, 136, 15, 632_009_604, 1_533_097_524);
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2624 */
  offset: 2624,
  bytesPerRow: 3328,
  buffer: buffer12,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer10, 864, new Int16Array(35376), 5246, 792);
} catch {}
let commandEncoder53 = device0.createCommandEncoder({});
let sampler35 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', lodMinClamp: 41.75, lodMaxClamp: 60.62});
let externalTexture2 = device0.importExternalTexture({source: videoFrame5, colorSpace: 'srgb'});
try {
computePassEncoder17.setBindGroup(0, bindGroup22);
} catch {}
try {
computePassEncoder8.setBindGroup(1, bindGroup22, new Uint32Array(1428), 27, 0);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder1.setViewport(26.76858549246953, 0.1738117231774483, 14.355954414940419, 2.9662767601263926, 0.3098867148575647, 0.6084424384494704);
} catch {}
try {
renderPassEncoder5.draw(477, 2, 638_960_718);
} catch {}
try {
renderPassEncoder6.drawIndexed(9, 41, 1, 490_013_064, 110_398_532);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer32, 40);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer26, 12);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer24, 'uint16', 2_462, 4_397);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline2);
} catch {}
try {
device0.addEventListener('uncapturederror', e => {  e.label = device0.label; });
} catch {}
try {
computePassEncoder29.pushDebugGroup('\u01cc');
} catch {}
try {
renderPassEncoder1.insertDebugMarker('\u{1f6aa}');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView52 = texture41.createView({});
try {
renderPassEncoder7.setBindGroup(2, bindGroup25);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: -37.49, g: 408.7, b: 74.61, a: 153.9, });
} catch {}
try {
renderPassEncoder5.draw(604, 0, 755_353_291);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer5, 1_516);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline1);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
commandEncoder53.copyBufferToBuffer(buffer23, 36, buffer14, 1596, 28);
} catch {}
document.body.prepend(canvas1);
let texture54 = device0.createTexture({
  label: '\u067b\u9dca\u0066\u0839\u079b\u02cd',
  size: [270, 15, 1],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder47 = commandEncoder53.beginComputePass({});
let sampler36 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 76.94,
  lodMaxClamp: 97.95,
  compare: 'not-equal',
});
try {
{ clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup25);
} catch {}
try {
renderPassEncoder5.setBlendConstant({ r: 546.0, g: 516.5, b: -534.2, a: 951.4, });
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer32, 'uint32', 864, 374);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer16, 4_916, 3_236);
} catch {}
let texture55 = device0.createTexture({
  label: '\u0a27\u0210',
  size: [16, 16, 14],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder48 = commandEncoder52.beginComputePass({});
try {
computePassEncoder42.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup10, new Uint32Array(1103), 117, 0);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.draw(518, 0, 2_727_079_713, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer4, 256);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer16, 'uint32', 7_760, 2_763);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(4, buffer24, 4_456);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 1,
  origin: {x: 14, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(0).fill(36), /* required buffer size: 0 */
{offset: 0}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
textureView31.label = '\ua3f9\u41df\u{1fdc7}\u01a7\u0df7\u4264\ufa0c';
} catch {}
let bindGroup28 = device0.createBindGroup({
  label: '\u{1fb2e}\u{1ff24}\ud79f\u7022\u05ad\u12e7\ubfef\u0f2e',
  layout: bindGroupLayout1,
  entries: [{binding: 183, resource: textureView40}],
});
let commandEncoder54 = device0.createCommandEncoder({});
let textureView53 = texture50.createView({
  label: '\ucf58\u03b7\u48de\u{1fb5d}\u7b28\u24b2\u60e6\u49c3\u{1f986}\ud554\uc675',
  dimension: '2d-array',
  mipLevelCount: 1,
});
let texture56 = device0.createTexture({
  label: '\u0eff\ud875\uacae\u{1f62b}\u18b4\u01ad\u052e\u{1f765}\u2e9d',
  size: {width: 420, height: 10, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView54 = texture24.createView({dimension: '2d', aspect: 'stencil-only', baseMipLevel: 0, baseArrayLayer: 0});
let computePassEncoder49 = commandEncoder54.beginComputePass({});
try {
computePassEncoder44.setBindGroup(1, bindGroup25, new Uint32Array(548), 74, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer22, 96); };
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(284);
} catch {}
try {
renderPassEncoder6.drawIndexed(4, 0, 3, -1_639_614_867);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer5, 3_444);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer4, 312);
} catch {}
document.body.append(img0);
let commandEncoder55 = device0.createCommandEncoder({label: '\u{1ff32}\u9f7d\ub523\u09ca\u{1fd5a}\u{1fa90}\ub66a\u9f0e\ucd44\u482c\ua087'});
let computePassEncoder50 = commandEncoder55.beginComputePass({});
let externalTexture3 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'display-p3'});
try {
computePassEncoder5.setBindGroup(1, bindGroup21, new Uint32Array(628), 15, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder4.setScissorRect(15, 0, 8, 0);
} catch {}
try {
renderPassEncoder5.draw(334, 3, 1_046_985_745);
} catch {}
try {
renderPassEncoder6.drawIndexed(4, 0, 11, 83_753_488);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer22, 0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer28, 0);
} catch {}
let bindGroup29 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView18}]});
let buffer35 = device0.createBuffer({
  label: '\ucf67\uffa2\u{1fd71}\u0f53\u062b\u1b28',
  size: 3813,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView55 = texture46.createView({baseArrayLayer: 5, arrayLayerCount: 10});
let texture57 = device0.createTexture({
  size: {width: 270, height: 15, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder5.setBindGroup(1, bindGroup25, new Uint32Array(557), 105, 0);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder5.drawIndirect(buffer20, 1_804);
} catch {}
let buffer36 = device0.createBuffer({size: 15298, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder56 = device0.createCommandEncoder({});
let textureView56 = texture43.createView({aspect: 'depth-only', format: 'depth32float'});
let sampler37 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 57.11,
  lodMaxClamp: 72.38,
});
try {
computePassEncoder44.setBindGroup(2, bindGroup7, new Uint32Array(408), 51, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup27);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup4, new Uint32Array(2424), 118, 0);
} catch {}
try {
renderPassEncoder6.draw(482, 0, 1_529_604_984, 0);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer18, 260);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer16, 0);
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

@group(0) @binding(19) var st6: texture_storage_3d<rgba8uint, write>;

@group(0) @binding(477) var tex7: texture_1d<u32>;

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

struct VertexOutput12 {
  @location(2) @interpolate(flat, center) f29: f16,
  @builtin(position) f30: vec4f,
  @location(13) f31: f16,
  @location(4) f32: vec2f,
  @location(8) @interpolate(flat, centroid) f33: u32,
  @location(3) @interpolate(flat) f34: f32,
  @location(11) f35: f16,
}

struct FragmentOutput7 {
  @location(5) f0: vec4u,
  @location(0) @interpolate(flat) f1: vec2u,
  @builtin(frag_depth) f2: f32,
  @builtin(sample_mask) f3: u32,
}

var<workgroup> vw18: FragmentOutput7;

var<workgroup> vw19: FragmentOutput7;

var<workgroup> vw20: FragmentOutput7;

var<private> vp14: VertexOutput12 = VertexOutput12(f16(22031.8), vec4f(-0.1243, 0.1670, 0.2160, 0.07906), f16(5842.6), vec2f(0.00918, 0.2451), u32(905), f32(0.1476), f16(10185.4));

@vertex @must_use
fn vertex13(@location(3) @interpolate(flat, center) a0: f16, @builtin(instance_index) a1: u32) -> VertexOutput12 {
  var out: VertexOutput12;
  var vf128: u32 = a1;
  var vf129: f32 = degrees(f32(unconst_f32(0.05880)));
  out.f34 = f32(pack2x16float(vec2f(unconst_f32(0.3337), unconst_f32(0.05874))));
  out.f34 *= vf129;
  var vf130: f32 = vp14.f30[u32(unconst_u32(16))];
  let ptr63: ptr<private, f16> = &vp14.f31;
  vp14 = VertexOutput12(vp14.f29, vec4f(f32(vp14.f29)), vp14.f29, vec2f(f32(vp14.f29)), u32(vp14.f29), f32(vp14.f29), vp14.f29);
  var vf131: u32 = pack2x16snorm(vec2f(unconst_f32(0.07882), unconst_f32(0.01550)));
  var vf132: vec2h = floor(vec2h(unconst_f16(11611.3), unconst_f16(1379.1)));
  vf132 -= bitcast<vec2h>(vp14.f34);
  let ptr64: ptr<private, f32> = &vp14.f34;
  vf131 >>= u32(vp14.f35);
  let ptr65: ptr<function, vec2h> = &vf132;
  vf128 ^= a1;
  vf131 = u32((*ptr63));
  out.f32 += vec2f(vf130);
  out.f33 = bitcast<u32>((*ptr64));
  out.f35 *= f16(vp14.f32[1]);
  out.f32 = unpack2x16snorm(pack2x16snorm(vec2f(unconst_f32(0.1147), unconst_f32(0.07858))));
  vp14 = VertexOutput12(f16(vf130), vec4f(vf130), f16(vf130), vec2f(vf130), u32(vf130), vf130, f16(vf130));
  let ptr66: ptr<function, u32> = &vf128;
  let ptr67: ptr<private, f16> = &vp14.f29;
  out.f34 = bitcast<f32>((*ptr65));
  var vf133: vec3h = faceForward(vec3h(unconst_f16(42185.9), unconst_f16(5783.6), unconst_f16(-9175.9)), vec3h(unconst_f16(3151.6), unconst_f16(1773.7), unconst_f16(7011.2)), vec3h(unconst_f16(-5961.0), unconst_f16(18167.1), unconst_f16(3292.1)));
  let ptr68: ptr<private, f16> = &vp14.f29;
  return out;
}

@fragment
fn fragment9() -> FragmentOutput7 {
  var out: FragmentOutput7;
  textureStore(st6, vec3i(unconst_i32(8), unconst_i32(109), unconst_i32(437)), vec4u(vec4u(unconst_u32(36), unconst_u32(711), unconst_u32(13), unconst_u32(34))));
  let ptr69: ptr<private, f16> = &vp14.f31;
  let ptr70: ptr<private, vec2f> = &vp14.f32;
  out.f0 ^= vec4u(vp14.f32.rrrg);
  vp14 = VertexOutput12(f16(extractBits(vec4i(unconst_i32(31), unconst_i32(57), unconst_i32(125), unconst_i32(57)), u32(unconst_u32(120)), u32(unconst_u32(36))).r), vec4f(extractBits(vec4i(unconst_i32(31), unconst_i32(57), unconst_i32(125), unconst_i32(57)), u32(unconst_u32(120)), u32(unconst_u32(36)))), f16(extractBits(vec4i(unconst_i32(31), unconst_i32(57), unconst_i32(125), unconst_i32(57)), u32(unconst_u32(120)), u32(unconst_u32(36))).z), bitcast<vec2f>(extractBits(vec4i(unconst_i32(31), unconst_i32(57), unconst_i32(125), unconst_i32(57)), u32(unconst_u32(120)), u32(unconst_u32(36))).wx), pack4xI8Clamp(extractBits(vec4i(unconst_i32(31), unconst_i32(57), unconst_i32(125), unconst_i32(57)), u32(unconst_u32(120)), u32(unconst_u32(36)))), bitcast<f32>(extractBits(vec4i(unconst_i32(31), unconst_i32(57), unconst_i32(125), unconst_i32(57)), u32(unconst_u32(120)), u32(unconst_u32(36)))[0]), vec4h(extractBits(vec4i(unconst_i32(31), unconst_i32(57), unconst_i32(125), unconst_i32(57)), u32(unconst_u32(120)), u32(unconst_u32(36)))).b);
  let vf134: vec4f = floor(vec4f(unconst_f32(0.02271), unconst_f32(0.3850), unconst_f32(0.00592), unconst_f32(0.08523)));
  var vf135: vec2f = atanh(vec2f(unconst_f32(0.2242), unconst_f32(0.06484)));
  textureStore(st6, vec3i(unconst_i32(57), unconst_i32(24), unconst_i32(418)), vec4u(vec4u(unconst_u32(25), unconst_u32(31), unconst_u32(119), unconst_u32(151))));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute5() {
  vp14 = VertexOutput12(f16((*&vw18).f3), unpack4x8snorm((*&vw18).f3), f16((*&vw18).f3), unpack2x16snorm((*&vw18).f3), (*&vw18).f3, f32((*&vw18).f3), f16((*&vw18).f3));
  vp14.f34 = vw20.f2;
  vw20 = FragmentOutput7((*&vw18).f1.rrrr, (*&vw18).f1, bitcast<f32>((*&vw18).f1.y), (*&vw18).f1.g);
  vp14.f32 += vec2f(f32(vp14.f31));
  vw18.f2 *= pow(vec2f(unconst_f32(0.2397), unconst_f32(0.03736)), vec2f(unconst_f32(0.1147), unconst_f32(0.08505))).x;
  let ptr71: ptr<workgroup, f32> = &(*&vw18).f2;
  textureStore(st6, vec3i(unconst_i32(330), unconst_i32(62), unconst_i32(23)), vec4u(vec4u(unconst_u32(23), unconst_u32(113), unconst_u32(110), unconst_u32(157))));
  let vf136: vec3h = acos(vec3h(unconst_f16(33699.0), unconst_f16(1966.8), unconst_f16(3678.2)));
  vw19.f2 += vec4f(vw19.f0)[3];
  vw20.f0 ^= vec4u(bitcast<u32>(workgroupUniformLoad(&vw20).f2));
  let ptr72: ptr<private, VertexOutput12> = &vp14;
  vw19 = FragmentOutput7(unpack4xU8(bitcast<u32>(vw20.f2)), vec2u(bitcast<u32>(vw20.f2)), vw20.f2, u32(vw20.f2));
  let ptr73: ptr<workgroup, f32> = &(*&vw19).f2;
}`,
  sourceMap: {},
  hints: {},
});
try {
computePassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(1301), 93, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup15);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer35, 1_592);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer1, 'uint16', 232, 486);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(3, buffer29);
} catch {}
let pipeline10 = device0.createComputePipeline({
  label: '\ucf68\u{1f99c}\u8fb8\ubef3',
  layout: pipelineLayout2,
  compute: {module: shaderModule1, entryPoint: 'compute0'},
});
let bindGroup30 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView36}, {binding: 477, resource: textureView17}],
});
try {
computePassEncoder45.setBindGroup(2, bindGroup0, new Uint32Array(90), 0, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup24, []);
} catch {}
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer35, 348);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
let commandEncoder57 = device0.createCommandEncoder({});
try {
computePassEncoder48.setBindGroup(3, bindGroup26);
} catch {}
try {
computePassEncoder50.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder3.draw(52, 75, 0, 997_273_119);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer1, 36);
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3968 */
  offset: 3968,
  bytesPerRow: 33536,
  rowsPerImage: 29,
  buffer: buffer9,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 10, y: 4, z: 0},
  aspect: 'all',
}, {width: 6, height: 3, depthOrArrayLayers: 0});
} catch {}
let buffer37 = device0.createBuffer({
  label: '\u07b5\u{1f7af}\u074f',
  size: 4917,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView57 = texture49.createView({
  label: '\uea78\u8a7f\ubf56\uf564\u9c3c\u{1fdbb}\u{1fa6a}\u9ec2\u0fdf\u{1f6a9}\u{1fb0e}',
  dimension: '2d-array',
  baseArrayLayer: 3,
  arrayLayerCount: 6,
});
let computePassEncoder51 = commandEncoder56.beginComputePass();
let sampler38 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 30.68,
  lodMaxClamp: 52.10,
  maxAnisotropy: 19,
});
try {
computePassEncoder7.setBindGroup(3, bindGroup17);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup4);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup19, new Uint32Array(315), 5, 0);
} catch {}
try {
renderPassEncoder6.draw(21, 0, 1_270_333_683);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder29.popDebugGroup();
} catch {}
let texture58 = device0.createTexture({
  size: {width: 540, height: 30, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder24.setBindGroup(1, bindGroup15, []);
} catch {}
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder8.setViewport(18.603458752069574, 0.12621406185150907, 5.269336017307377, 1.3679886445797285, 0.8282437028229631, 0.9558352848515088);
} catch {}
try {
renderPassEncoder6.draw(479, 0, 619_827_492);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer34, 0, 174);
} catch {}
try {
commandEncoder24.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 580 */
  offset: 580,
  buffer: buffer28,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder38.resolveQuerySet(querySet2, 199, 226, buffer5, 1792);
} catch {}
let querySet10 = device0.createQuerySet({type: 'occlusion', count: 536});
let computePassEncoder52 = commandEncoder24.beginComputePass({});
try {
computePassEncoder35.setBindGroup(2, bindGroup26);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder6.draw(6, 0, 979_937_966);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer33, 304);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer28, 560);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer22, 356);
} catch {}
try {
buffer21.unmap();
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 840 widthInBlocks: 210 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 424 */
  offset: 424,
  bytesPerRow: 27648,
  buffer: buffer2,
}, {
  texture: texture51,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 210, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas1);
let pipelineLayout5 = device0.createPipelineLayout({label: '\uc0cb\u20cc', bindGroupLayouts: []});
let commandEncoder58 = device0.createCommandEncoder({});
let textureView58 = texture33.createView({label: '\u054e\uc4f0\u0fff\u{1ffa0}', mipLevelCount: 1});
let computePassEncoder53 = commandEncoder58.beginComputePass({});
let externalTexture4 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder9.setBindGroup(3, bindGroup22, new Uint32Array(816), 22, 0);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer18, 1_388);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer24, 'uint32', 380, 715);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer26, 44, 42);
} catch {}
try {
commandEncoder57.resolveQuerySet(querySet3, 11, 1, buffer29, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 119, y: 1, z: 4},
  aspect: 'all',
}, new Uint8Array(11_098).fill(120), /* required buffer size: 11_098 */
{offset: 62, bytesPerRow: 335, rowsPerImage: 31}, {width: 79, height: 2, depthOrArrayLayers: 2});
} catch {}
let bindGroup31 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 44, resource: sampler13}]});
let computePassEncoder54 = commandEncoder38.beginComputePass({label: '\u3492\u6293\ud6b1\u03e5\u03b5\u5e16\ue6d2\uf2fd\u{1fba1}'});
try {
computePassEncoder11.setBindGroup(0, bindGroup4, new Uint32Array(6826), 158, 0);
} catch {}
try {
computePassEncoder47.end();
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup18, new Uint32Array(1050), 187, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer33, 1_296);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
let bindGroup32 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 44, resource: sampler11}]});
let sampler39 = device0.createSampler({
  label: '\u{1fe7f}\u3989\u{1f89d}\uf1a2\u0f0c\u4122',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 35.49,
  lodMaxClamp: 64.16,
});
try {
computePassEncoder31.setBindGroup(0, bindGroup15, new Uint32Array(262), 15, 0);
} catch {}
try {
computePassEncoder34.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder7.setScissorRect(7, 0, 18, 0);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline1);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
let buffer38 = device0.createBuffer({size: 27988, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX, mappedAtCreation: false});
let commandEncoder59 = device0.createCommandEncoder({label: '\u{1fbf5}\u2155\u08ce\u4e95\u2a57\u5418\u6717\u0287'});
let texture59 = device0.createTexture({
  label: '\u07aa\u{1ffe6}\u{1f6c0}\u{1f87d}',
  size: {width: 12, height: 1, depthOrArrayLayers: 29},
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder55 = commandEncoder53.beginComputePass();
try {
computePassEncoder38.setBindGroup(0, bindGroup15, new Uint32Array(1234), 563, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder6.draw(183, 0, 1_148_347_771, 0);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer18, 1_664);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer4, 'uint32', 540, 73);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline1);
} catch {}
try {
commandEncoder57.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2804 */
  offset: 2804,
  bytesPerRow: 768,
  buffer: buffer25,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout6 = device0.createPipelineLayout({label: '\u5cbe\uc0b7\u{1fddb}\u0dc9\u{1fd4d}\u0f10\u069d', bindGroupLayouts: []});
let texture60 = device0.createTexture({
  size: {width: 420, height: 10, depthOrArrayLayers: 1},
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder56 = commandEncoder57.beginComputePass({label: '\uc2da\u77bd\uf25f\u080f\u08df\u5a87\u08d9\uee6a\u27de'});
try {
computePassEncoder32.setBindGroup(2, bindGroup19);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup18, []);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle0, renderBundle0, renderBundle2, renderBundle5]);
} catch {}
try {
renderPassEncoder6.draw(96, 0, 1_070_813_440);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer32, 1_644);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer1, 'uint32', 452, 73);
} catch {}
try {
commandEncoder59.copyBufferToTexture({
  /* bytesInLastRow: 210 widthInBlocks: 210 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 2948 */
  offset: 2948,
  buffer: buffer12,
}, {
  texture: texture30,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {width: 210, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let bindGroup33 = device0.createBindGroup({
  label: '\uc858\ucbc6\u6efe\u{1fd49}\u{1f605}\u1b77\u{1ffba}\u0891\u9948\u06a8',
  layout: bindGroupLayout3,
  entries: [{binding: 44, resource: sampler34}],
});
let commandEncoder60 = device0.createCommandEncoder({});
let computePassEncoder57 = commandEncoder60.beginComputePass({label: '\u{1fbab}\ufc9f\u0b73\u4652\u3c7a\u5239\u00ab\uba66\u070f'});
try {
computePassEncoder35.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.draw(293, 0, 2_921_879_623, 0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer18, 3_996);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(2, buffer5, 2_068, 1_180);
} catch {}
let bindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 64,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer39 = device0.createBuffer({
  size: 3669,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder61 = device0.createCommandEncoder({});
let texture61 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 14},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView59 = texture54.createView({dimension: '2d-array'});
let computePassEncoder58 = commandEncoder61.beginComputePass({label: '\u0039\u{1fd0e}\uaaf8\u4064\u1081\ue3c9'});
try {
computePassEncoder55.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.draw(257, 0, 231_120_697);
} catch {}
try {
renderPassEncoder6.drawIndexed(6, 0, 5, 145_053_872);
} catch {}
try {
commandEncoder59.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1048 */
  offset: 1048,
  bytesPerRow: 1280,
  rowsPerImage: 263,
  buffer: buffer13,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let texture62 = device0.createTexture({
  size: {width: 270, height: 15, depthOrArrayLayers: 1},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView60 = texture24.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 4});
let computePassEncoder59 = commandEncoder59.beginComputePass({});
try {
computePassEncoder4.setBindGroup(1, bindGroup20);
} catch {}
try {
computePassEncoder42.setBindGroup(2, bindGroup25, new Uint32Array(1483), 95, 0);
} catch {}
try {
computePassEncoder22.end();
} catch {}
try {
computePassEncoder49.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup23);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer8, 888);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer28, 224);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline1);
} catch {}
try {
commandEncoder23.copyTextureToTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 64, y: 4, z: 0},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 32, height: 4, depthOrArrayLayers: 0});
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
let commandEncoder62 = device0.createCommandEncoder({label: '\ua0d6\u9725\u{1f8e7}\u0e1d\u813a\u0c16\u{1ff80}\u{1f64f}'});
let texture63 = device0.createTexture({
  size: [34, 7, 1],
  mipLevelCount: 3,
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture64 = device0.createTexture({
  label: '\u0762\u09ff\ubd33\u{1fc1b}\u02d9\u6047\u8641',
  size: {width: 16},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder60 = commandEncoder62.beginComputePass({label: '\u{1f667}\u{1f985}\u237c\u0e01'});
let sampler40 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 38.95,
  lodMaxClamp: 74.25,
  maxAnisotropy: 1,
});
try {
computePassEncoder58.setBindGroup(0, bindGroup12, new Uint32Array(8), 1, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup4, new Uint32Array(224), 36, 0);
} catch {}
try {
renderPassEncoder2.setScissorRect(8, 0, 0, 0);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
try {
commandEncoder23.copyBufferToTexture({
  /* bytesInLastRow: 216 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 480 */
  offset: 480,
  bytesPerRow: 1536,
  buffer: buffer39,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 173, y: 2, z: 0},
  aspect: 'all',
}, {width: 27, height: 2, depthOrArrayLayers: 0});
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let bindGroup34 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView31}, {binding: 477, resource: textureView17}],
});
let buffer40 = device0.createBuffer({
  size: 2263,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let textureView61 = texture61.createView({dimension: '2d', aspect: 'all'});
let texture65 = gpuCanvasContext0.getCurrentTexture();
let sampler41 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'nearest', lodMaxClamp: 95.93});
let externalTexture5 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder28.setBindGroup(0, bindGroup5, new Uint32Array(253), 39, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer40, 'uint32', 132, 738);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 48, height: 5, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 5, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder63 = device0.createCommandEncoder();
let texture66 = device0.createTexture({
  size: {width: 68, height: 15, depthOrArrayLayers: 2},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder61 = commandEncoder23.beginComputePass({label: '\u0ae9\uebb0\u{1f882}\u00ef\u{1f6de}\u0648\u0397\u1459'});
let renderPassEncoder9 = commandEncoder63.beginRenderPass({
  label: '\u04ec\u59d9\u0c62\u{1fd51}\u2ffb\uc49f\u0ce0\u0a42',
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -235.0, g: -339.9, b: 566.6, a: 928.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder7.setBindGroup(0, bindGroup15);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer1, 1_180);
} catch {}
try {
buffer34.unmap();
} catch {}
try {
  await promise10;
} catch {}
let imageData6 = new ImageData(16, 72);
let texture67 = gpuCanvasContext2.getCurrentTexture();
let sampler42 = device0.createSampler({
  label: '\u0ade\u{1ff82}\u0d1c\u3c07\u0298\ua25a\u601f\u0173\u08d5\u3afd\u2b21',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 89.70,
  lodMaxClamp: 99.11,
  compare: 'greater',
});
try {
computePassEncoder51.setBindGroup(1, bindGroup28, new Uint32Array(1099), 396, 0);
} catch {}
try {
computePassEncoder2.setPipeline(pipeline3);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 4336, new Int16Array(10975), 139, 1476);
} catch {}
let buffer41 = device0.createBuffer({size: 14309, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let commandEncoder64 = device0.createCommandEncoder();
let computePassEncoder62 = commandEncoder64.beginComputePass({});
try {
computePassEncoder36.setBindGroup(0, bindGroup30, new Uint32Array(2380), 143, 0);
} catch {}
try {
computePassEncoder30.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup34, new Uint32Array(1815), 318, 0);
} catch {}
try {
renderPassEncoder6.draw(806, 0, 153_939_897);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer7, 0, 889);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 1, depthOrArrayLayers: 29}
*/
{
  source: imageBitmap0,
  origin: { x: 20, y: 14 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 6},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView62 = texture26.createView({dimension: '2d-array', aspect: 'depth-only'});
try {
computePassEncoder44.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup30, new Uint32Array(52), 9, 0);
} catch {}
try {
renderPassEncoder6.draw(118, 0, 812_530_265);
} catch {}
try {
renderPassEncoder8.drawIndexed(8, 0, 48, -2_071_536_723);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(4, buffer24, 0, 3_754);
} catch {}
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte170m', transfer: 'hlg'} });
let bindGroup35 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 44, resource: sampler31}]});
let externalTexture6 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'});
try {
computePassEncoder54.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder6.draw(16, 0, 2_470_174_208);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer16);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 17, height: 3, depthOrArrayLayers: 1}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let bindGroup36 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 64, resource: textureView61}]});
let textureView63 = texture28.createView({dimension: '2d', aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 7});
let sampler43 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMinClamp: 61.43,
  lodMaxClamp: 92.71,
});
try {
computePassEncoder38.dispatchWorkgroups(1, 3);
} catch {}
try {
computePassEncoder57.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup13, new Uint32Array(753), 14, 0);
} catch {}
try {
renderPassEncoder8.draw(238, 0, 698_158_287);
} catch {}
try {
renderPassEncoder6.drawIndexed(0, 0, 4, 276_555_585);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer28, 1_008);
} catch {}
let bindGroup37 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView4}, {binding: 19, resource: textureView31}],
});
let texture68 = device0.createTexture({
  label: '\u03a9\u00c5\u{1fa1b}\u{1f64f}',
  size: {width: 210},
  dimension: '1d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder62.setBindGroup(3, bindGroup18);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder6.drawIndexed(3, 0, 2, 166_781_096);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer9, 76);
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
let bindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 245,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let commandEncoder65 = device0.createCommandEncoder({label: '\ufb0e\ufd5e'});
let texture69 = device0.createTexture({
  size: [24, 2, 1],
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView64 = texture17.createView({baseArrayLayer: 0});
let computePassEncoder63 = commandEncoder65.beginComputePass({});
try {
computePassEncoder11.setBindGroup(0, bindGroup14, new Uint32Array(366), 134, 0);
} catch {}
try {
renderPassEncoder8.drawIndexed(7, 0, 1, 62_886_203);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(6, buffer9, 0, 33);
} catch {}
let texture70 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 199},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView65 = texture44.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder58.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder8.draw(50_442_221, 178, 338_491_294, 262_375_450);
} catch {}
let buffer42 = device0.createBuffer({size: 18648, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder66 = device0.createCommandEncoder({label: '\u{1fe75}\u5199\u{1f951}'});
let querySet11 = device0.createQuerySet({type: 'occlusion', count: 846});
let textureView66 = texture61.createView({label: '\uc4fd\ub254\uc663\uaed6', dimension: '2d', baseArrayLayer: 4});
let textureView67 = texture22.createView({dimension: '2d'});
let externalTexture7 = device0.importExternalTexture({source: videoFrame7});
try {
computePassEncoder60.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup11);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle5]);
} catch {}
try {
renderPassEncoder8.draw(914_324_888, 32, 1_544_078_344, 784_735_786);
} catch {}
try {
renderPassEncoder8.drawIndexed(108, 8, 0, 9_630_956, 1_505_893_353);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer5, 0, 2_606);
} catch {}
try {
commandEncoder66.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 620 */
  offset: 620,
  bytesPerRow: 3072,
  rowsPerImage: 243,
  buffer: buffer36,
}, {
  texture: texture40,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 5},
  aspect: 'stencil-only',
}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 48, height: 5, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 10, y: 2 },
  flipY: true,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let sampler44 = device0.createSampler({addressModeW: 'clamp-to-edge', magFilter: 'linear', minFilter: 'linear', lodMaxClamp: 51.51});
try {
computePassEncoder1.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder25.setBindGroup(0, bindGroup14, new Uint32Array(1318), 92, 0);
} catch {}
try {
computePassEncoder59.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.draw(184, 0, 776_445_818);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer26, 4);
} catch {}
try {
renderPassEncoder4.drawIndirect(buffer5, 4_508);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline2);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder66.copyTextureToTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture11,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise8;
} catch {}
let commandEncoder67 = device0.createCommandEncoder();
let textureView68 = texture22.createView({dimension: '2d', baseArrayLayer: 5});
let computePassEncoder64 = commandEncoder66.beginComputePass({});
let renderPassEncoder10 = commandEncoder67.beginRenderPass({
  colorAttachments: [{
  view: textureView47,
  depthSlice: 40,
  clearValue: { r: -665.8, g: -136.9, b: -605.3, a: -579.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet5,
});
try {
computePassEncoder48.setBindGroup(0, bindGroup14, new Uint32Array(3036), 130, 0);
} catch {}
try {
computePassEncoder61.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup26);
} catch {}
try {
renderPassEncoder4.draw(24, 0, 1_033_279_203);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer8, 348);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer34, 544, 191);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer40, 444, new BigUint64Array(4403), 637, 24);
} catch {}
let commandEncoder68 = device0.createCommandEncoder({});
let computePassEncoder65 = commandEncoder68.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer26, 52); };
} catch {}
try {
computePassEncoder45.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder4.drawIndexed(19, 0, 94, 254_801_948);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer23, 0, 56);
} catch {}
let bindGroup38 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView31}, {binding: 477, resource: textureView17}],
});
let commandEncoder69 = device0.createCommandEncoder({});
let texture71 = device0.createTexture({
  size: [1080, 60, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder66 = commandEncoder69.beginComputePass({});
try {
computePassEncoder49.setBindGroup(0, bindGroup27, new Uint32Array(1340), 158, 0);
} catch {}
try {
computePassEncoder52.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder4.end();
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer4, 168);
} catch {}
try {
commandEncoder32.copyBufferToTexture({
  /* bytesInLastRow: 105 widthInBlocks: 105 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1640 */
  offset: 1640,
  bytesPerRow: 24832,
  buffer: buffer12,
}, {
  texture: texture28,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'stencil-only',
}, {width: 105, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: []});
let computePassEncoder67 = commandEncoder32.beginComputePass();
let externalTexture8 = device0.importExternalTexture({
  label: '\u{1f7b3}\u073c\u5cfb\u0c05\u{1fed4}\u{1f63d}\u{1ff72}\u03e7\u9d07',
  source: videoFrame1,
  colorSpace: 'srgb',
});
try {
computePassEncoder37.setBindGroup(0, bindGroup5, new Uint32Array(1937), 267, 0);
} catch {}
try {
computePassEncoder62.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer4, 312);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
document.body.prepend(img0);
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'smpteSt4281'} });
let textureView69 = texture61.createView({dimension: '2d'});
let textureView70 = texture24.createView({dimension: '2d', aspect: 'all', format: 'depth32float-stencil8', baseArrayLayer: 7});
let externalTexture9 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder9.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder67.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder7.setScissorRect(4, 0, 9, 2);
} catch {}
try {
renderPassEncoder8.draw(1_326_481_160, 107, 443_885_119, 102_098_830);
} catch {}
try {
renderPassEncoder6.drawIndexed(1, 10, 2, -1_763_970_591, 1_832_279_855);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer38, 'uint16', 2_662, 1_543);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer24, 44, 5_833);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
computePassEncoder61.pushDebugGroup('\u{1fd78}');
} catch {}
let buffer43 = device0.createBuffer({size: 23393, usage: GPUBufferUsage.VERTEX});
let commandEncoder70 = device0.createCommandEncoder({});
let texture72 = device0.createTexture({
  size: {width: 105, height: 2, depthOrArrayLayers: 30},
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderPassEncoder7.setBindGroup(0, bindGroup15);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer42, 924);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer16, 'uint32', 6_132, 426);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline4);
} catch {}
try {
commandEncoder70.copyBufferToBuffer(buffer30, 436, buffer14, 2752, 12);
} catch {}
try {
commandEncoder70.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1904 */
  offset: 1904,
  bytesPerRow: 4864,
  rowsPerImage: 330,
  buffer: buffer16,
}, {
  texture: texture45,
  mipLevel: 2,
  origin: {x: 47, y: 0, z: 0},
  aspect: 'all',
}, {width: 10, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder70.copyTextureToBuffer({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 564 */
  offset: 564,
  bytesPerRow: 18944,
  buffer: buffer5,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let bindGroup39 = device0.createBindGroup({
  label: '\u095a\u705c\u0b0f\u9f36\ub775\u0fd0\udf59\u091f',
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView2}, {binding: 477, resource: textureView20}],
});
let buffer44 = device0.createBuffer({size: 1167, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder71 = device0.createCommandEncoder({label: '\u21c1\uf1c3\u6368\u0086'});
try {
computePassEncoder33.setBindGroup(2, bindGroup10);
} catch {}
try {
computePassEncoder64.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup20, new Uint32Array(9533), 888, 0);
} catch {}
document.body.prepend(img0);
let bindGroup40 = device0.createBindGroup({
  label: '\u{1fc25}\u{1fd30}\u04ba\u16b0\ud507\ueecb\u{1fb11}\u{1f612}\u9ea6\ufebb',
  layout: bindGroupLayout5,
  entries: [{binding: 245, resource: textureView40}],
});
let textureView71 = texture22.createView({
  label: '\u63ca\u{1ff22}\u13a4\u4c91\u8b6c\u{1fcf0}\u{1f728}\u0ef3\u6604\uadbe',
  dimension: '2d',
  baseArrayLayer: 16,
});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({
  label: '\u396c\u8a85\u03f2\u8f18\u{1fa4b}\u3895\u{1fee6}\u036a\u39e7',
  colorFormats: ['rg8uint'],
  depthStencilFormat: 'stencil8',
  depthReadOnly: true,
});
let renderBundle6 = renderBundleEncoder6.finish({});
let sampler45 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 72.02,
  lodMaxClamp: 72.57,
});
try {
computePassEncoder56.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup25);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer28, 4_200);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer42, 2_880);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(2, buffer0, 160, 52);
} catch {}
try {
commandEncoder70.copyBufferToBuffer(buffer30, 1244, buffer9, 1200, 4);
} catch {}
try {
commandEncoder71.copyBufferToTexture({
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 4592 */
  offset: 4592,
  rowsPerImage: 171,
  buffer: buffer3,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder71.clearBuffer(buffer29);
} catch {}
try {
device0.queue.writeBuffer(buffer23, 24, new Float32Array(15066), 582, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 540, height: 30, depthOrArrayLayers: 10}
*/
{
  source: img0,
  origin: { x: 9, y: 4 },
  flipY: true,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 105, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
  await promise11;
} catch {}
try {
computePassEncoder45.label = '\u068c\u{1f757}';
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder72 = device0.createCommandEncoder({label: '\ueae8\u4c60\u{1faf7}\ua60b\ub442\u62ab\ue379\ud18f'});
let texture73 = device0.createTexture({
  size: {width: 210, height: 5, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder34.setBindGroup(3, bindGroup35, new Uint32Array(2132), 435, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup11, new Uint32Array(336), 20, 0);
} catch {}
try {
renderPassEncoder8.draw(249_333_049, 158, 666_158_522, 113_663_744);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer4, 4);
} catch {}
try {
commandEncoder71.copyBufferToTexture({
  /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2740 */
  offset: 2740,
  bytesPerRow: 12032,
  buffer: buffer16,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer31, 25744, new BigUint64Array(26520), 1582, 60);
} catch {}
let bindGroup41 = device0.createBindGroup({
  label: '\u{1f67c}\u14cc\uc44b\ub46e\u0303\u8e9f\u{1fdd6}',
  layout: bindGroupLayout5,
  entries: [{binding: 245, resource: textureView13}],
});
let textureView72 = texture17.createView({});
try {
computePassEncoder17.setBindGroup(0, bindGroup32, new Uint32Array(3354), 210, 0);
} catch {}
try {
computePassEncoder9.end();
} catch {}
try {
computePassEncoder19.setPipeline(pipeline10);
} catch {}
try {
computePassEncoder26.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup24);
} catch {}
try {
renderPassEncoder6.draw(0, 96, 0, 369_439_205);
} catch {}
try {
renderPassEncoder6.drawIndexed(8, 61, 7, 229_694_940, 206_737_200);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer20, 952);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer32, 1_284);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline2);
} catch {}
try {
commandEncoder72.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 104 */
  offset: 104,
  bytesPerRow: 11008,
  buffer: buffer15,
}, {
  texture: texture11,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder61.popDebugGroup();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
canvas1.width = 836;
let texture74 = gpuCanvasContext0.getCurrentTexture();
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthStencilFormat: 'stencil8'});
let renderBundle7 = renderBundleEncoder7.finish({});
try {
computePassEncoder63.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder8.drawIndexedIndirect(buffer28, 2_436);
} catch {}
let bindGroup42 = device0.createBindGroup({label: '\u403d\u6223', layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView18}]});
let texture75 = device0.createTexture({
  size: {width: 270, height: 15, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'stencil8',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView73 = texture40.createView({dimension: 'cube-array', aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 6});
let computePassEncoder68 = commandEncoder72.beginComputePass();
try {
computePassEncoder41.setBindGroup(3, bindGroup19);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroupsIndirect(buffer9, 124); };
} catch {}
try {
renderPassEncoder1.setViewport(32.288406333543506, 3.267902093585559, 10.6857722508946, 1.050832690780053, 0.7932723360847694, 0.8012925861571571);
} catch {}
try {
renderPassEncoder6.draw(0, 493, 0, 838_430_855);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(5, buffer26, 4, 4);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 788, new BigUint64Array(9669), 1151, 584);
} catch {}
let texture76 = device0.createTexture({
  label: '\u0001\uc6ba\u{1f80a}\u0c8e',
  size: {width: 1080, height: 60, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'astc-10x6-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture77 = device0.createTexture({size: [68, 15, 117], dimension: '2d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_SRC});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb']});
let sampler46 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 12.24,
  lodMaxClamp: 34.61,
  compare: 'never',
});
try {
computePassEncoder3.setBindGroup(0, bindGroup38);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder24.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder6.drawIndexed(10, 49, 3, 782_177_545, 786_645_736);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer35, 2_876);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer32, 'uint16', 1_852, 5_128);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer3, 0);
} catch {}
try {
buffer42.unmap();
} catch {}
try {
commandEncoder70.copyBufferToBuffer(buffer1, 168, buffer17, 4296, 264);
} catch {}
document.body.append(canvas2);
let commandEncoder73 = device0.createCommandEncoder({});
let computePassEncoder69 = commandEncoder4.beginComputePass({});
try {
renderPassEncoder6.draw(0, 387, 0, 228_827_346);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer14, 'uint16', 5_736, 513);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer5, 0, 6_343);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup32);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup32, new Uint32Array(1983), 41, 0);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer34, 0);
} catch {}
try {
  await promise6;
} catch {}
let texture78 = device0.createTexture({size: [24, 2, 6], format: 'stencil8', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder1.setBindGroup(1, bindGroup20);
} catch {}
try {
computePassEncoder50.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder68.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup10, new Uint32Array(1126), 20, 0);
} catch {}
try {
renderPassEncoder8.drawIndexed(18, 560, 0, 1_472_398_610, 330_148_884);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup38);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer32, 'uint32', 352, 1_073);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let commandEncoder74 = device0.createCommandEncoder({});
let textureView74 = texture45.createView({format: 'rg32uint', mipLevelCount: 1, baseArrayLayer: 0});
let renderPassEncoder11 = commandEncoder74.beginRenderPass({
  label: '\u0f6a\u791c\uc846\ub880',
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: 177.7, g: 168.9, b: 376.4, a: 812.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder29.setBindGroup(0, bindGroup38);
} catch {}
try {
computePassEncoder69.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup22, new Uint32Array(5219), 880, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer32, 'uint16', 1_026, 296);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer34, 0, 1_208);
} catch {}
try {
renderBundleEncoder8.setBindGroup(0, bindGroup18, new Uint32Array(405), 44, 0);
} catch {}
try {
commandEncoder70.insertDebugMarker('\u0d9e');
} catch {}
let bindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 114,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 10, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', minBindingSize: 64, hasDynamicOffset: false },
    },
    {
      binding: 501,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 1,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {binding: 38, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {
      binding: 57,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 329,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: true },
    },
  ],
});
let buffer45 = device0.createBuffer({size: 4829, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let computePassEncoder70 = commandEncoder70.beginComputePass({});
let renderBundle8 = renderBundleEncoder8.finish({});
try {
renderPassEncoder6.setBindGroup(0, bindGroup34);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup10, new Uint32Array(1759), 99, 0);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer5, 'uint16', 2_692, 1_798);
} catch {}
let promise13 = shaderModule3.getCompilationInfo();
try {
commandEncoder71.copyBufferToTexture({
  /* bytesInLastRow: 248 widthInBlocks: 31 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 536 */
  offset: 536,
  buffer: buffer25,
}, {
  texture: texture68,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {width: 31, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 1, depthOrArrayLayers: 29}
*/
{
  source: imageBitmap1,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 15},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture79 = device0.createTexture({
  size: {width: 136, height: 30, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_SRC,
});
let computePassEncoder71 = commandEncoder49.beginComputePass({});
try {
computePassEncoder21.setBindGroup(3, bindGroup31);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer28, 112); };
} catch {}
try {
computePassEncoder41.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder6.drawIndexed(5, 381, 12, 29_484_696, 206_891_724);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer4, 192);
} catch {}
try {
commandEncoder73.copyBufferToBuffer(buffer36, 2996, buffer17, 11016, 724);
} catch {}
try {
commandEncoder73.copyTextureToTexture({
  texture: texture64,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture68,
  mipLevel: 0,
  origin: {x: 107, y: 0, z: 0},
  aspect: 'all',
},
{width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.label = '\u3c2b\ub2f4\u07ce\ub0ac\ua82e\uff29\u{1f62d}\u0251\ua8af';
} catch {}
let renderPassEncoder12 = commandEncoder71.beginRenderPass({
  label: '\ua9e7\u0d36\ue8af',
  colorAttachments: [{
  view: textureView44,
  clearValue: { r: -689.6, g: -998.7, b: 48.55, a: -641.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 59780217,
});
let sampler47 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 3.900,
  lodMaxClamp: 43.53,
  compare: 'equal',
});
try {
renderPassEncoder12.setScissorRect(6, 0, 2, 0);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer32, 1_464);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let imageBitmap2 = await createImageBitmap(img0);
let commandEncoder75 = device0.createCommandEncoder({label: '\u9e3e\u01a2\u009a\u079b\u2bf6\u248a\u212e\u0536\ue9d0\ued04'});
let texture80 = device0.createTexture({
  size: {width: 96, height: 10, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({
  label: '\u{1f899}\u6ba8\uf574\ue71b\u0b89\u0d18\u{1f8e9}\u032b\uafb0',
  colorFormats: ['rg8uint'],
  depthStencilFormat: 'stencil8',
  stencilReadOnly: true,
});
let sampler48 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 80.17,
  compare: 'less',
  maxAnisotropy: 9,
});
try {
computePassEncoder5.setBindGroup(0, bindGroup15, new Uint32Array(2491), 1_916, 0);
} catch {}
try {
renderPassEncoder7.beginOcclusionQuery(13);
} catch {}
try {
renderPassEncoder11.setBlendConstant({ r: -108.3, g: 256.9, b: 283.2, a: 992.7, });
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer42, 2_632);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(7, buffer24, 0);
} catch {}
try {
commandEncoder75.copyTextureToBuffer({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {
  /* bytesInLastRow: 420 widthInBlocks: 420 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1224 */
  offset: 1224,
  bytesPerRow: 14080,
  buffer: buffer3,
}, {width: 420, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas1,
  origin: { x: 110, y: 3 },
  flipY: true,
}, {
  texture: texture34,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup43 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView18}]});
let commandEncoder76 = device0.createCommandEncoder({label: '\ud8ce\uf6d4\u8537\u0a41\u0a89\u{1fcef}\u059b\u004b\u{1fdbe}\u1e03\ud8bb'});
let computePassEncoder72 = commandEncoder75.beginComputePass({});
try {
renderPassEncoder6.setBindGroup(3, bindGroup42, new Uint32Array(168), 29, 0);
} catch {}
try {
renderPassEncoder7.drawIndexed(2, 16, 9, 247_764_352, 1_754_653_070);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer5, 1_248);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup30);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(7, buffer20, 0, 2_666);
} catch {}
try {
commandEncoder76.copyBufferToBuffer(buffer44, 72, buffer18, 92, 368);
} catch {}
try {
commandEncoder73.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1344 */
  offset: 1344,
  buffer: buffer2,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise13;
} catch {}
let imageData7 = new ImageData(140, 72);
let computePassEncoder73 = commandEncoder73.beginComputePass({});
let renderBundle9 = renderBundleEncoder9.finish();
let sampler49 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 57.48,
  lodMaxClamp: 80.73,
  compare: 'never',
});
try {
computePassEncoder65.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder7.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.drawIndexed(8, 207, 17, 377_382_605, 254_810_601);
} catch {}
try {
device0.queue.writeBuffer(buffer19, 60, new DataView(new ArrayBuffer(3609)), 1337, 32);
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
let texture81 = device0.createTexture({
  label: '\u989a\u0937\u{1f747}\u{1f61e}\uff31',
  size: [270, 15, 1],
  sampleCount: 1,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder55.setBindGroup(2, bindGroup17, new Uint32Array(679), 31, 0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer28, 1_040);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer37, 'uint16', 246, 123);
} catch {}
try {
commandEncoder76.copyTextureToBuffer({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 73, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 180 widthInBlocks: 45 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1276 */
  offset: 1276,
  bytesPerRow: 10496,
  buffer: buffer28,
}, {width: 45, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture55,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(1_078).fill(35), /* required buffer size: 1_078 */
{offset: 87, bytesPerRow: 65}, {width: 16, height: 16, depthOrArrayLayers: 1});
} catch {}
let texture82 = device0.createTexture({size: [48, 5, 1], format: 'bgra8unorm-srgb', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView75 = texture1.createView({baseArrayLayer: 0});
let computePassEncoder74 = commandEncoder76.beginComputePass({label: '\ucbcc\u085f\ua915\u92b6\u047c\u0a70'});
let renderPassEncoder13 = commandEncoder77.beginRenderPass({
  label: '\u0cb8\u511e\u7786\u{1f82d}\u07d1',
  colorAttachments: [{
  view: textureView44,
  clearValue: { r: -459.8, g: -744.0, b: 798.4, a: 548.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet3,
});
try {
renderPassEncoder2.setBindGroup(0, bindGroup15);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup27, new Uint32Array(326), 32, 0);
} catch {}
try {
renderPassEncoder7.setBlendConstant({ r: -136.9, g: -846.1, b: 886.3, a: -203.1, });
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer42, 704);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer28, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(107).fill(246), /* required buffer size: 107 */
{offset: 107, bytesPerRow: 98}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
try {
  await promise9;
} catch {}
try {
computePassEncoder33.setBindGroup(0, bindGroup37);
} catch {}
try {
computePassEncoder72.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer5, 'uint32', 1_288, 1_179);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline2);
} catch {}
try {
  await promise12;
} catch {}
let imageData8 = new ImageData(48, 24);
let buffer46 = device0.createBuffer({size: 13080, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder78 = device0.createCommandEncoder({});
try {
computePassEncoder70.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder13.setViewport(28.736306167264704, 3.946170993943252, 4.1916436546364695, 0.38451579332862196, 0.837005289312753, 0.9597006236172753);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer4, 696);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(1, buffer39, 444, 1_140);
} catch {}
try {
buffer18.unmap();
} catch {}
try {
commandEncoder78.copyTextureToBuffer({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1112 */
  offset: 1112,
  bytesPerRow: 10240,
  buffer: buffer10,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView76 = texture32.createView({});
try {
computePassEncoder11.end();
} catch {}
try {
computePassEncoder71.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder11.setBindGroup(2, bindGroup36);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup17, new Uint32Array(2204), 130, 0);
} catch {}
try {
renderPassEncoder6.draw(0, 70, 0, 833_022_893);
} catch {}
try {
renderPassEncoder7.drawIndexed(19, 375, 30, 465_379_242, 461_862_635);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, colorSpace: 'display-p3'});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule8 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(19) var st7: texture_storage_3d<rgba8uint, write>;

@group(0) @binding(477) var tex8: texture_1d<u32>;

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

struct T1 {
  @align(64) @size(1408) f0: array<array<mat3x4f, 1>>,
}

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

struct T3 {
  @align(32) @size(128) f0: atomic<u32>,
  @size(64) f1: array<array<f16, 2>, 4>,
  @align(64) @size(128) f2: array<array<atomic<u32>, 1>>,
}

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

struct S4 {
  @location(1) @interpolate(flat) f0: vec4i,
}

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

struct VertexOutput14 {
  @builtin(position) f37: vec4f,
}

struct S5 {
  @builtin(num_workgroups) @size(16) f0: vec3u,
}

alias vec3b = vec3<bool>;

fn fn0() -> VertexOutput14 {
  var out: VertexOutput14;
  out = VertexOutput14(vec4f(f32(pack4x8unorm(vec4f(unconst_f32(0.1657), unconst_f32(0.04393), unconst_f32(-0.08971), unconst_f32(0.1855))))));
  out.f37 += quantizeToF16(vec4f(unconst_f32(0.01751), unconst_f32(0.1682), unconst_f32(-0.01856), unconst_f32(0.1222)));
  var vf137: u32 = pack4x8unorm(vec4f(unconst_f32(0.09901), unconst_f32(0.1935), unconst_f32(0.00241), unconst_f32(0.08774)));
  out = VertexOutput14(radians(vec4f(unconst_f32(0.00588), unconst_f32(0.01796), unconst_f32(0.02811), unconst_f32(0.02932))));
  let ptr74: ptr<function, u32> = &vf137;
  let vf138: vec4h = round(vec4h(unconst_f16(1594.9), unconst_f16(25835.2), unconst_f16(8204.7), unconst_f16(10955.4)));
  vf137 ^= u32(vf138[u32(unconst_u32(360))]);
  let ptr75: ptr<function, u32> = &(*ptr74);
  let ptr76: ptr<function, u32> = &(*ptr75);
  out = VertexOutput14(vec4f(round(vec4h(unconst_f16(-21179.5), unconst_f16(2408.1), unconst_f16(4100.5), unconst_f16(2512.5)))));
  let ptr77: ptr<function, u32> = &(*ptr76);
  vf137 = (*ptr75);
  let vf139: f16 = vf138[u32(unconst_u32(21))];
  vf137 ^= (*ptr75);
  out = VertexOutput14(quantizeToF16(vec4f(unconst_f32(-0.2405), unconst_f32(0.08656), unconst_f32(0.02374), unconst_f32(-0.3399))));
  let ptr78: ptr<function, u32> = &(*ptr76);
  out.f37 = vec4f(f32((*ptr75)));
  out.f37 *= vec4f(f32((*ptr78)));
  return out;
}

fn fn1(a0: ptr<uniform, array<i32, 1>>) -> VertexOutput14 {
  var out: VertexOutput14;
  fn0();
  out = VertexOutput14(vec4f(unpack4xI8(u32(unconst_u32(44)))));
  var vf140 = fn0();
  let ptr79: ptr<uniform, i32> = &(*a0)[u32(unconst_u32(24))];
  vf140 = VertexOutput14(vec4f(bitcast<f32>((*ptr79))));
  out.f37 = vf140.f37;
  out = VertexOutput14(vec4f(f32((*a0)[u32(unconst_u32(52))])));
  var vf141 = fn0();
  var vf142 = fn0();
  out.f37 *= round(unpack2x16snorm(pack4xI8Clamp(vec4i(unconst_i32(177), unconst_i32(41), unconst_i32(17), unconst_i32(11))))).gggg;
  let ptr80: ptr<function, vec4f> = &vf140.f37;
  fn0();
  out.f37 = vec4f(f32((*ptr79)));
  let vf143: vec2f = round(vec2f(unconst_f32(-0.04060), unconst_f32(0.1497)));
  out.f37 -= round(vec2f(unconst_f32(0.03122), unconst_f32(0.04548))).yxxx;
  var vf144 = fn0();
  var vf145: f32 = vf142.f37[u32(unconst_u32(78))];
  fn0();
  var vf146 = fn0();
  let ptr81: ptr<function, vec4f> = &vf141.f37;
  vf142 = VertexOutput14(vf146.f37);
  return out;
}

fn fn2(a0: ptr<storage, array<atomic<i32>>, read_write>) -> array<array<vec4f, 1>, 1> {
  var out: array<array<vec4f, 1>, 1>;
  out[u32(unconst_u32(113))][u32(unconst_u32(18))] = vec4f(bitcast<f32>(arrayLength(&(*a0))));
  var vf147: vec4h = reflect(vec4h(unconst_f16(48959.5), unconst_f16(13821.6), unconst_f16(630.4), unconst_f16(7817.7)), vec4h(unconst_f16(12220.5), unconst_f16(-4188.0), unconst_f16(5053.3), unconst_f16(2863.9)));
  out[u32(unconst_u32(8))][u32(unconst_u32(218))] = vec4f(f32(atomicLoad(&(*a0)[arrayLength(&(*a0))])));
  fn0();
  let vf148: vec3f = pow(vec3f(unconst_f32(0.02683), unconst_f32(0.00396), unconst_f32(0.04875)), vec3f(unconst_f32(0.2123), unconst_f32(0.1654), unconst_f32(0.2258)));
  vf147 = vec4h(floor(vec4f(unconst_f32(0.02467), unconst_f32(0.04413), unconst_f32(0.1991), unconst_f32(0.2377))));
  fn0();
  vf147 = vec4h(f16(atomicLoad(&(*a0)[arrayLength(&(*a0))])));
  out[pack4x8unorm(degrees(vec4f(unconst_f32(0.4926), unconst_f32(0.01569), unconst_f32(0.09406), unconst_f32(0.4236))))][0] = vec4f(fma(f32(unconst_f32(0.2522)), f32(unconst_f32(0.2328)), f32(unconst_f32(0.4492))));
  let vf149: i32 = atomicExchange(&(*a0)[arrayLength(&(*a0))], i32(unconst_i32(595)));
  var vf150: vec4f = asinh(vec4f(unconst_f32(0.03641), unconst_f32(0.1053), unconst_f32(0.2294), unconst_f32(0.3005)));
  var vf151: i32 = vf149;
  var vf152 = fn0();
  let vf153: f32 = min(vec4f(reflect(vec4h(log2(vec4f(unconst_f32(0.02901), unconst_f32(0.4271), unconst_f32(0.2674), unconst_f32(0.2917)))), vec4h(unconst_f16(2117.2), unconst_f16(-11129.1), unconst_f16(27573.3), unconst_f16(-5029.0))))[2], bitcast<f32>(vf151));
  vf151 *= i32(vf152.f37[u32(unconst_u32(209))]);
  var vf154 = fn0();
  fn0();
  vf152 = VertexOutput14(vf152.f37);
  let vf155: f32 = vf154.f37[u32(unconst_u32(36))];
  fn0();
  vf147 += vec4h(f16(atomicLoad(&(*a0)[i32(unconst_i32(191))])));
  var vf156: vec4h = reflect(vec4h(unconst_f16(-7082.8), unconst_f16(6626.0), unconst_f16(17135.1), unconst_f16(1717.4)), vec4h(unconst_f16(1425.2), unconst_f16(238.9), unconst_f16(-3445.5), unconst_f16(1832.2)));
  let ptr82: ptr<function, vec4h> = &vf147;
  var vf157: u32 = arrayLength(&(*a0));
  return out;
}

var<workgroup> vw21: VertexOutput14;

var<workgroup> vw22: S4;

var<workgroup> vw23: atomic<i32>;

@vertex
fn vertex14(a0: S4, @location(5) @interpolate(flat, sample) a1: vec2u, @location(8) a2: vec4i, @location(13) @interpolate(flat, centroid) a3: vec2h, @builtin(instance_index) a4: u32) -> VertexOutput13 {
  var out: VertexOutput13;
  var vf158: i32 = a0.f0[u32(unconst_u32(20))];
  out.f36 = vec4f(a2);
  var vf159: mat2x4f = transpose(mat4x2f());
  vf159 = mat2x4f(bitcast<f32>(a4), f32(a4), bitcast<f32>(a4), f32(a4), bitcast<f32>(a4), f32(a4), bitcast<f32>(a4), f32(a4));
  out.f36 -= vec4f(bitcast<f32>(a2[u32(unconst_u32(483))]));
  out = VertexOutput13(vec4f(a0.f0));
  out.f36 = vec4f(a0.f0);
  out.f36 = transpose(mat4x2f())[unconst_i32(0)];
  out.f36 -= vec4f(a3.grgg);
  return out;
}

@vertex
fn vertex15(@location(12) @interpolate(flat, sample) a0: i32) -> VertexOutput14 {
  var out: VertexOutput14;
  var vf160: vec3h = saturate(vec3h(unconst_f16(4699.9), unconst_f16(254.5), unconst_f16(13819.7)));
  var vf161: u32 = pack4xU8Clamp(vec4u(unconst_u32(320), unconst_u32(91), unconst_u32(280), unconst_u32(86)));
  let vf162: vec2f = unpack2x16unorm(u32(unconst_u32(27)));
  out.f37 = vec4f(saturate(vec3h(unconst_f16(6104.1), unconst_f16(15002.3), unconst_f16(16381.3))).grrr);
  let vf163: u32 = pack4xU8Clamp(vec4u(unconst_u32(122), unconst_u32(170), unconst_u32(134), unconst_u32(23)));
  out.f37 *= unpack4x8unorm(vf161);
  return out;
}

@fragment
fn fragment10() -> @location(200) @interpolate(perspective) vec2u {
  var out: vec2u;
  out |= vec2u(unpack4x8snorm(u32(unconst_u32(18))).yy);
  let vf164: vec4i = max(vec4i(exp2(vec4f(unconst_f32(0.2475), unconst_f32(0.08042), unconst_f32(0.04530), unconst_f32(0.1023)))), vec4i(unconst_i32(141), unconst_i32(55), unconst_i32(277), unconst_i32(115)));
  let vf165: u32 = pack2x16unorm(vec2f(unconst_f32(0.02797), unconst_f32(0.3064)));
  out ^= vec2u(max(vec4i(unconst_i32(151), unconst_i32(51), unconst_i32(107), unconst_i32(44)), vec4i(unconst_i32(48), unconst_i32(59), unconst_i32(-53), unconst_i32(279))).ab);
  var vf166: vec2h = tanh(vec2h(unconst_f16(9126.3), unconst_f16(25479.1)));
  let vf167: vec4f = asinh(vec4f(unconst_f32(0.2637), unconst_f32(0.1697), unconst_f32(0.09857), unconst_f32(0.3329)));
  let vf168: vec4i = max(vec4i(unconst_i32(298), unconst_i32(194), unconst_i32(255), unconst_i32(103)), vec4i(unconst_i32(52), unconst_i32(393), unconst_i32(6), unconst_i32(-103)));
  let vf169: f32 = round(f32(unconst_f32(0.07121)));
  var vf170: vec4i = vf168;
  let vf171: f32 = round(f32(unconst_f32(0.1511)));
  out -= vec2u(tanh(vec2h(unconst_f16(11772.4), unconst_f16(5929.2))));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute6() {
  let ptr83: ptr<workgroup, vec4f> = &vw21.f37;
  vw22 = S4(vw22.f0);
  let ptr84: ptr<workgroup, vec4f> = &vw21.f37;
  textureStore(st7, vec3i(unconst_i32(79), unconst_i32(67), unconst_i32(360)), vec4u(unpack4xU8(dot4U8Packed(u32(unconst_u32(26)), bitcast<u32>(inverseSqrt(vec4f(unconst_f32(0.1236), unconst_f32(0.1733), unconst_f32(0.1359), unconst_f32(0.01341)))[3])))));
  storageBarrier();
  textureStore(st7, vec3i(unconst_i32(81), unconst_i32(317), unconst_i32(-371)), vec4u(vec4u(unconst_u32(397), unconst_u32(5), unconst_u32(34), unconst_u32(265))));
  vw21.f37 *= vec4f(workgroupUniformLoad(&vw22).f0);
  let vf172: f32 = (*&vw21).f37[u32((*ptr84)[u32(unconst_u32(296))])];
  let vf173: i32 = atomicLoad(&(*&vw23));
  let ptr85: ptr<workgroup, vec4f> = &(*ptr83);
}

@compute @workgroup_size(3, 1, 1)
fn compute7(@builtin(global_invocation_id) a0: vec3u, a1: S5) {
  workgroupBarrier();
  textureStore(st7, vec3i(unconst_i32(73), unconst_i32(73), unconst_i32(128)), vec4u(vec4u(unconst_u32(12), unconst_u32(50), unconst_u32(305), unconst_u32(252))));
  vw21 = VertexOutput14((*&vw21).f37);
  vw22.f0 += vec4i(a0.brrb);
  let ptr86: ptr<workgroup, S4> = &vw22;
  let vf174: vec3u = a1.f0;
  let ptr87: ptr<workgroup, vec4f> = &vw21.f37;
  let ptr88: ptr<workgroup, vec4f> = &vw21.f37;
  var vf175: vec3f = max(vec3f(unconst_f32(0.2188), unconst_f32(0.2046), unconst_f32(0.06895)), vec3f(unconst_f32(-0.05349), unconst_f32(0.2626), unconst_f32(-0.06855)));
  vw22 = S4(vec4i(a0.bbgb));
  var vf176 = fn0();
  var vf177 = fn0();
}

@compute @workgroup_size(4, 1, 1)
fn compute8() {
  vw21.f37 -= bitcast<vec4f>(vw22.f0);
  let vf178: vec4u = countTrailingZeros(vec4u(unconst_u32(256), unconst_u32(177), unconst_u32(466), unconst_u32(34)));
  atomicXor(&vw23, i32(unconst_i32(220)));
  let vf179: vec4h = faceForward(vec4h(unconst_f16(447.5), unconst_f16(5747.4), unconst_f16(2080.3), unconst_f16(7280.7)), vec4h(unconst_f16(4916.1), unconst_f16(8198.7), unconst_f16(7767.3), unconst_f16(3528.2)), vec4h(unconst_f16(4946.8), unconst_f16(3549.7), unconst_f16(199.2), unconst_f16(5500.3)));
  vw22 = S4(vec4i(atomicExchange(&(*&vw23), i32(unconst_i32(-103)))));
  vw22.f0 |= vec4i(i32(countOneBits(u32(unconst_u32(110)))));
  textureStore(st7, vec3i(unconst_i32(119), unconst_i32(93), unconst_i32(20)), vec4u(vec4u(unconst_u32(114), unconst_u32(269), unconst_u32(5), unconst_u32(46))));
  let vf180: vec4h = vf179;
  vw22 = S4(vec4i(faceForward(vec4h(unconst_f16(247.5), unconst_f16(20948.6), unconst_f16(110.9), unconst_f16(11852.9)), vec4h(unconst_f16(2439.4), unconst_f16(406.7), unconst_f16(5533.3), unconst_f16(1206.4)), vec4h(unconst_f16(-4196.8), unconst_f16(6000.4), unconst_f16(4816.0), unconst_f16(1377.3)))));
  vw22.f0 = vec4i(atan(vec2h(unconst_f16(2486.3), unconst_f16(1998.3))).rggr);
  textureStore(st7, vec3i(unconst_i32(41), unconst_i32(227), unconst_i32(26)), vec4u(vec4u(unconst_u32(136), unconst_u32(90), unconst_u32(29), unconst_u32(169))));
  var vf181: vec2h = atan(vec2h(unconst_f16(1561.0), unconst_f16(2809.1)));
  fn0();
}`,
  sourceMap: {},
  hints: {},
});
let textureView77 = texture27.createView({label: '\u0997\u7d34\u0ef0\u0f55'});
try {
computePassEncoder5.setBindGroup(0, bindGroup11);
} catch {}
try {
computePassEncoder26.setBindGroup(1, bindGroup10, new Uint32Array(125), 26, 0);
} catch {}
try {
computePassEncoder51.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle4, renderBundle4, renderBundle0, renderBundle1, renderBundle5]);
} catch {}
try {
renderPassEncoder12.setBlendConstant({ r: -336.1, g: -549.0, b: 422.0, a: -900.4, });
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer4, 948);
} catch {}
let pipeline11 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule6, constants: {}}});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let computePassEncoder75 = commandEncoder11.beginComputePass({});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({label: '\udced\u{1f81c}\u0804\uf653\u885c', colorFormats: ['rgba8unorm-srgb'], sampleCount: 4});
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer1, 100); };
} catch {}
try {
computePassEncoder74.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder6.drawIndexed(44, 53, 10, -231_694_916, 2_229_443_513);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer42, 'uint32', 5_408, 372);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(2, buffer34, 836, 14);
} catch {}
try {
  await buffer31.mapAsync(GPUMapMode.READ, 0, 2332);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture52,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(275).fill(31), /* required buffer size: 275 */
{offset: 275, rowsPerImage: 6}, {width: 210, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup44 = device0.createBindGroup({
  label: '\u48e4\u5621\uda9e\u5ea8',
  layout: bindGroupLayout3,
  entries: [{binding: 44, resource: sampler42}],
});
let textureView78 = texture14.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0});
let computePassEncoder76 = commandEncoder78.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(2, 1); };
} catch {}
try {
computePassEncoder12.end();
} catch {}
try {
computePassEncoder76.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup31, new Uint32Array(4381), 595, 0);
} catch {}
try {
renderPassEncoder6.draw(0, 97, 0, 1_097_446_011);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer41, 264);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer21);
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup16);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer18, 'uint32', 7_908, 184);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(6, buffer28, 864, 9_980);
} catch {}
try {
commandEncoder12.clearBuffer(buffer0, 60, 24);
} catch {}
let textureView79 = texture2.createView({mipLevelCount: 1});
let renderBundle10 = renderBundleEncoder10.finish({});
try {
computePassEncoder20.setBindGroup(0, bindGroup0, new Uint32Array(470), 198, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer33, 128); };
} catch {}
try {
computePassEncoder46.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(208), 0, 0);
} catch {}
try {
renderPassEncoder6.setScissorRect(16, 0, 4, 4);
} catch {}
try {
renderPassEncoder7.draw(0, 96, 0, 807_016_394);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer28, 1_544);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer43, 1_148, 5_755);
} catch {}
let promise14 = shaderModule3.getCompilationInfo();
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder79 = device0.createCommandEncoder({});
try {
computePassEncoder49.setBindGroup(3, bindGroup27);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder7.draw(1, 122, 1, 530_352_306);
} catch {}
try {
renderPassEncoder6.drawIndexed(0, 72, 47, 756_900_094, 339_219_801);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer4, 712);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer33, 140);
} catch {}
let commandEncoder80 = device0.createCommandEncoder({});
let texture83 = device0.createTexture({
  size: {width: 540, height: 30, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView80 = texture5.createView({label: '\u{1fb89}\u5f1d\u1a10'});
try {
renderPassEncoder9.setBindGroup(0, bindGroup1, new Uint32Array(908), 122, 0);
} catch {}
try {
renderPassEncoder12.setViewport(11.497401241936485, 1.8096788388072305, 26.567548133220036, 2.5483076990509437, 0.6198004417391735, 0.725866809020338);
} catch {}
try {
renderPassEncoder6.drawIndexed(1, 282, 24, 127_622_078, 1_278_885_554);
} catch {}
let arrayBuffer0 = buffer31.getMappedRange(312, 124);
try {
commandEncoder12.insertDebugMarker('\u{1f896}');
} catch {}
let commandEncoder81 = device0.createCommandEncoder();
let commandBuffer1 = commandEncoder12.finish();
try {
renderPassEncoder7.end();
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle8]);
} catch {}
try {
renderPassEncoder6.draw(0, 205, 0, 129_210_712);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer5, 736);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer24, 1_556, 5_526);
} catch {}
try {
  await promise14;
} catch {}
let commandEncoder82 = device0.createCommandEncoder({});
let textureView81 = texture36.createView({label: '\uc8d4\u{1fe7d}\u7efd\u0816'});
let sampler50 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMaxClamp: 84.05,
});
try {
computePassEncoder57.setBindGroup(0, bindGroup34, new Uint32Array(795), 255, 0);
} catch {}
try {
computePassEncoder75.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup30);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer33, 2_052);
} catch {}
try {
renderPassEncoder6.drawIndirect(buffer20, 308);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer41, 0, 4_217);
} catch {}
let arrayBuffer1 = buffer31.getMappedRange(440, 80);
try {
computePassEncoder71.insertDebugMarker('\u5e6a');
} catch {}
let bindGroupLayout7 = device0.createBindGroupLayout({
  label: '\ud383\u6f46\u08a3',
  entries: [
    {
      binding: 66,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup45 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 245, resource: textureView13}]});
let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: []});
let computePassEncoder77 = commandEncoder80.beginComputePass({});
let renderPassEncoder14 = commandEncoder82.beginRenderPass({
  label: '\uf499\u09d5\u0a8a\ucef6',
  colorAttachments: [{
  view: textureView44,
  clearValue: { r: 872.9, g: -833.6, b: -997.5, a: -290.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
renderPassEncoder12.setBindGroup(1, bindGroup28, new Uint32Array(1572), 357, 0);
} catch {}
try {
renderPassEncoder6.draw(0, 16, 0, 273_435_371);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer9, 2_488);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer1, 'uint32', 1_552, 25);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(0, buffer24);
} catch {}
try {
commandEncoder81.copyTextureToBuffer({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 65, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 152 widthInBlocks: 38 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5936 */
  offset: 5936,
  bytesPerRow: 3072,
  buffer: buffer36,
}, {width: 38, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer8, 552, new Int16Array(5231), 716, 52);
} catch {}
let bindGroup46 = device0.createBindGroup({
  label: '\u1b8e\u893d\u{1ff1d}\u0cee\u06a2\ue9bd\uba10',
  layout: bindGroupLayout6,
  entries: [
    {binding: 15, resource: {buffer: buffer3, offset: 10240, size: 980}},
    {binding: 329, resource: {buffer: buffer32, offset: 1792, size: 443}},
    {binding: 114, resource: textureView69},
    {binding: 38, resource: sampler3},
    {binding: 10, resource: {buffer: buffer21, offset: 256, size: 2584}},
    {binding: 1, resource: {buffer: buffer21, offset: 512, size: 2708}},
    {binding: 501, resource: textureView56},
    {binding: 57, resource: {buffer: buffer39, offset: 256, size: 476}},
  ],
});
let commandEncoder83 = device0.createCommandEncoder({});
let texture84 = device0.createTexture({
  label: '\ucc7c\u0acf\u{1fda7}\u98e4\uc2c3\uda2c',
  size: {width: 420, height: 10, depthOrArrayLayers: 4},
  mipLevelCount: 3,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], sampleCount: 1});
try {
computePassEncoder77.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup21);
} catch {}
try {
renderPassEncoder6.draw(85_125_606, 297, 715_330_254, 411_996_941);
} catch {}
try {
renderPassEncoder6.drawIndexed(3, 72, 7, 429_401_489, 863_932_699);
} catch {}
try {
renderPassEncoder6.drawIndexedIndirect(buffer18, 292);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer4, 'uint32', 520, 411);
} catch {}
try {
renderBundleEncoder11.setBindGroup(2, bindGroup41, new Uint32Array(2117), 13, 0);
} catch {}
try {
renderBundleEncoder11.setIndexBuffer(buffer36, 'uint16', 8_222, 2_559);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
  await promise7;
} catch {}
let computePassEncoder78 = commandEncoder79.beginComputePass({});
let renderPassEncoder15 = commandEncoder46.beginRenderPass({
  label: '\u{1fbe2}\u98b5\u9249\u4864\u{1fd31}\u{1fe4e}\u{1fad9}',
  colorAttachments: [{view: textureView75, depthSlice: 4, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet4,
});
let renderBundle11 = renderBundleEncoder11.finish({});
let sampler51 = device0.createSampler({
  label: '\u06fb\u0cc0\u4405',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 19.71,
});
try {
computePassEncoder65.setBindGroup(0, bindGroup3, new Uint32Array(1432), 0, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder53.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup41, new Uint32Array(724), 137, 0);
} catch {}
try {
renderPassEncoder6.end();
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer21, 'uint16', 176, 920);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(1_682).fill(39), /* required buffer size: 1_682 */
{offset: 466, bytesPerRow: 32, rowsPerImage: 19}, {width: 1, height: 0, depthOrArrayLayers: 3});
} catch {}
try {
adapter0.label = '\u6cab\u{1fe9c}\ua443\ubbda\u6a89\u0a87\u0281\u{1f629}\udd43\uae62';
} catch {}
let buffer47 = device0.createBuffer({
  label: '\u0d47\u0829\u10ba\u{1f629}',
  size: 1145,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder28.end();
} catch {}
try {
computePassEncoder66.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer16, 'uint16', 4_710, 9_887);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(6, buffer39);
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 210 widthInBlocks: 210 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 28 */
  offset: 28,
  bytesPerRow: 18944,
  buffer: buffer10,
}, {
  texture: texture56,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {width: 210, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
document.body.append(img0);
let bindGroup47 = device0.createBindGroup({
  label: '\u6130\uc81e\u7d2c',
  layout: bindGroupLayout1,
  entries: [{binding: 183, resource: textureView40}],
});
let buffer48 = device0.createBuffer({
  size: 21694,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder84 = device0.createCommandEncoder({});
let texture85 = device0.createTexture({size: {width: 16}, sampleCount: 1, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder79 = commandEncoder27.beginComputePass({});
let renderPassEncoder16 = commandEncoder84.beginRenderPass({
  colorAttachments: [{
  view: textureView47,
  depthSlice: 23,
  clearValue: { r: 431.6, g: -633.2, b: 847.3, a: 891.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder44.setBindGroup(1, bindGroup6);
} catch {}
try {
computePassEncoder48.setBindGroup(1, bindGroup35, new Uint32Array(869), 13, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer42, 'uint16', 388, 318);
} catch {}
try {
renderPassEncoder11.setPipeline(pipeline4);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1220 */
  offset: 1220,
  bytesPerRow: 4864,
  rowsPerImage: 107,
  buffer: buffer20,
}, {
  texture: texture40,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {width: 8, height: 8, depthOrArrayLayers: 0});
} catch {}
let bindGroup48 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 66, resource: {buffer: buffer48, offset: 512, size: 1687}}],
});
let commandEncoder85 = device0.createCommandEncoder({});
let textureView82 = texture14.createView({baseMipLevel: 0});
let computePassEncoder80 = commandEncoder81.beginComputePass({});
try {
computePassEncoder79.setBindGroup(3, bindGroup33);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle11, renderBundle2]);
} catch {}
let pipeline12 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule6, entryPoint: 'compute4', constants: {}}});
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt2020', transfer: 'bt2020_12bit'} });
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandBuffer2 = commandEncoder41.finish();
let computePassEncoder81 = commandEncoder83.beginComputePass({});
try {
renderPassEncoder10.setBindGroup(3, bindGroup45, new Uint32Array(1496), 7, 0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle1, renderBundle0, renderBundle8, renderBundle1]);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer46, 56);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer37, 'uint32', 1_832, 567);
} catch {}
try {
commandEncoder85.copyBufferToBuffer(buffer46, 6560, buffer14, 636, 292);
} catch {}
try {
commandEncoder85.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 524 */
  offset: 524,
  bytesPerRow: 35584,
  buffer: buffer36,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 4, y: 3, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule9 = device0.createShaderModule({
  label: '\u05f9\u9d93\u{1f7a1}\u8cf7\u02dd\u0dad\u5a78',
  code: `
enable f16;

enable f16;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(477) var tex9: texture_1d<u32>;

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

struct VertexOutput15 {
  @invariant @builtin(position) f38: vec4f,
  @location(11) @interpolate(perspective, centroid) f39: f32,
  @location(7) @interpolate(flat) f40: vec2f,
  @location(4) f41: vec2i,
}

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

alias vec3b = vec3<bool>;

fn fn0() -> FragmentOutput8 {
  var out: FragmentOutput8;
  var vf182: vec4f = unpack4x8snorm(u32(unconst_u32(66)));
  out.f0 = vec4f(vf182[u32(unconst_u32(49))]);
  var vf183: vec2h = degrees(vec2h(unconst_f16(3319.8), unconst_f16(10400.2)));
  out = FragmentOutput8(vec4f(unpack4xU8(u32(unconst_u32(14)))));
  let vf184: vec4f = unpack4x8snorm(u32(unconst_u32(28)));
  vf183 = cross(vec3h(unconst_f16(2899.2), unconst_f16(3060.1), unconst_f16(1506.2)), vec3h(unconst_f16(4205.7), unconst_f16(-19366.3), unconst_f16(10735.5))).yx;
  vf183 = vec2h(vf183[bitcast<u32>(degrees(vec2h(unconst_f16(9557.6), unconst_f16(14245.5))))]);
  vf182 = vf184;
  out.f0 *= vec4f(f32(vf183[u32(unconst_u32(66))]));
  let vf185: vec4f = unpack4x8snorm(u32(unconst_u32(324)));
  vf182 = vec4f(vf185[u32(unconst_u32(112))]);
  let vf186: f16 = vf183[u32(unconst_u32(273))];
  return out;
}

var<workgroup> vw24: f16;

var<workgroup> vw25: atomic<u32>;

var<workgroup> vw26: atomic<u32>;

var<workgroup> vw27: array<array<vec4h, 1>, 1>;

@vertex
fn vertex16() -> VertexOutput15 {
  var out: VertexOutput15;
  out.f39 *= unpack2x16float(u32(unconst_u32(367)))[0];
  fn0();
  fn0();
  let vf187: vec2h = exp2(vec2h(unconst_f16(2135.6), unconst_f16(2565.1)));
  out.f38 = vec4f(fma(vec3h(unconst_f16(12132.6), unconst_f16(-1261.9), unconst_f16(4345.6)), vec3h(unconst_f16(1429.7), unconst_f16(8097.1), unconst_f16(3810.3)), vec3h(unconst_f16(7115.7), unconst_f16(12846.2), unconst_f16(19699.5))).zyxy);
  var vf188 = fn0();
  var vf189 = fn0();
  out.f39 = faceForward(vec3f(f32(pack4xU8(vec4u(unconst_u32(316), unconst_u32(42), unconst_u32(234), unconst_u32(105))))), faceForward(vec3f(unconst_f32(0.1575), unconst_f32(0.04988), unconst_f32(0.03123)), vec3f(bitcast<f32>(pack4xU8Clamp(vec4u(unconst_u32(594), unconst_u32(437), unconst_u32(20), unconst_u32(2))))), vec3f(unconst_f32(0.04230), unconst_f32(0.03221), unconst_f32(0.02370))), vec3f(unconst_f32(0.00519), unconst_f32(0.02516), unconst_f32(0.04569))).b;
  vf188 = FragmentOutput8(vec4f(f32(vf187[u32(unconst_u32(39))])));
  out.f39 = f32(pack4xU8Clamp(vec4u(unconst_u32(42), unconst_u32(157), unconst_u32(72), unconst_u32(488))));
  out.f40 += acos(vec2f(unconst_f32(0.03780), unconst_f32(0.1317)));
  fn0();
  fn0();
  fn0();
  vf189.f0 = vec4f(min(vec4h(degrees(vec4f(unconst_f32(0.01921), unconst_f32(0.00015), unconst_f32(0.04111), unconst_f32(0.1607)))), vec4h(unconst_f16(2796.0), unconst_f16(8438.8), unconst_f16(6982.3), unconst_f16(40219.8))));
  let vf190: vec4h = min(vec4h(unconst_f16(1308.4), unconst_f16(639.7), unconst_f16(14252.9), unconst_f16(13634.6)), vec4h(unconst_f16(1752.3), unconst_f16(4764.5), unconst_f16(1883.9), unconst_f16(21875.6)));
  let vf191: f32 = step(f32(unconst_f32(0.1384)), f32(unconst_f32(-0.03712)));
  vf188.f0 += vec4f(min(vec4h(unconst_f16(4976.4), unconst_f16(13131.8), unconst_f16(2176.4), unconst_f16(-13423.0)), vec4h(unconst_f16(6021.9), unconst_f16(816.3), unconst_f16(15044.6), unconst_f16(12138.1))));
  var vf192: vec4h = min(vec4h(unconst_f16(30483.5), unconst_f16(9630.8), unconst_f16(16740.0), unconst_f16(13704.8)), vec4h(unconst_f16(-7745.2), unconst_f16(2728.2), unconst_f16(10128.6), unconst_f16(294.5)));
  out.f38 = vf189.f0;
  fn0();
  fn0();
  var vf193: vec4h = min(vec4h(unconst_f16(-947.5), unconst_f16(7146.2), unconst_f16(13880.9), unconst_f16(5368.8)), vec4h(unconst_f16(4009.7), unconst_f16(12128.8), unconst_f16(20339.6), unconst_f16(10813.4)));
  return out;
}

@fragment
fn fragment11() -> FragmentOutput8 {
  var out: FragmentOutput8;
  fn0();
  out.f0 -= vec4f(bitcast<f32>(min(u32(unconst_u32(401)), u32(unconst_u32(175)))));
  out.f0 = vec4f(sign(vec2h(unconst_f16(572.8), unconst_f16(4568.7))).rrrr);
  var vf194 = fn0();
  var vf195: vec4i = extractBits(vec4i(unconst_i32(4), unconst_i32(-15), unconst_i32(235), unconst_i32(120)), u32(unconst_u32(112)), u32(unconst_u32(190)));
  out = FragmentOutput8(vec4f(f32(pack4xI8Clamp(vec4i(unconst_i32(221), unconst_i32(143), unconst_i32(433), unconst_i32(318))))));
  var vf196 = fn0();
  out.f0 = vec4f(cos(vec4h(unconst_f16(14164.6), unconst_f16(18282.0), unconst_f16(27410.6), unconst_f16(5757.1))));
  vf194.f0 = vec4f(fma(vec4h(unconst_f16(2692.5), unconst_f16(9842.2), unconst_f16(1024.9), unconst_f16(-35472.0)), vec4h(unconst_f16(15732.2), unconst_f16(41886.8), unconst_f16(4611.0), unconst_f16(-11119.1)), vec4h(unconst_f16(8597.3), unconst_f16(10644.7), unconst_f16(2587.4), unconst_f16(-1269.9))));
  let vf197: vec2h = sign(vec2h(unconst_f16(11330.1), unconst_f16(-11288.4)));
  fn0();
  var vf198 = fn0();
  let vf199: u32 = pack4x8snorm(vec4f(unconst_f32(0.1945), unconst_f32(0.01964), unconst_f32(0.2791), unconst_f32(0.1778)));
  fn0();
  out.f0 = vec4f(vf194.f0[pack4x8snorm(vec4f(unconst_f32(0.6759), unconst_f32(0.04091), unconst_f32(0.1012), unconst_f32(0.04375)))]);
  var vf200 = fn0();
  let ptr89: ptr<function, FragmentOutput8> = &vf198;
  var vf201: vec3u = clamp(vec3u(unconst_u32(100), unconst_u32(198), unconst_u32(296)), vec3u(unconst_u32(612), unconst_u32(431), unconst_u32(60)), vec3u(unconst_u32(12), unconst_u32(120), unconst_u32(197)));
  vf200 = FragmentOutput8(vec4f(cos(vec4h(f16(vf195[u32(unconst_u32(129))])))));
  let ptr90: ptr<function, vec4i> = &vf195;
  fn0();
  var vf202: vec2h = vf197;
  out.f0 = vec4f(vf194.f0[u32(unconst_u32(83))]);
  return out;
}

@compute @workgroup_size(1, 1, 2)
fn compute9() {
  fn0();
  var vf203 = fn0();
  vw27[textureNumLevels(tex9)][0] = vec4h(f16(atomicLoad(&vw25)));
  atomicCompareExchangeWeak(&vw25, unconst_u32(461), unconst_u32(46));
  let vf204: f16 = vw27[0][u32(unconst_u32(43))][u32(unconst_u32(89))];
  let ptr91: ptr<workgroup, atomic<u32>> = &(*&vw25);
  var vf205 = fn0();
  atomicExchange(&vw26, u32(unconst_u32(122)));
}`,
  sourceMap: {},
});
let textureView83 = texture17.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder82 = commandEncoder85.beginComputePass({label: '\uc645\u6b31'});
try {
{ clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder81.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder11.draw(1_259_946_812, 73, 115_251_385, 948_595_968);
} catch {}
try {
renderPassEncoder11.drawIndirect(buffer20, 1_668);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer28);
} catch {}
let commandEncoder86 = device0.createCommandEncoder();
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 406});
try {
renderPassEncoder13.setBindGroup(0, bindGroup38);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup6, new Uint32Array(285), 28, 0);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer38, 'uint16', 6_026, 4_147);
} catch {}
try {
commandEncoder86.copyBufferToTexture({
  /* bytesInLastRow: 210 widthInBlocks: 210 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 268 */
  offset: 268,
  buffer: buffer12,
}, {
  texture: texture30,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {width: 210, height: 1, depthOrArrayLayers: 0});
} catch {}
let textureView84 = texture54.createView({aspect: 'depth-only'});
try {
computePassEncoder82.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup5, new Uint32Array(1735), 171, 0);
} catch {}
try {
renderPassEncoder10.drawIndexed(19, 68, 2, 28_224_273, 50_422_154);
} catch {}
try {
buffer19.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let buffer49 = device0.createBuffer({
  label: '\u2ff1\u60e4\u987f\uff2f\u0a3a\u6e8c\u0831\u728d\ub03e\u019e',
  size: 10182,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder87 = device0.createCommandEncoder({});
let textureView85 = texture81.createView({dimension: '2d-array', aspect: 'stencil-only'});
let computePassEncoder83 = commandEncoder86.beginComputePass({});
try {
computePassEncoder80.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder10.draw(25, 249, 7, 673_702_548);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer4, 164);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer26, 16);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer36, 'uint16', 66, 26);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline2);
} catch {}
try {
commandEncoder87.copyBufferToTexture({
  /* bytesInLastRow: 1028 widthInBlocks: 257 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1584 */
  offset: 1584,
  bytesPerRow: 26624,
  rowsPerImage: 613,
  buffer: buffer9,
}, {
  texture: texture44,
  mipLevel: 1,
  origin: {x: 116, y: 1, z: 0},
  aspect: 'all',
}, {width: 257, height: 18, depthOrArrayLayers: 0});
} catch {}
let commandEncoder88 = device0.createCommandEncoder({});
let textureView86 = texture75.createView({mipLevelCount: 1});
let textureView87 = texture16.createView({baseMipLevel: 0});
let computePassEncoder84 = commandEncoder87.beginComputePass({label: '\u1381\ue3b0\uf37e\ubd63\u{1faff}\ub1f0\u6a38\u04b2\u4509\u{1fd39}'});
let renderPassEncoder17 = commandEncoder88.beginRenderPass({
  colorAttachments: [{
  view: textureView75,
  depthSlice: 7,
  clearValue: { r: 765.4, g: -787.0, b: -614.1, a: 723.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 111732520,
});
try {
computePassEncoder76.setBindGroup(0, bindGroup34, []);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle2, renderBundle0, renderBundle5, renderBundle2]);
} catch {}
try {
renderPassEncoder10.drawIndexed(3, 157, 1, 101_463_301, 781_387_588);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer22, 36);
} catch {}
let commandEncoder89 = device0.createCommandEncoder({label: '\u1e0f\ue636\ue908\u638b\u{1fa1d}\u{1fe6a}\u38f5\u{1fbe8}\u0885'});
let computePassEncoder85 = commandEncoder89.beginComputePass();
try {
computePassEncoder79.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer8, 56);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer21, 'uint32', 556, 1_302);
} catch {}
let bindGroup49 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 183, resource: textureView33}]});
let texture86 = device0.createTexture({size: [16, 16, 14], mipLevelCount: 1, format: 'stencil8', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder59.setBindGroup(0, bindGroup39, new Uint32Array(919), 34, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle5, renderBundle2]);
} catch {}
try {
renderPassEncoder11.drawIndexedIndirect(buffer20, 16);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer23, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture69,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(218).fill(135), /* required buffer size: 218 */
{offset: 218, bytesPerRow: 33}, {width: 24, height: 2, depthOrArrayLayers: 0});
} catch {}
let texture87 = device0.createTexture({
  size: [840, 20, 1],
  format: 'rg32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture10 = device0.importExternalTexture({source: videoFrame5});
try {
computePassEncoder73.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder10.draw(4, 486, 32, 975_877_837);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer10, 'uint32', 4_240, 2_738);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(2, buffer8, 0);
} catch {}
let bindGroup50 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView18}]});
let commandEncoder90 = device0.createCommandEncoder({});
let commandBuffer3 = commandEncoder90.finish();
let texture88 = device0.createTexture({
  size: [420, 10, 33],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler52 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 87.95,
  lodMaxClamp: 89.45,
  maxAnisotropy: 2,
});
try {
renderPassEncoder17.setBindGroup(2, bindGroup47);
} catch {}
try {
renderPassEncoder11.end();
} catch {}
try {
renderPassEncoder10.drawIndexed(9, 27, 17, 426_316_492, 236_895_596);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer20, 20);
} catch {}
try {
computePassEncoder7.pushDebugGroup('\ud689');
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let buffer50 = device0.createBuffer({size: 4422, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let renderPassEncoder18 = commandEncoder74.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -984.0, g: 284.9, b: 221.9, a: -472.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet1,
});
try {
{ clearResourceUsages(device0, computePassEncoder57); computePassEncoder57.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup18);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(5);
} catch {}
try {
renderPassEncoder10.draw(10, 59, 1, 2_196_193_356);
} catch {}
try {
renderPassEncoder10.drawIndexed(9, 13, 15, 772_338_743, 907_564_604);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer18, 'uint32', 8_624, 58);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(5, buffer16);
} catch {}
let imageData9 = new ImageData(16, 40);
let commandEncoder91 = device0.createCommandEncoder();
let texture89 = device0.createTexture({
  size: {width: 68, height: 15, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView88 = texture50.createView({baseArrayLayer: 0});
try {
computePassEncoder80.setBindGroup(3, bindGroup47);
} catch {}
try {
computePassEncoder2.end();
} catch {}
try {
computePassEncoder84.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder17.setBindGroup(3, bindGroup10);
} catch {}
try {
renderPassEncoder10.draw(2, 258, 13, 185_106_365);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder7.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 8},
  aspect: 'stencil-only',
}, new Uint8Array(29_428).fill(169), /* required buffer size: 29_428 */
{offset: 238, bytesPerRow: 230, rowsPerImage: 61}, {width: 210, height: 5, depthOrArrayLayers: 3});
} catch {}
let commandEncoder92 = device0.createCommandEncoder({});
let textureView89 = texture45.createView({dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder31.end();
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder10.drawIndexed(4, 103, 10, 495_116_380, 391_875_700);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer4, 'uint32', 12, 1_041);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline1);
} catch {}
try {
commandEncoder91.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3128 */
  offset: 3128,
  rowsPerImage: 844,
  buffer: buffer25,
}, {
  texture: texture63,
  mipLevel: 0,
  origin: {x: 11, y: 2, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer3]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 40, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(59).fill(52), /* required buffer size: 59 */
{offset: 59}, {width: 27, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let bindGroup51 = device0.createBindGroup({
  label: '\u7dd0\u{1fb53}\u0f1a\u{1fa9a}\u1728\uc3f6\u0735\u9133\u4ba2\uf10d\uddc5',
  layout: bindGroupLayout5,
  entries: [{binding: 245, resource: textureView13}],
});
let querySet13 = device0.createQuerySet({type: 'occlusion', count: 3});
let computePassEncoder86 = commandEncoder31.beginComputePass({label: '\u3153\u{1ffa0}\u{1f607}\u050b\u863b\u041c\u{1fca4}\uf82c\u0c9e\u96b0'});
let renderPassEncoder19 = commandEncoder92.beginRenderPass({colorAttachments: [{view: textureView44, loadOp: 'load', storeOp: 'discard'}]});
let sampler53 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 83.99,
  lodMaxClamp: 94.66,
  maxAnisotropy: 9,
});
try {
computePassEncoder86.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder10.draw(8, 161, 1, 97_523_965);
} catch {}
try {
renderPassEncoder10.drawIndexed(8, 130, 46, 442_134_566, 1_978_742_331);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer35, 472);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer42, 276);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer5, 'uint16', 136, 5_729);
} catch {}
try {
commandEncoder91.resolveQuerySet(querySet1, 157, 402, buffer24, 2304);
} catch {}
let bindGroup52 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 66, resource: {buffer: buffer20, offset: 0, size: 128}}],
});
let buffer51 = device0.createBuffer({
  size: 667,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let texture90 = gpuCanvasContext0.getCurrentTexture();
let textureView90 = texture72.createView({});
try {
computePassEncoder78.setPipeline(pipeline6);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.queue.writeBuffer(buffer50, 432, new Float32Array(5006), 295, 28);
} catch {}
let bindGroup53 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView80}, {binding: 477, resource: textureView4}],
});
let commandEncoder93 = device0.createCommandEncoder({});
let texture91 = gpuCanvasContext2.getCurrentTexture();
let computePassEncoder87 = commandEncoder93.beginComputePass({label: '\u0686\u08f2\uc5f7'});
try {
renderPassEncoder10.setBindGroup(2, bindGroup45);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup36, new Uint32Array(2239), 1_611, 0);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer8, 24);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer16, 'uint32', 2_748, 2_077);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline2);
} catch {}
try {
  await buffer13.mapAsync(GPUMapMode.WRITE, 0, 832);
} catch {}
document.body.prepend(img0);
let commandEncoder94 = device0.createCommandEncoder({});
let textureView91 = texture44.createView({dimension: '2d-array', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder58); computePassEncoder58.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder83.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder18.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder10.draw(10, 98, 3, 408_646_433);
} catch {}
try {
renderPassEncoder10.drawIndexed(16, 38, 1, 230_642_070, 599_040_911);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer35, 100);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline4);
} catch {}
document.body.prepend(canvas2);
let buffer52 = device0.createBuffer({
  label: '\u{1f745}\u0d55\uad23\u0613',
  size: 2383,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
});
let commandEncoder95 = device0.createCommandEncoder({label: '\u0aea\u3087\u3513'});
let textureView92 = texture19.createView({label: '\u004c\u00a9\u{1ff81}\u9d30', baseArrayLayer: 40, arrayLayerCount: 4});
let sampler54 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 85.44,
  lodMaxClamp: 88.97,
});
try {
computePassEncoder44.setBindGroup(2, bindGroup35, new Uint32Array(1318), 280, 0);
} catch {}
try {
computePassEncoder85.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.drawIndexed(21, 10, 9, 570_720_502, 29_852_349);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer33, 1_712);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline4);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(2, buffer47, 0);
} catch {}
try {
commandEncoder94.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 4592 */
  offset: 4592,
  buffer: buffer41,
}, {
  texture: texture63,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas1);
let computePassEncoder88 = commandEncoder94.beginComputePass();
try {
computePassEncoder87.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup42, new Uint32Array(267), 16, 0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer26, 56);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer4, 472);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer21, 2956, new Float32Array(9557), 962, 96);
} catch {}
let computePassEncoder89 = commandEncoder2.beginComputePass({});
try {
renderPassEncoder9.setBindGroup(0, bindGroup9, new Uint32Array(1798), 75, 0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(15);
} catch {}
try {
renderPassEncoder10.drawIndexed(6, 127, 2, 242_517_530, 139_069_999);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline4);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let imageData10 = new ImageData(48, 40);
let commandEncoder96 = device0.createCommandEncoder({});
let texture92 = device0.createTexture({
  size: {width: 840, height: 20, depthOrArrayLayers: 18},
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder90 = commandEncoder96.beginComputePass({});
let renderPassEncoder20 = commandEncoder91.beginRenderPass({
  label: '\u{1f97d}\u05e8\u94b5\u{1ff15}\u0862\u03e1\u3eb6\u{1fbdc}\u{1f7a0}\u0c4d',
  colorAttachments: [{
  view: textureView75,
  depthSlice: 1,
  clearValue: { r: -930.9, g: 4.004, b: -559.0, a: 911.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler55 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 8.990,
  lodMaxClamp: 85.81,
  compare: 'not-equal',
});
try {
renderPassEncoder10.setBindGroup(2, bindGroup41, new Uint32Array(304), 96, 0);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder10.drawIndexed(3, 21, 13, 297_485_342, 951_826_026);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(2, buffer45, 460, 1_021);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 12, height: 1, depthOrArrayLayers: 29}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture41,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup54 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [
    {binding: 38, resource: sampler38},
    {binding: 501, resource: textureView84},
    {binding: 57, resource: {buffer: buffer24, offset: 768, size: 1992}},
    {binding: 15, resource: {buffer: buffer51, offset: 0, size: 68}},
    {binding: 329, resource: {buffer: buffer35, offset: 256, size: 251}},
    {binding: 1, resource: {buffer: buffer21, offset: 0, size: 3652}},
    {binding: 114, resource: textureView61},
    {binding: 10, resource: {buffer: buffer39, offset: 0, size: 2108}},
  ],
});
let computePassEncoder91 = commandEncoder95.beginComputePass();
try {
computePassEncoder90.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup40, new Uint32Array(1218), 516, 0);
} catch {}
try {
renderPassEncoder10.draw(4, 40, 14, 141_110_196);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer22, 352);
} catch {}
await gc();
let texture93 = device0.createTexture({
  size: {width: 12, height: 1, depthOrArrayLayers: 1},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture94 = device0.createTexture({
  label: '\ua882\u04d8\u{1fa28}\u03ba\u2817',
  size: {width: 210, height: 5, depthOrArrayLayers: 38},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler56 = device0.createSampler({
  label: '\ud21a\u9c2e\u5ae4\u9b50\u40f4',
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 83.50,
  maxAnisotropy: 20,
});
try {
computePassEncoder56.setBindGroup(0, bindGroup19, new Uint32Array(969), 74, 0);
} catch {}
try {
computePassEncoder91.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup32);
} catch {}
try {
renderPassEncoder10.draw(9, 76, 5, 180_722_166);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer8, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
await gc();
let bindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 46,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
  ],
});
let bindGroup55 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 221, resource: textureView18}]});
let texture95 = device0.createTexture({
  size: [840, 20, 1],
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder88.setBindGroup(1, bindGroup33);
} catch {}
try {
computePassEncoder89.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup36, []);
} catch {}
try {
renderPassEncoder10.draw(4, 26, 6, 537_032_023);
} catch {}
let bindGroup56 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 46, resource: sampler22}]});
let commandEncoder97 = device0.createCommandEncoder({});
let computePassEncoder92 = commandEncoder97.beginComputePass({});
try {
computePassEncoder92.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup16, new Uint32Array(21), 2, 0);
} catch {}
try {
renderPassEncoder10.end();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
await gc();
let bindGroup57 = device0.createBindGroup({
  label: '\uc87d\u350f\ub940\u{1f99a}\u6bc7\u9a9e\u2bb0\udebc\u{1f8c0}',
  layout: bindGroupLayout2,
  entries: [{binding: 221, resource: textureView18}],
});
let commandEncoder98 = device0.createCommandEncoder();
let texture96 = device0.createTexture({
  size: {width: 34, height: 7, depthOrArrayLayers: 1},
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView93 = texture96.createView({aspect: 'depth-only'});
try {
computePassEncoder85.setBindGroup(0, bindGroup5, new Uint32Array(6125), 2_053, 0);
} catch {}
try {
computePassEncoder88.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer37, 'uint16', 178, 730);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(3, buffer45, 880);
} catch {}
let bindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {binding: 69, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }},
  ],
});
let bindGroup58 = device0.createBindGroup({
  label: '\u338e\u4806\u{1fcf4}\ud81e',
  layout: bindGroupLayout5,
  entries: [{binding: 245, resource: textureView33}],
});
let commandEncoder99 = device0.createCommandEncoder({label: '\u466f\ufb58\u{1f9cd}\ue2ff\u{1f83d}\u7876\u2dcd\ubf95\u06c1\u0378'});
let computePassEncoder93 = commandEncoder67.beginComputePass({});
let sampler57 = device0.createSampler({
  label: '\u49fb\u08e1\u0137\u{1ff28}\u9769\u018d\u0c2e',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 81.46,
  lodMaxClamp: 93.66,
});
let externalTexture11 = device0.importExternalTexture({source: videoFrame7});
try {
computePassEncoder1.setBindGroup(0, bindGroup2, new Uint32Array(5838), 1_129, 0);
} catch {}
try {
computePassEncoder93.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle1, renderBundle4, renderBundle11]);
} catch {}
try {
commandEncoder99.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1424 */
  offset: 1424,
  bytesPerRow: 2304,
  buffer: buffer4,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder98.resolveQuerySet(querySet2, 442, 0, buffer0, 0);
} catch {}
try {
renderPassEncoder13.pushDebugGroup('\u0b2a');
} catch {}
let texture97 = device0.createTexture({
  size: {width: 420, height: 10, depthOrArrayLayers: 1},
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView94 = texture58.createView({baseMipLevel: 0, baseArrayLayer: 0, arrayLayerCount: 1});
let computePassEncoder94 = commandEncoder98.beginComputePass({});
try {
computePassEncoder94.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder16.setScissorRect(10, 0, 4, 0);
} catch {}
try {
renderPassEncoder12.insertDebugMarker('\uf8fe');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 135, height: 7, depthOrArrayLayers: 18}
*/
{
  source: videoFrame7,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup59 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 64, resource: textureView66}]});
let commandEncoder100 = device0.createCommandEncoder({});
let texture98 = device0.createTexture({
  size: [105, 2, 143],
  mipLevelCount: 2,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder95 = commandEncoder99.beginComputePass({});
let sampler58 = device0.createSampler({
  label: '\uca4e\u0a2e\u4e13',
  addressModeV: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 95.28,
  lodMaxClamp: 99.67,
});
try {
computePassEncoder95.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer32, 'uint16', 1_358, 261);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline4);
} catch {}
try {
commandEncoder100.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1664 */
  offset: 1664,
  bytesPerRow: 66048,
  buffer: buffer10,
}, {
  texture: texture93,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder100.clearBuffer(buffer29);
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let bindGroup60 = device0.createBindGroup({
  label: '\u020b\u0acb\ufb10\udef4',
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView31}, {binding: 477, resource: textureView17}],
});
try {
computePassEncoder60.setBindGroup(2, bindGroup41, new Uint32Array(3053), 430, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer52, 'uint32', 200, 405);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(1, buffer7, 0);
} catch {}
try {
commandEncoder100.resolveQuerySet(querySet4, 249, 7, buffer0, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(23).fill(20), /* required buffer size: 23 */
{offset: 23}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas1);
let commandEncoder101 = device0.createCommandEncoder();
try {
{ clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup44, []);
} catch {}
try {
renderPassEncoder13.beginOcclusionQuery(8);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(6, buffer24, 10_968);
} catch {}
try {
commandEncoder101.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 388 */
  offset: 388,
  bytesPerRow: 16640,
  rowsPerImage: 282,
  buffer: buffer12,
}, {
  texture: texture93,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder49.insertDebugMarker('\u0765');
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
let canvas3 = document.createElement('canvas');
let buffer53 = device0.createBuffer({
  label: '\u96ae\u06a0\u8e8a\uede1\u07ae\u0500\u00df\u01b9\ud22b\ud773',
  size: 244,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let texture99 = gpuCanvasContext0.getCurrentTexture();
let textureView95 = texture72.createView({label: '\u01f5\u50be\ub773\uc88b'});
let computePassEncoder96 = commandEncoder101.beginComputePass({});
try {
computePassEncoder36.setBindGroup(0, bindGroup12, new Uint32Array(3351), 869, 0);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup48);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup60, new Uint32Array(1434), 90, 0);
} catch {}
try {
buffer13.unmap();
} catch {}
let buffer54 = device0.createBuffer({size: 9094, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder102 = device0.createCommandEncoder({});
let sampler59 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 7.298});
try {
computePassEncoder25.setBindGroup(3, bindGroup17, new Uint32Array(406), 22, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer35, 928); };
} catch {}
try {
computePassEncoder29.end();
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup20, new Uint32Array(62), 2, 0);
} catch {}
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle1]);
} catch {}
try {
commandEncoder100.copyBufferToTexture({
  /* bytesInLastRow: 210 widthInBlocks: 210 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 2288 */
  offset: 2288,
  bytesPerRow: 9984,
  buffer: buffer25,
}, {
  texture: texture52,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'stencil-only',
}, {width: 210, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder100.copyTextureToBuffer({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 544, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 864 */
  offset: 864,
  bytesPerRow: 50176,
  buffer: buffer8,
}, {width: 12, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(135).fill(186), /* required buffer size: 135 */
{offset: 135, bytesPerRow: 58, rowsPerImage: 100}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let computePassEncoder97 = commandEncoder102.beginComputePass({});
try {
computePassEncoder66.setBindGroup(0, bindGroup55);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder58); computePassEncoder58.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder38.end();
} catch {}
try {
renderPassEncoder14.setVertexBuffer(5, buffer26, 0, 23);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let computePassEncoder98 = commandEncoder10.beginComputePass({});
try {
computePassEncoder35.setBindGroup(0, bindGroup2);
} catch {}
try {
computePassEncoder18.setBindGroup(1, bindGroup7, new Uint32Array(540), 4, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder18.end();
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer23, 'uint32', 32, 108);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder5.pushDebugGroup('\u313c');
} catch {}
let gpuCanvasContext3 = canvas3.getContext('webgpu');
let commandEncoder103 = device0.createCommandEncoder({});
let computePassEncoder99 = commandEncoder100.beginComputePass({});
try {
computePassEncoder64.setBindGroup(0, bindGroup40, new Uint32Array(379), 51, 0);
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(7, buffer34, 0, 110);
} catch {}
try {
commandEncoder19.copyTextureToBuffer({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 52, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1104 */
  offset: 1104,
  bytesPerRow: 14592,
  rowsPerImage: 217,
  buffer: buffer9,
}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder100 = commandEncoder33.beginComputePass();
try {
renderPassEncoder15.setBindGroup(3, bindGroup23, new Uint32Array(1), 0, 0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer48, 4_228);
} catch {}
try {
commandEncoder103.copyBufferToBuffer(buffer25, 424, buffer0, 0, 136);
} catch {}
let computePassEncoder101 = commandEncoder19.beginComputePass({});
try {
renderPassEncoder9.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(149);
} catch {}
try {
renderPassEncoder12.setViewport(23.97919221027979, 3.228150419946305, 2.3048944600933, 1.522528596791201, 0.8092804460994455, 0.8838005650893039);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer42, 'uint16', 1_314, 2_625);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer39, 0, 202);
} catch {}
let arrayBuffer2 = buffer31.getMappedRange(520, 180);
try {
commandEncoder103.copyBufferToBuffer(buffer46, 2776, buffer42, 128, 1112);
} catch {}
try {
commandEncoder103.copyBufferToTexture({
  /* bytesInLastRow: 270 widthInBlocks: 270 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 580 */
  offset: 580,
  buffer: buffer46,
}, {
  texture: texture81,
  mipLevel: 0,
  origin: {x: 0, y: 8, z: 0},
  aspect: 'stencil-only',
}, {width: 270, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder5.popDebugGroup();
} catch {}
let commandEncoder104 = device0.createCommandEncoder({});
let textureView96 = texture38.createView({label: '\u6c82\ue71c\u4386\u6e4d\u08fd'});
let computePassEncoder102 = commandEncoder103.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer18, 6_352); };
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.drawIndexed(1_836, 0, 188, 394_187_938);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer5, 8_028);
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline4);
} catch {}
let bindGroup61 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 19, resource: textureView36}, {binding: 477, resource: textureView4}],
});
let commandEncoder105 = device0.createCommandEncoder({});
let texture100 = device0.createTexture({
  size: [840, 20, 1],
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView97 = texture4.createView({});
try {
computePassEncoder89.setBindGroup(3, bindGroup23);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup4, new Uint32Array(1325), 634, 0);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer26, 44);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline4);
} catch {}
let bindGroup62 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [
    {binding: 57, resource: {buffer: buffer46, offset: 0}},
    {binding: 10, resource: {buffer: buffer3, offset: 7936, size: 7212}},
    {binding: 329, resource: {buffer: buffer18, offset: 1280, size: 1018}},
    {binding: 501, resource: textureView56},
    {binding: 15, resource: {buffer: buffer45, offset: 768, size: 1272}},
    {binding: 114, resource: textureView69},
    {binding: 38, resource: sampler37},
    {binding: 1, resource: {buffer: buffer24, offset: 4608, size: 5800}},
  ],
});
let buffer55 = device0.createBuffer({size: 305, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM});
let computePassEncoder103 = commandEncoder104.beginComputePass({label: '\u4219\u{1fc37}\u0f9b\ue548\uefe2\uc6e0\u{1fa50}\u902a'});
let sampler60 = device0.createSampler({
  label: '\u562c\u51d2\u{1f7e6}\uf252\u2000\u2d48\u4b8e\u0c0b\u011c\u004f\u0f44',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 55.15,
  lodMaxClamp: 69.84,
});
try {
computePassEncoder83.setBindGroup(1, bindGroup42);
} catch {}
try {
computePassEncoder50.setBindGroup(3, bindGroup8, new Uint32Array(489), 35, 0);
} catch {}
try {
computePassEncoder101.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.draw(109, 0, 2_015_412_054);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer1, 64);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(3, buffer26);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
let bindGroup63 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 46, resource: sampler28}]});
let querySet14 = device0.createQuerySet({type: 'occlusion', count: 1408});
let texture101 = device0.createTexture({
  size: {width: 34, height: 7, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder104 = commandEncoder105.beginComputePass({label: '\uaa51\u{1fda9}\u0da7\u029e\u0c03\u099b\u{1f8f4}\u5110\uc9f2\u00d9'});
try {
computePassEncoder41.setBindGroup(2, bindGroup50);
} catch {}
try {
computePassEncoder103.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup42, new Uint32Array(4448), 1_214, 0);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer26, 8);
} catch {}
document.body.append(img0);
try {
globalThis.someLabel = computePassEncoder74.label;
} catch {}
let texture102 = device0.createTexture({
  size: [24, 2, 5],
  mipLevelCount: 1,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler61 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 71.44,
  lodMaxClamp: 77.66,
  compare: 'equal',
});
try {
renderPassEncoder18.setBindGroup(0, bindGroup34, new Uint32Array(5036), 367, 0);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder9.draw(108, 0, 455_172_462, 0);
} catch {}
try {
renderPassEncoder9.drawIndexed(1_547, 0, 733, 604_583_889);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer38, 'uint16', 6_630, 2_999);
} catch {}
await gc();
let buffer56 = device0.createBuffer({
  size: 24826,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder106 = device0.createCommandEncoder({});
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(6, undefined, 0, 84_639_239);
} catch {}
try {
  await promise17;
} catch {}
let texture103 = device0.createTexture({
  size: {width: 48, height: 5, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let texture104 = gpuCanvasContext1.getCurrentTexture();
let computePassEncoder105 = commandEncoder106.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroupsIndirect(buffer26, 84); };
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup18, new Uint32Array(295), 48, 0);
} catch {}
try {
renderPassEncoder17.executeBundles([renderBundle11, renderBundle11, renderBundle8, renderBundle2]);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer18, 764);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(5, buffer16);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
try {
  await promise16;
} catch {}
document.body.prepend(img0);
let bindGroup64 = device0.createBindGroup({label: '\u0b0b\u0332', layout: bindGroupLayout1, entries: [{binding: 183, resource: textureView24}]});
let buffer57 = device0.createBuffer({size: 14310, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let commandEncoder107 = device0.createCommandEncoder({label: '\u32fd\u696a\u0faa'});
let commandBuffer4 = commandEncoder107.finish();
try {
computePassEncoder33.setBindGroup(1, bindGroup22, new Uint32Array(123), 2, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup18, new Uint32Array(1064), 215, 0);
} catch {}
try {
renderPassEncoder15.setViewport(56.38435649558977, 9.874973209043837, 152.19946707586894, 42.1136955619768, 0.4656635942408901, 0.7562650421451598);
} catch {}
try {
renderPassEncoder9.draw(182, 0, 188_327_099);
} catch {}
try {
renderPassEncoder9.drawIndexed(1_683, 0, 751, 553_116_996);
} catch {}
try {
renderPassEncoder9.drawIndexedIndirect(buffer42, 580);
} catch {}
try {
computePassEncoder84.setBindGroup(0, bindGroup53, new Uint32Array(203), 8, 0);
} catch {}
try {
computePassEncoder104.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder9.drawIndexed(2_223, 0, 22, 323_972_302);
} catch {}
try {
renderPassEncoder9.drawIndirect(buffer57, 820);
} catch {}
try {
  await promise15;
} catch {}
let canvas4 = document.createElement('canvas');
let bindGroupLayout10 = device0.createBindGroupLayout({
  label: '\ucf33\u6a6a',
  entries: [
    {
      binding: 165,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' },
    },
  ],
});
let bindGroup65 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 66, resource: {buffer: buffer24, offset: 512, size: 1474}}],
});
let texture105 = device0.createTexture({
  size: {width: 48, height: 5, depthOrArrayLayers: 117},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture106 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 14},
  mipLevelCount: 2,
  format: 'depth32float-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['depth32float-stencil8'],
});
let sampler62 = device0.createSampler({addressModeU: 'repeat', magFilter: 'nearest', lodMinClamp: 48.08, lodMaxClamp: 59.63});
try {
computePassEncoder37.setBindGroup(1, bindGroup21);
} catch {}
try {
computePassEncoder20.setBindGroup(0, bindGroup9, new Uint32Array(242), 15, 0);
} catch {}
try {
renderPassEncoder9.end();
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer16, 'uint16', 2_532, 2_460);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(2, buffer21, 64);
} catch {}
try {
commandEncoder63.copyBufferToTexture({
  /* bytesInLastRow: 68 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1228 */
  offset: 1228,
  bytesPerRow: 768,
  buffer: buffer24,
}, {
  texture: texture7,
  mipLevel: 1,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
}, {width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
canvas3.width = 172;
let texture107 = device0.createTexture({
  label: '\u{1f7c7}\u00a4\u0170\ud18b\u4ee1\u0b52\u{1f7cb}\u7f70\uf225',
  size: [1080, 60, 498],
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture108 = device0.createTexture({
  size: {width: 270, height: 15, depthOrArrayLayers: 14},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder106 = commandEncoder63.beginComputePass({});
try {
renderPassEncoder1.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder12.setViewport(38.83308267611988, 3.5544894791149195, 2.2626043693851408, 1.44415408488266, 0.49931474207666127, 0.7456251162683918);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
try {
textureView21.label = '\u{1f965}\u192a\u40e0';
} catch {}
let commandEncoder108 = device0.createCommandEncoder({label: '\u{1fd76}\u059b\u73fa\u99b9\ud52a\u07ec\u064e\u6516\u0005'});
let texture109 = device0.createTexture({
  size: {width: 272, height: 60, depthOrArrayLayers: 414},
  sampleCount: 1,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture110 = device0.createTexture({size: [270], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.STORAGE_BINDING});
try {
{ clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroupsIndirect(buffer26, 40); };
} catch {}
try {
computePassEncoder100.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup19, new Uint32Array(2621), 95, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(6, buffer23, 0, 14);
} catch {}
let commandEncoder109 = device0.createCommandEncoder({});
let texture111 = device0.createTexture({
  label: '\u63ea\u0f0f\u4c14\uc8fe\u1d32',
  size: [12, 1, 29],
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture112 = device0.createTexture({
  size: {width: 540, height: 30, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['stencil8'],
});
let computePassEncoder107 = commandEncoder108.beginComputePass();
let sampler63 = device0.createSampler({
  label: '\u2037\u{1fc31}',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 86.64,
  lodMaxClamp: 97.69,
});
try {
computePassEncoder59.setBindGroup(2, bindGroup43, new Uint32Array(626), 24, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup42, new Uint32Array(1026), 143, 0);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture46,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'stencil-only',
}, new Uint8Array(4_834).fill(237), /* required buffer size: 4_834 */
{offset: 261, bytesPerRow: 153}, {width: 136, height: 30, depthOrArrayLayers: 1});
} catch {}
let bindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 10,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup66 = device0.createBindGroup({
  label: '\u6966\u{1f8e9}\u2891\uef61\u9b9a\u00d5\u9aad\ubd14',
  layout: bindGroupLayout11,
  entries: [{binding: 10, resource: {buffer: buffer16, offset: 3072, size: 1584}}],
});
let commandEncoder110 = device0.createCommandEncoder({});
let textureView98 = texture107.createView({});
let computePassEncoder108 = commandEncoder109.beginComputePass({});
try {
computePassEncoder108.setPipeline(pipeline11);
} catch {}
try {
commandEncoder110.copyTextureToBuffer({
  texture: texture89,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2040 */
  offset: 2040,
  buffer: buffer50,
}, {width: 14, height: 1, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext4 = canvas4.getContext('webgpu');
try {
gpuCanvasContext2.unconfigure();
} catch {}
let shaderModule10 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(19) var st8: texture_storage_3d<rgba8uint, write>;

@group(0) @binding(477) var tex10: texture_1d<u32>;

struct T0 {
  @align(128) @size(512) f0: mat3x4h,
  @align(64) @size(512) f1: vec4h,
  @align(64) @size(2560) f2: array<u32, 17>,
}

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

struct VertexOutput16 {
  @builtin(position) f42: vec4f,
}

struct FragmentOutput9 {
  @builtin(sample_mask) f0: u32,
  @location(0) f1: vec2u,
}

struct FragmentOutput10 {
  @location(0) @interpolate(flat, sample) f0: vec2u,
}

alias vec3b = vec3<bool>;

fn fn0(a0: mat3x2f, a1: ptr<uniform, VertexOutput16>) -> vec2i {
  var out: vec2i;
  let ptr92: ptr<uniform, vec4f> = &(*a1).f42;
  out = vec2i(i32(distance(f16(unconst_f16(4581.0)), f16(a0[u32(unconst_u32(52))][0]))));
  var vf206: vec4u = insertBits(vec4u(unconst_u32(599), unconst_u32(435), unconst_u32(2), unconst_u32(50)), vec4u(unconst_u32(214), unconst_u32(55), unconst_u32(99), unconst_u32(55)), u32(unconst_u32(172)), u32(unconst_u32(297)));
  out = vec2i(i32((*a1).f42[u32(unconst_u32(47))]));
  var vf207: vec4f = round(vec4f(unconst_f32(0.2801), unconst_f32(0.00108), unconst_f32(0.2817), unconst_f32(0.2031)));
  out &= vec2i(bitcast<i32>(sin(f32(unconst_f32(0.08677)))));
  var vf208: vec4f = floor(vec4f(unconst_f32(0.1701), unconst_f32(0.1700), unconst_f32(-0.8479), unconst_f32(0.3190)));
  let vf209: f16 = distance(f16(unconst_f16(1194.3)), f16(unconst_f16(3959.9)));
  out &= bitcast<vec2i>(vf206.zx);
  let ptr93: ptr<uniform, VertexOutput16> = &(*a1);
  var vf210: vec2f = acos(vec2f(unconst_f32(0.01351), unconst_f32(0.1357)));
  var vf211: u32 = pack4xI8(vec4i(unconst_i32(38), unconst_i32(154), unconst_i32(10), unconst_i32(41)));
  return out;
}

fn fn1() -> array<vec4<bool>, 1> {
  var out: array<vec4<bool>, 1>;
  out[0] = vec4<bool>(unpack4xU8(u32(unconst_u32(341))));
  let vf212: u32 = pack4xI8(vec4i(unconst_i32(-96), unconst_i32(42), unconst_i32(88), unconst_i32(23)));
  out[u32(unconst_u32(281))] = vec4<bool>(unpack4xU8(u32(unconst_u32(122))));
  let vf213: u32 = pack4x8snorm(vec4f(unconst_f32(-0.1056), unconst_f32(0.2267), unconst_f32(0.06218), unconst_f32(0.2268)));
  out[u32(unconst_u32(127))] = vec4<bool>(bool(pack4x8snorm(vec4f(unconst_f32(0.1785), unconst_f32(0.07564), unconst_f32(-0.08904), unconst_f32(0.07786)))));
  out[pack4xU8Clamp(vec4u(saturate(vec4h(unconst_f16(3276.3), unconst_f16(3859.2), unconst_f16(9117.1), unconst_f16(2156.6)))))] = select(vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(false)), vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false), unconst_bool(true)), bool(unconst_bool(false)));
  return out;
}

@vertex
fn vertex17() -> VertexOutput16 {
  var out: VertexOutput16;
  var vf214 = fn1();
  vf214[u32(unconst_u32(82))] = vec4<bool>(bool(pack4xU8Clamp(vec4u(unconst_u32(148), unconst_u32(375), unconst_u32(321), unconst_u32(68)))));
  out.f42 += unpack4x8unorm(dot4U8Packed(u32(unconst_u32(143)), u32(unconst_u32(460))));
  var vf215: vec4f = acos(vec4f(unconst_f32(0.1088), unconst_f32(0.6342), unconst_f32(0.8751), unconst_f32(0.1981)));
  let vf216: vec4f = asin(vec4f(unconst_f32(0.05311), unconst_f32(0.7254), unconst_f32(0.06910), unconst_f32(0.1261)));
  out.f42 = vec4f(f32(vf214[u32(unconst_u32(194))][u32(unconst_u32(177))]));
  fn1();
  var vf217: bool = vf214[0][u32(unconst_u32(97))];
  vf215 = vec4f(faceForward(vec4h(unconst_f16(3208.9), unconst_f16(7762.9), unconst_f16(4713.1), unconst_f16(2272.2)), vec4h(unconst_f16(21141.2), unconst_f16(40396.6), unconst_f16(6965.1), unconst_f16(4683.7)), faceForward(vec4h(unconst_f16(-440.7), unconst_f16(-53045.6), unconst_f16(16547.4), unconst_f16(6540.4)), vec4h(unconst_f16(13330.3), unconst_f16(10493.7), unconst_f16(1037.7), unconst_f16(8719.5)), vec4h(unconst_f16(15644.9), unconst_f16(10387.2), unconst_f16(13965.0), unconst_f16(12127.4)))));
  out.f42 = vec4f(countTrailingZeros(vec4i(unconst_i32(172), unconst_i32(152), unconst_i32(41), unconst_i32(304))));
  vf214[u32(unconst_u32(152))] = vec4<bool>(bool(acos(f16(unconst_f16(27979.4)))));
  return out;
}

@fragment
fn fragment12() -> FragmentOutput9 {
  var out: FragmentOutput9;
  textureStore(st8, vec3i(unconst_i32(40), unconst_i32(77), unconst_i32(-69)), vec4u(vec4u(unconst_u32(104), unconst_u32(235), unconst_u32(64), unconst_u32(142))));
  fn1();
  out = FragmentOutput9(bitcast<vec3u>(fma(vec3f(bitcast<f32>(pack4xU8Clamp(vec4u(unconst_u32(13), unconst_u32(1), unconst_u32(357), unconst_u32(102))))), vec3f(unconst_f32(0.3946), unconst_f32(0.3062), unconst_f32(0.00404)), vec3f(unconst_f32(0.1467), unconst_f32(1.000), unconst_f32(0.06553))))[0], vec2u(fma(vec3f(bitcast<f32>(pack4xU8Clamp(vec4u(unconst_u32(13), unconst_u32(1), unconst_u32(357), unconst_u32(102))))), vec3f(unconst_f32(0.3946), unconst_f32(0.3062), unconst_f32(0.00404)), vec3f(unconst_f32(0.1467), unconst_f32(1.000), unconst_f32(0.06553))).bg));
  out.f1 = vec2u(atan(vec3h(unconst_f16(2466.6), unconst_f16(13973.0), unconst_f16(14071.7))).yx);
  out.f0 &= bitcast<u32>(refract(vec3f(unconst_f32(0.05984), unconst_f32(-0.00403), unconst_f32(0.4042)), vec3f(unconst_f32(0.2025), unconst_f32(0.6026), unconst_f32(0.06201)), f32(unconst_f32(0.09435)))[0]);
  let vf218: vec2f = floor(vec2f(unconst_f32(0.2255), unconst_f32(0.3892)));
  let vf219: f32 = vf218[u32(fma(vec3f(unconst_f32(-0.1235), unconst_f32(-0.2067), unconst_f32(0.05426)), vec3f(unconst_f32(0.03754), unconst_f32(0.1167), unconst_f32(0.07545)), vec3f(unconst_f32(0.1358), unconst_f32(0.09548), unconst_f32(0.06961)))[0])];
  out = FragmentOutput9(vec3u(fma(vec3f(unconst_f32(0.1240), unconst_f32(0.2465), unconst_f32(0.02656)), vec3f(unconst_f32(0.2773), unconst_f32(0.00604), unconst_f32(0.2254)), vec3f(unconst_f32(0.04937), unconst_f32(0.06801), unconst_f32(0.00170)))).r, bitcast<vec2u>(fma(vec3f(unconst_f32(0.1240), unconst_f32(0.2465), unconst_f32(0.02656)), vec3f(unconst_f32(0.2773), unconst_f32(0.00604), unconst_f32(0.2254)), vec3f(unconst_f32(0.04937), unconst_f32(0.06801), unconst_f32(0.00170))).zy));
  out.f0 = vec3u(quantizeToF16(vec3f(unconst_f32(0.00306), unconst_f32(0.03021), unconst_f32(-0.02700))))[0];
  return out;
}

@fragment
fn fragment13() -> FragmentOutput10 {
  var out: FragmentOutput10;
  let vf220: bool = any(vec2<bool>(fma(vec3f(unconst_f32(0.3150), unconst_f32(0.1679), unconst_f32(0.06555)), vec3f(unconst_f32(0.05283), unconst_f32(0.4955), unconst_f32(0.1710)), vec3f(unconst_f32(0.01754), unconst_f32(0.1384), unconst_f32(-0.03900))).yy));
  out.f0 = bitcast<vec2u>(normalize(fma(vec3f(unconst_f32(0.00917), unconst_f32(-0.08069), unconst_f32(0.1990)), vec3f(unconst_f32(0.1607), unconst_f32(0.05324), unconst_f32(0.2111)), vec3f(unconst_f32(0.4926), unconst_f32(0.00326), unconst_f32(0.4248))).grbr).yw);
  let vf221: vec4f = sinh(vec4f(unconst_f32(0.2032), unconst_f32(0.7403), unconst_f32(0.04638), unconst_f32(0.1083)));
  var vf222: bool = any(vec2<bool>(unconst_bool(false), unconst_bool(true)));
  out.f0 = countTrailingZeros(bitcast<vec4u>(ldexp(vec3f(unconst_f32(0.05676), unconst_f32(0.04228), unconst_f32(0.2068)), vec3i(unconst_i32(86), unconst_i32(211), unconst_i32(173))).rrrg)).wx;
  var vf223: vec4f = normalize(vec4f(unconst_f32(0.01914), unconst_f32(0.1773), unconst_f32(0.2010), unconst_f32(0.2511)));
  textureStore(st8, vec3i(unconst_i32(116), unconst_i32(16), unconst_i32(571)), vec4u(vec4u(unconst_u32(22), unconst_u32(1), unconst_u32(12), unconst_u32(86))));
  out.f0 += vec2u(sinh(vec4f(unconst_f32(0.01279), unconst_f32(0.1605), unconst_f32(0.1597), unconst_f32(0.00530))).ab);
  textureStore(st8, vec3i(unconst_i32(42), unconst_i32(375), unconst_i32(125)), vec4u(unpack4xU8(bitcast<u32>(vf223[u32(unconst_u32(26))]))));
  var vf224: vec4u = countTrailingZeros(vec4u(unconst_u32(243), unconst_u32(161), unconst_u32(304), unconst_u32(218)));
  vf224 += vec4u(atan(vec2f(unconst_f32(0.08755), unconst_f32(0.1002))).grrr);
  vf223 += vec4f(f32(vf220));
  fn1();
  vf224 >>= abs(vec4u(unconst_u32(316), unconst_u32(30), unconst_u32(19), unconst_u32(121)));
  let ptr94: ptr<function, vec4f> = &vf223;
  vf224 *= vec4u((*ptr94));
  textureStore(st8, vec3i(unconst_i32(16), unconst_i32(644), unconst_i32(2)), vec4u(vec4u(unconst_u32(322), unconst_u32(468), unconst_u32(133), unconst_u32(33))));
  let vf225: vec4u = abs(vec4u(unconst_u32(89), unconst_u32(34), unconst_u32(614), unconst_u32(260)));
  discard;
  return out;
}

@compute @workgroup_size(2, 1, 1)
fn compute10() {
  var vf226 = fn1();
  vf226[u32(extractBits(vec3i(unconst_i32(28), unconst_i32(92), unconst_i32(67)), u32(unconst_u32(71)), u32(unconst_u32(9)))[0])] = vec4<bool>(bool(pack4xU8(vec4u(unconst_u32(108), unconst_u32(197), unconst_u32(116), unconst_u32(0)))));
}`,
  sourceMap: {},
});
let bindGroup67 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 46, resource: sampler8}]});
let commandEncoder111 = device0.createCommandEncoder({});
let texture113 = device0.createTexture({
  label: '\u09ab\u0963\uad79\u53fd\u0c2d\u{1f6a2}',
  size: {width: 68, height: 15, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView99 = texture84.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1});
let computePassEncoder109 = commandEncoder111.beginComputePass();
let renderPassEncoder21 = commandEncoder110.beginRenderPass({
  colorAttachments: [{
  view: textureView47,
  depthSlice: 46,
  clearValue: { r: 842.2, g: -498.2, b: 805.8, a: -122.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder3.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup0, new Uint32Array(3229), 256, 0);
} catch {}
try {
renderPassEncoder20.setViewport(538.163746644042, 27.886821048432463, 535.3499092055023, 3.688182841184899, 0.6862545147224971, 0.8491457196009682);
} catch {}
let arrayBuffer3 = buffer31.getMappedRange(704, 256);
try {
device0.queue.copyExternalImageToTexture(/*
{width: 272, height: 60, depthOrArrayLayers: 414}
*/
{
  source: imageData8,
  origin: { x: 6, y: 4 },
  flipY: true,
}, {
  texture: texture109,
  mipLevel: 0,
  origin: {x: 31, y: 1, z: 32},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 26, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder112 = device0.createCommandEncoder({});
let texture114 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder110 = commandEncoder112.beginComputePass({});
try {
computePassEncoder101.setBindGroup(0, bindGroup60);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder110.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder20.setBindGroup(2, bindGroup41);
} catch {}
try {
computePassEncoder58.insertDebugMarker('\u3381');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer28, 1820, new BigUint64Array(6294), 745, 20);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 34, height: 7, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas0,
  origin: { x: 5, y: 4 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData11 = new ImageData(84, 28);
let bindGroup68 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 10, resource: {buffer: buffer55, offset: 0, size: 25}}],
});
let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder113 = device0.createCommandEncoder({});
let textureView100 = texture111.createView({baseMipLevel: 0});
let computePassEncoder111 = commandEncoder113.beginComputePass();
try {
computePassEncoder27.setBindGroup(3, bindGroup29);
} catch {}
try {
renderPassEncoder15.setPipeline(pipeline2);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup69 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 10, resource: {buffer: buffer10, offset: 0, size: 816}}],
});
let buffer58 = device0.createBuffer({
  label: '\u0293\u0d15\u0d2c\ucabb\ue332',
  size: 33159,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: false,
});
let commandEncoder114 = device0.createCommandEncoder();
let texture115 = device0.createTexture({
  size: {width: 135, height: 7, depthOrArrayLayers: 1},
  format: 'stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView101 = texture87.createView({dimension: '2d'});
let computePassEncoder112 = commandEncoder114.beginComputePass({label: '\uf8e6\u884a\u5203\ubf6f\u887b\u075d\u014b\ubc31\u0318\u26b3'});
try {
computePassEncoder53.setBindGroup(3, bindGroup32);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup20, new Uint32Array(2360), 26, 0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(7, buffer28);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 270, height: 15, depthOrArrayLayers: 5}
*/
{
  source: img0,
  origin: { x: 9, y: 7 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 1,
  origin: {x: 51, y: 6, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder115 = device0.createCommandEncoder({});
let renderPassEncoder22 = commandEncoder115.beginRenderPass({
  label: '\u44a9\u5085\u{1f81a}\u9c17\u54bd\ub1d9\u{1fd30}\u78b3\u4e6b',
  colorAttachments: [{view: textureView75, depthSlice: 7, loadOp: 'load', storeOp: 'store'}],
  maxDrawCount: 440817056,
});
try {
renderPassEncoder20.setBindGroup(0, bindGroup20);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer4, 'uint32', 284, 226);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 8, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture116 = device0.createTexture({
  size: [1080, 60, 55],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler64 = device0.createSampler({
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 56.89,
  lodMaxClamp: 57.54,
  maxAnisotropy: 12,
});
try {
computePassEncoder64.setBindGroup(2, bindGroup59);
} catch {}
let commandEncoder116 = device0.createCommandEncoder({});
let querySet15 = device0.createQuerySet({type: 'occlusion', count: 273});
let computePassEncoder113 = commandEncoder116.beginComputePass({label: '\u008e\u6de9\u{1f8b6}\u08c5'});
let externalTexture12 = device0.importExternalTexture({source: videoFrame3});
try {
{ clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder113.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder18.executeBundles([]);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(7, buffer9);
} catch {}
try {
buffer19.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 67, height: 3, depthOrArrayLayers: 9}
*/
{
  source: canvas0,
  origin: { x: 3, y: 11 },
  flipY: true,
}, {
  texture: texture47,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 54, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView102 = texture68.createView({});
try {
computePassEncoder46.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder4.setBindGroup(3, bindGroup62, new Uint32Array(232), 47, 1);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup57);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup24, new Uint32Array(280), 83, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(5, buffer34, 564, 740);
} catch {}
try {
computePassEncoder96.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
device0.queue.writeBuffer(buffer50, 532, new DataView(new ArrayBuffer(5266)), 1015, 332);
} catch {}
let videoFrame10 = new VideoFrame(img0, {timestamp: 0});
let commandEncoder117 = device0.createCommandEncoder({});
let computePassEncoder114 = commandEncoder117.beginComputePass({});
try {
computePassEncoder97.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer56, 'uint32', 1_400, 10_036);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline4);
} catch {}
try {
buffer8.unmap();
} catch {}
try {
globalThis.someLabel = buffer44.label;
} catch {}
try {
computePassEncoder56.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder112.setPipeline(pipeline12);
} catch {}
let textureView103 = texture83.createView({dimension: '2d-array', mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder84); computePassEncoder84.dispatchWorkgroupsIndirect(buffer51, 44); };
} catch {}
try {
computePassEncoder98.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(2, buffer0, 0);
} catch {}
let textureView104 = texture33.createView({});
let sampler65 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 70.41,
});
try {
renderPassEncoder22.setBindGroup(1, bindGroup56, new Uint32Array(160), 2, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer21, 'uint32', 2_580, 2_660);
} catch {}
let buffer59 = device0.createBuffer({
  size: 2024,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder118 = device0.createCommandEncoder({});
let texture117 = gpuCanvasContext1.getCurrentTexture();
let renderPassEncoder23 = commandEncoder118.beginRenderPass({
  label: '\u3eac\u{1fbf3}\u8e93\udca0',
  colorAttachments: [{
  view: textureView47,
  depthSlice: 0,
  clearValue: { r: 516.5, g: 687.7, b: -800.7, a: 625.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet8,
});
try {
computePassEncoder79.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer16, 'uint32', 1_820, 20);
} catch {}
try {
buffer18.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer34, 1268, new Float32Array(9948), 512, 32);
} catch {}
document.body.append(canvas2);
let bindGroup70 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 64, resource: textureView69}]});
try {
computePassEncoder49.setBindGroup(0, bindGroup34, []);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(39);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle1, renderBundle4, renderBundle5]);
} catch {}
try {
renderPassEncoder21.setScissorRect(0, 0, 1, 0);
} catch {}
let texture118 = device0.createTexture({
  size: {width: 105, height: 2, depthOrArrayLayers: 30},
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView105 = texture55.createView({
  dimension: 'cube-array',
  aspect: 'stencil-only',
  mipLevelCount: 1,
  baseArrayLayer: 1,
  arrayLayerCount: 6,
});
let sampler66 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 81.57,
  maxAnisotropy: 8,
});
try {
computePassEncoder102.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(5, buffer5);
} catch {}
let bindGroup71 = device0.createBindGroup({layout: bindGroupLayout10, entries: [{binding: 165, resource: textureView100}]});
let buffer60 = device0.createBuffer({
  size: 7352,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX,
  mappedAtCreation: false,
});
let textureView106 = texture105.createView({dimension: '3d'});
try {
buffer2.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(258).fill(210), /* required buffer size: 258 */
{offset: 258}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
try {
computePassEncoder76.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder23.end();
} catch {}
try {
commandEncoder118.copyTextureToTexture({
  texture: texture111,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture105,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 4});
} catch {}
try {
commandEncoder118.resolveQuerySet(querySet15, 40, 17, buffer8, 0);
} catch {}
try {
renderPassEncoder13.popDebugGroup();
} catch {}
try {
renderPassEncoder13.insertDebugMarker('\u0859');
} catch {}
try {
computePassEncoder111.setPipeline(pipeline5);
} catch {}
try {
commandEncoder118.resolveQuerySet(querySet13, 0, 1, buffer0, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture95,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'stencil-only',
}, new Uint8Array(76).fill(121), /* required buffer size: 76 */
{offset: 76, bytesPerRow: 979}, {width: 840, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup72 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 10, resource: {buffer: buffer25, offset: 1792, size: 557}}],
});
let buffer61 = device0.createBuffer({
  label: '\u6144\u0537\uc21b\u0aba\u00c2\u{1f860}',
  size: 15645,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
});
let commandEncoder119 = device0.createCommandEncoder({label: '\u48f9\uaa48\u8a07\u0181\u1338\u0f0a\ucdb2\u4587\u02e4\u3338'});
let querySet16 = device0.createQuerySet({type: 'occlusion', count: 210});
let computePassEncoder115 = commandEncoder118.beginComputePass({});
let renderPassEncoder24 = commandEncoder119.beginRenderPass({
  label: '\u4ad9\u{1f64b}\uafc4\u5337\ua93c\u9f2d\uf770\u{1fb91}\ub220',
  colorAttachments: [{view: textureView47, depthSlice: 32, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet9,
});
try {
computePassEncoder45.setBindGroup(0, bindGroup30);
} catch {}
try {
computePassEncoder114.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer22);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'bt2020_12bit'} });
let bindGroup73 = device0.createBindGroup({
  label: '\u2675\ubc57\u6126\uf343\u01e1\u{1f990}\u0cce\ub452\ufc6c',
  layout: bindGroupLayout8,
  entries: [{binding: 46, resource: sampler27}],
});
try {
{ clearResourceUsages(device0, computePassEncoder49); computePassEncoder49.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder109.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder24.setBindGroup(3, bindGroup9);
} catch {}
try {
renderPassEncoder15.setBindGroup(1, bindGroup63, new Uint32Array(240), 62, 0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle0]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
let buffer62 = device0.createBuffer({
  size: 1605,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder120 = device0.createCommandEncoder();
let computePassEncoder116 = commandEncoder120.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder58); computePassEncoder58.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer16, 'uint16', 4_156, 898);
} catch {}
try {
buffer43.unmap();
} catch {}
await gc();
let querySet17 = device0.createQuerySet({type: 'occlusion', count: 1695});
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView8}, {binding: 19, resource: textureView36}],
});
let buffer63 = device0.createBuffer({
  size: 42888,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder121 = device0.createCommandEncoder({});
let computePassEncoder117 = commandEncoder121.beginComputePass({});
try {
computePassEncoder116.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer61, 'uint32', 1_512, 5_662);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(2, buffer47);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 272, height: 60, depthOrArrayLayers: 414}
*/
{
  source: canvas4,
  origin: { x: 40, y: 17 },
  flipY: true,
}, {
  texture: texture109,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 23},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 85, height: 7, depthOrArrayLayers: 0});
} catch {}
await gc();
let textureView107 = texture12.createView({dimension: '3d'});
let sampler67 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 48.66,
  compare: 'never',
});
try {
computePassEncoder26.setBindGroup(0, bindGroup38);
} catch {}
try {
computePassEncoder70.setBindGroup(0, bindGroup4, new Uint32Array(1841), 358, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder57); computePassEncoder57.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder107.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline2);
} catch {}
let texture119 = device0.createTexture({
  label: '\u4182\u72dc\u{1f899}\u{1f92a}\u{1fe9c}\u0659\ud192\u0570\u0d43',
  size: [270, 15, 42],
  mipLevelCount: 4,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView108 = texture28.createView({
  label: '\u411f\u43fb\u{1fe13}\u{1f906}\ue5e4\u{1fbec}\u{1fa23}\u3868\u{1ff71}\uf6e1\udd87',
  aspect: 'depth-only',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 2,
  arrayLayerCount: 24,
});
try {
computePassEncoder108.setBindGroup(0, bindGroup15);
} catch {}
try {
computePassEncoder41.setPipeline(pipeline11);
} catch {}
try {
computePassEncoder99.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup56);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, buffer14, 0);
} catch {}
let buffer64 = device0.createBuffer({
  size: 16355,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView109 = texture18.createView({dimension: 'cube-array', arrayLayerCount: 6});
let textureView110 = texture75.createView({dimension: '2d-array', aspect: 'stencil-only', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder15.setBindGroup(0, bindGroup60);
} catch {}
try {
computePassEncoder105.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer23, 'uint32', 36, 46);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(6, buffer29, 4);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup47, new Uint32Array(122), 62, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle2, renderBundle0]);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer1, 'uint16', 1_890, 120);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 324, new BigUint64Array(14966), 2304, 124);
} catch {}
let bindGroupLayout12 = device0.createBindGroupLayout({
  label: '\u0411\ud642\ue5e2\u8bff',
  entries: [
    {
      binding: 135,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let commandEncoder122 = device0.createCommandEncoder({});
let sampler68 = device0.createSampler({
  label: '\u021c\ude6f\u9060\u030d\u053b\u6537\u4069\u455d\u6bd2\u{1f986}',
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 31.45,
  maxAnisotropy: 16,
});
try {
computePassEncoder34.setBindGroup(0, bindGroup15);
} catch {}
try {
computePassEncoder115.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup60);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer40, 'uint32', 344, 435);
} catch {}
try {
buffer35.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer50, 188, new Float32Array(13420), 836, 360);
} catch {}
let bindGroup75 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 245, resource: textureView13}]});
let buffer65 = device0.createBuffer({
  size: 4325,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder123 = device0.createCommandEncoder({});
try {
computePassEncoder48.setBindGroup(0, bindGroup11);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder18.setBindGroup(3, bindGroup47, new Uint32Array(2145), 1_038, 0);
} catch {}
try {
renderPassEncoder13.beginOcclusionQuery(2);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let computePassEncoder118 = commandEncoder122.beginComputePass({});
let sampler69 = device0.createSampler({
  label: '\u{1f7ff}\u{1fc42}\uaf15\u{1fd77}\u2121\u{1f8b8}\u06e8\u{1f90d}\u{1f890}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.55,
  maxAnisotropy: 17,
});
try {
computePassEncoder92.setBindGroup(0, bindGroup18);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1); };
} catch {}
try {
commandEncoder123.copyBufferToBuffer(buffer64, 2772, buffer23, 56, 0);
} catch {}
try {
commandEncoder123.copyTextureToTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 16},
  aspect: 'all',
},
{
  texture: texture47,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder124 = device0.createCommandEncoder();
let textureView111 = texture23.createView({});
let computePassEncoder119 = commandEncoder124.beginComputePass({label: '\u7b6a\u0ae6\u06a9\ue21e\ua080'});
let sampler70 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', minFilter: 'nearest', lodMaxClamp: 89.03});
try {
computePassEncoder49.setBindGroup(2, bindGroup8, new Uint32Array(2789), 1_187, 0);
} catch {}
try {
renderPassEncoder12.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder1.setViewport(20.671653408109123, 1.81644809713151, 18.011120010092057, 1.4372762936247923, 0.7665029890107207, 0.879001589266045);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer64, 'uint16', 410, 2_309);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
let imageData12 = new ImageData(108, 24);
let pipelineLayout12 = device0.createPipelineLayout({label: '\u1611\u1bb7\u6cc7\u0087\u{1f9e7}\u{1ffb1}\u0421\u0322\u71bf', bindGroupLayouts: []});
let textureView112 = texture28.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5});
let sampler71 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 68.78,
  lodMaxClamp: 92.60,
});
try {
computePassEncoder100.setBindGroup(0, bindGroup37);
} catch {}
try {
computePassEncoder117.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup72);
} catch {}
try {
renderPassEncoder19.setViewport(47.13418728389492, 4.822774895093069, 0.5824554000044492, 0.10256272395252249, 0.2811874349594248, 0.889807591054675);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer21, 'uint32', 4_052, 480);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(3, buffer56, 13_404, 2_017);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 152, new Float32Array(15180), 2349, 8);
} catch {}
let imageData13 = new ImageData(80, 24);
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpteRp431', transfer: 'bt1361ExtendedColourGamut'} });
try {
globalThis.someLabel = computePassEncoder103.label;
} catch {}
let commandEncoder125 = device0.createCommandEncoder({});
let commandBuffer5 = commandEncoder123.finish();
let texture120 = device0.createTexture({
  size: [48, 5, 1],
  mipLevelCount: 3,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView113 = texture52.createView({
  label: '\u00a3\uf998\u065e\u{1fe84}\u0ce8\u5c9b\ud10a\u0029\u8c64',
  aspect: 'stencil-only',
  mipLevelCount: 1,
});
let renderPassEncoder25 = commandEncoder125.beginRenderPass({
  colorAttachments: [{
  view: textureView9,
  clearValue: { r: -206.4, g: -479.2, b: 184.4, a: 414.0, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder35.setBindGroup(3, bindGroup10, new Uint32Array(2880), 47, 0);
} catch {}
try {
computePassEncoder118.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle0, renderBundle2, renderBundle11]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture98,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 14},
  aspect: 'all',
}, new Uint8Array(203).fill(192), /* required buffer size: 203 */
{offset: 203, bytesPerRow: 7, rowsPerImage: 0}, {width: 1, height: 0, depthOrArrayLayers: 39});
} catch {}
let commandEncoder126 = device0.createCommandEncoder({});
let renderPassEncoder26 = commandEncoder126.beginRenderPass({
  colorAttachments: [{
  view: textureView75,
  depthSlice: 0,
  clearValue: { r: -192.1, g: -48.18, b: 536.6, a: 212.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet8,
});
try {
computePassEncoder119.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder13.setScissorRect(31, 0, 4, 0);
} catch {}
let commandEncoder127 = device0.createCommandEncoder({});
let querySet18 = device0.createQuerySet({type: 'occlusion', count: 382});
let textureView114 = texture70.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderPassEncoder27 = commandEncoder127.beginRenderPass({
  colorAttachments: [{
  view: textureView75,
  depthSlice: 7,
  clearValue: { r: 806.1, g: -593.1, b: 969.9, a: 478.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let externalTexture13 = device0.importExternalTexture({source: videoFrame6});
try {
computePassEncoder114.setBindGroup(2, bindGroup17, new Uint32Array(1368), 308, 0);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(7, buffer37, 0, 1_032);
} catch {}
let commandEncoder128 = device0.createCommandEncoder({});
let textureView115 = texture70.createView({label: '\u62df\u{1f839}', mipLevelCount: 1});
let textureView116 = texture30.createView({dimension: '2d', format: 'depth32float-stencil8', mipLevelCount: 1});
let computePassEncoder120 = commandEncoder128.beginComputePass({label: '\ud48b\u0c22\u8f89\u007b\u9773\ucb4d\u{1f608}\u58ac\u0893\u{1f72d}'});
let sampler72 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 99.68,
});
try {
{ clearResourceUsages(device0, computePassEncoder70); computePassEncoder70.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder21.setBindGroup(2, bindGroup40);
} catch {}
try {
renderPassEncoder17.setBindGroup(1, bindGroup65, new Uint32Array(828), 339, 0);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer5, 5620, new BigUint64Array(26096), 13398, 212);
} catch {}
let promise18 = device0.queue.onSubmittedWorkDone();
try {
  await promise18;
} catch {}
let texture121 = device0.createTexture({
  size: {width: 1080, height: 60, depthOrArrayLayers: 1},
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
let sampler73 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 91.44,
  lodMaxClamp: 94.22,
});
try {
computePassEncoder103.setBindGroup(1, bindGroup32);
} catch {}
try {
computePassEncoder42.end();
} catch {}
try {
computePassEncoder106.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer42, 'uint16', 3_410, 2_411);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 48, height: 5, depthOrArrayLayers: 117}
*/
{
  source: imageData2,
  origin: { x: 1, y: 0 },
  flipY: false,
}, {
  texture: texture105,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 36},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder129 = device0.createCommandEncoder({});
let querySet19 = device0.createQuerySet({label: '\udf06\u4f9f\ub092\u8872', type: 'occlusion', count: 679});
try {
computePassEncoder120.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder18.setBlendConstant({ r: 388.4, g: 300.6, b: -905.6, a: -562.1, });
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer10, 'uint16', 1_202, 1_373);
} catch {}
try {
commandEncoder45.copyBufferToBuffer(buffer63, 13124, buffer60, 6000, 4);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer40, 84, new BigUint64Array(50906), 24043, 136);
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'smpte240m'} });
let texture122 = gpuCanvasContext1.getCurrentTexture();
try {
renderPassEncoder18.setBindGroup(3, bindGroup25, new Uint32Array(645), 43, 0);
} catch {}
try {
commandEncoder129.copyTextureToTexture({
  texture: texture107,
  mipLevel: 0,
  origin: {x: 104, y: 16, z: 44},
  aspect: 'all',
},
{
  texture: texture109,
  mipLevel: 0,
  origin: {x: 49, y: 1, z: 83},
  aspect: 'all',
},
{width: 35, height: 3, depthOrArrayLayers: 64});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 48, height: 5, depthOrArrayLayers: 1}
*/
{
  source: imageData3,
  origin: { x: 4, y: 9 },
  flipY: true,
}, {
  texture: texture80,
  mipLevel: 1,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData14 = new ImageData(28, 28);
let bindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 169,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '2d' },
    },
  ],
});
let bindGroup76 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 66, resource: {buffer: buffer51, offset: 0, size: 109}}],
});
let texture123 = device0.createTexture({
  label: '\u0b6e\u294a\u1f9f\u90a2\u2fa1\u{1fb9c}\u{1f882}',
  size: {width: 24, height: 2, depthOrArrayLayers: 1},
  format: 'rgba8snorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder121 = commandEncoder129.beginComputePass({});
try {
renderPassEncoder16.setBindGroup(0, bindGroup13);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroup77 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [{binding: 477, resource: textureView20}, {binding: 19, resource: textureView96}],
});
let commandEncoder130 = device0.createCommandEncoder({});
let commandBuffer6 = commandEncoder45.finish();
let texture124 = device0.createTexture({
  label: '\u{1ff6b}\uec41\u538e\u98a0\u87a1',
  size: {width: 68, height: 15, depthOrArrayLayers: 20},
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView117 = texture6.createView({aspect: 'all'});
let computePassEncoder122 = commandEncoder130.beginComputePass();
try {
computePassEncoder0.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder20.setBindGroup(2, bindGroup28, new Uint32Array(3107), 504, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder100); computePassEncoder100.dispatchWorkgroups(3); };
} catch {}
try {
computePassEncoder58.end();
} catch {}
try {
computePassEncoder121.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(3, buffer39, 1_232, 184);
} catch {}
try {
commandEncoder61.copyTextureToTexture({
  texture: texture101,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture41,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 1},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder2.insertDebugMarker('\u{1fdf7}');
} catch {}
let buffer66 = device0.createBuffer({
  size: 115,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView118 = texture123.createView({label: '\u3963\ued1b\u{1ff5b}'});
let texture125 = device0.createTexture({
  label: '\u63dd\u8c12\u{1fd25}\u118a\uc8f9\u{1f997}\u0468\u1744\uc0fb\u5e33\u0a15',
  size: {width: 272, height: 60, depthOrArrayLayers: 42},
  sampleCount: 1,
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder123 = commandEncoder61.beginComputePass({});
try {
computePassEncoder51.setBindGroup(1, bindGroup31);
} catch {}
try {
computePassEncoder122.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer32, 'uint32', 528, 1_766);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
await gc();
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'bt2020_10bit'} });
let texture126 = device0.createTexture({
  size: {width: 48, height: 5, depthOrArrayLayers: 1},
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder123.setPipeline(pipeline5);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup42);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup61, new Uint32Array(11), 2, 0);
} catch {}
try {
renderPassEncoder27.setStencilReference(671);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline4);
} catch {}
try {
computePassEncoder66.setBindGroup(3, bindGroup25);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup40, new Uint32Array(1253), 75, 0);
} catch {}
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.setBlendConstant({ r: 856.1, g: -987.0, b: 361.2, a: 774.1, });
} catch {}
try {
renderPassEncoder19.setViewport(45.965903574321054, 4.554594859900145, 1.525630065964791, 0.3354201657217117, 0.8529855521256862, 0.8794154110078755);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer61, 'uint16', 548, 15_008);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let commandEncoder131 = device0.createCommandEncoder({});
let sampler74 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 74.47,
  lodMaxClamp: 82.87,
});
try {
renderPassEncoder19.setBindGroup(0, bindGroup41, new Uint32Array(1297), 111, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle2, renderBundle11, renderBundle0, renderBundle11, renderBundle5]);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer32, 'uint32', 528, 2_666);
} catch {}
try {
buffer66.unmap();
} catch {}
try {
commandEncoder131.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 688 */
  offset: 688,
  buffer: buffer39,
}, {
  texture: texture113,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer6, commandBuffer5]);
} catch {}
let commandEncoder132 = device0.createCommandEncoder({});
let textureView119 = texture123.createView({mipLevelCount: 1});
let sampler75 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.88,
  lodMaxClamp: 82.48,
  maxAnisotropy: 6,
});
try {
computePassEncoder36.end();
} catch {}
try {
renderPassEncoder20.setVertexBuffer(0, buffer32, 1_400, 804);
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(124, 69);
let bindGroup78 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 183, resource: textureView24}]});
let buffer67 = device0.createBuffer({
  size: 6648,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder133 = device0.createCommandEncoder({});
let texture127 = device0.createTexture({
  size: {width: 136, height: 30, depthOrArrayLayers: 1},
  format: 'stencil8',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder8.setBindGroup(0, bindGroup0);
} catch {}
try {
renderPassEncoder21.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder26.setBindGroup(1, bindGroup29, new Uint32Array(201), 130, 0);
} catch {}
try {
commandEncoder133.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3622 */
  offset: 3622,
  bytesPerRow: 37120,
  buffer: buffer67,
}, {
  texture: texture126,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer8, 176, new Float32Array(1641), 3, 68);
} catch {}
let gpuCanvasContext5 = offscreenCanvas1.getContext('webgpu');
let bindGroup79 = device0.createBindGroup({
  layout: bindGroupLayout11,
  entries: [{binding: 10, resource: {buffer: buffer51, offset: 0, size: 110}}],
});
let textureView120 = texture105.createView({dimension: '3d', arrayLayerCount: 1});
let computePassEncoder124 = commandEncoder131.beginComputePass({});
try {
computePassEncoder93.setBindGroup(0, bindGroup15, new Uint32Array(3086), 110, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder22.setBindGroup(0, bindGroup36, new Uint32Array(1576), 7, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(212).fill(55), /* required buffer size: 212 */
{offset: 212}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture34,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline13 = await device0.createComputePipelineAsync({
  layout: pipelineLayout2,
  compute: {module: shaderModule4, entryPoint: 'compute3', constants: {10_124: 0, 7_828: 0}},
});
document.body.append(canvas0);
let textureView121 = texture25.createView({label: '\u4921\u2f82', baseArrayLayer: 4, arrayLayerCount: 54});
let computePassEncoder125 = commandEncoder132.beginComputePass({});
try {
computePassEncoder107.setBindGroup(2, bindGroup27);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline4);
} catch {}
try {
commandEncoder39.resolveQuerySet(querySet19, 196, 3, buffer23, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
canvas0.height = 506;
try {
globalThis.someLabel = computePassEncoder95.label;
} catch {}
let texture128 = device0.createTexture({
  size: {width: 135, height: 7, depthOrArrayLayers: 77},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let textureView122 = texture69.createView({label: '\u{1fa31}\u{1f98c}\u4d64\u7ac3\ueebd\u7742\u0321', dimension: '2d-array'});
let computePassEncoder126 = commandEncoder39.beginComputePass({label: '\u4e8c\u884c\u45ff\u{1f88d}\u44ae\u0ab2'});
let sampler76 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 55.12,
  lodMaxClamp: 77.12,
});
try {
computePassEncoder62.setBindGroup(1, bindGroup29);
} catch {}
try {
computePassEncoder126.setPipeline(pipeline11);
} catch {}
try {
renderPassEncoder20.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder20.drawIndirect(buffer20, 324);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture76,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(373).fill(43), /* required buffer size: 373 */
{offset: 373}, {width: 50, height: 6, depthOrArrayLayers: 0});
} catch {}
let bindGroup80 = device0.createBindGroup({layout: bindGroupLayout12, entries: [{binding: 135, resource: sampler0}]});
try {
computePassEncoder125.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder20.drawIndexedIndirect(buffer51, 68);
} catch {}
document.body.append(canvas1);
let bindGroup81 = device0.createBindGroup({
  label: '\u4929\ub0fd\uedc2\u0300\ub80d\u{1fbf1}\u0e9a',
  layout: bindGroupLayout8,
  entries: [{binding: 46, resource: sampler16}],
});
let commandEncoder134 = device0.createCommandEncoder();
let computePassEncoder127 = commandEncoder133.beginComputePass({});
try {
computePassEncoder77.setBindGroup(0, bindGroup15, new Uint32Array(2494), 107, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder92); computePassEncoder92.dispatchWorkgroupsIndirect(buffer52, 288); };
} catch {}
try {
computePassEncoder33.end();
} catch {}
try {
computePassEncoder124.setPipeline(pipeline6);
} catch {}
try {
renderPassEncoder20.drawIndexedIndirect(buffer26, 16);
} catch {}
try {
renderPassEncoder20.drawIndirect(buffer66, 0);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer67, 'uint32', 620, 3_769);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(3, buffer29, 0, 98);
} catch {}
let bindGroup82 = device0.createBindGroup({
  layout: bindGroupLayout6,
  entries: [
    {binding: 10, resource: {buffer: buffer40, offset: 0, size: 1776}},
    {binding: 114, resource: textureView66},
    {binding: 15, resource: {buffer: buffer46, offset: 0}},
    {binding: 57, resource: {buffer: buffer9, offset: 256, size: 1212}},
    {binding: 38, resource: sampler9},
    {binding: 501, resource: textureView56},
    {binding: 1, resource: {buffer: buffer34, offset: 0, size: 1552}},
    {binding: 329, resource: {buffer: buffer5, offset: 256, size: 2770}},
  ],
});
let texture129 = device0.createTexture({
  size: [272, 60, 1],
  format: 'stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder128 = commandEncoder134.beginComputePass({});
let sampler77 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 96.72,
  lodMaxClamp: 97.50,
  maxAnisotropy: 19,
});
try {
renderPassEncoder20.drawIndexedIndirect(buffer22, 384);
} catch {}
document.body.append(img0);
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt470m', transfer: 'log'} });
let computePassEncoder129 = commandEncoder36.beginComputePass({});
try {
computePassEncoder4.setBindGroup(0, bindGroup15);
} catch {}
try {
computePassEncoder128.setPipeline(pipeline3);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 540, height: 30, depthOrArrayLayers: 10}
*/
{
  source: imageData14,
  origin: { x: 1, y: 4 },
  flipY: false,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 17, y: 11, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
computePassEncoder106.setBindGroup(3, bindGroup21, new Uint32Array(716), 194, 0);
} catch {}
try {
computePassEncoder129.setPipeline(pipeline12);
} catch {}
try {
renderPassEncoder15.setBlendConstant({ r: 889.9, g: 514.2, b: -339.8, a: -499.5, });
} catch {}
try {
renderPassEncoder20.draw(0, 388, 0, 152_579_705);
} catch {}
try {
renderPassEncoder20.drawIndirect(buffer65, 476);
} catch {}
try {
renderPassEncoder17.setIndexBuffer(buffer56, 'uint16', 2_526, 1_236);
} catch {}
try {
buffer57.unmap();
} catch {}
videoFrame0.close();
videoFrame3.close();
videoFrame4.close();
videoFrame5.close();
videoFrame6.close();
videoFrame7.close();
videoFrame8.close();
videoFrame9.close();
videoFrame11.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
}
async function window1() {
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({requiredFeatures: ['depth32float-stencil8', 'indirect-first-instance', 'shader-f16']});
let commandEncoder0 = device0.createCommandEncoder({label: '\u{1f89c}\u0864\u{1fe47}\u{1fe39}'});
let computePassEncoder0 = commandEncoder0.beginComputePass();
let sampler0 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 55.30,
  lodMaxClamp: 68.60,
});
let commandEncoder1 = device0.createCommandEncoder({});
let texture0 = device0.createTexture({
  size: {width: 26, height: 1, depthOrArrayLayers: 4},
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['r16float'],
});
let bindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 184,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
    },
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout0]});
let commandEncoder2 = device0.createCommandEncoder({});
let texture1 = device0.createTexture({
  size: {width: 52, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let commandEncoder3 = device0.createCommandEncoder({});
let texture2 = device0.createTexture({
  size: {width: 145, height: 12, depthOrArrayLayers: 2},
  dimension: '2d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder1 = commandEncoder3.beginComputePass({});
let bindGroupLayout1 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 357,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 120,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 39,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '3d' },
    },
    {binding: 37, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 124,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer0 = device0.createBuffer({size: 3043, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let texture3 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 21},
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder2 = commandEncoder1.beginComputePass({});
let pipelineLayout1 = device0.createPipelineLayout({label: '\u0065\uae9f\uf276\u206f', bindGroupLayouts: []});
let commandEncoder4 = device0.createCommandEncoder();
let texture4 = device0.createTexture({
  size: [52, 1, 14],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView0 = texture2.createView({dimension: '2d'});
let sampler1 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 84.82,
  lodMaxClamp: 89.07,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer1 = device0.createBuffer({
  size: 32609,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture5 = device0.createTexture({
  label: '\ubee5\ubeaf\ua4f6\u0569\u0aa0\u67f5\u{1fb88}\ufb56\u679f',
  size: {width: 145, height: 12, depthOrArrayLayers: 2},
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder3 = commandEncoder4.beginComputePass({});
let sampler2 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 78.08,
  lodMaxClamp: 87.56,
  maxAnisotropy: 1,
});
let bindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 329,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let textureView1 = texture4.createView({mipLevelCount: 1});
let texture6 = device0.createTexture({
  size: {width: 145, height: 12, depthOrArrayLayers: 2},
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
buffer1.unmap();
} catch {}
try {
commandEncoder2.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 898 */
  offset: 898,
  buffer: buffer1,
}, {
  texture: texture1,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture7 = device0.createTexture({
  size: [290, 24, 2],
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture8 = device0.createTexture({
  size: [210, 1, 422],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView2 = texture7.createView({dimension: '2d', baseMipLevel: 1, baseArrayLayer: 0, arrayLayerCount: 1});
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout0]});
let commandEncoder5 = device0.createCommandEncoder({});
let texture9 = device0.createTexture({
  size: [290, 24, 2],
  dimension: '2d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture10 = device0.createTexture({
  size: {width: 26, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture11 = device0.createTexture({
  size: {width: 1160, height: 96, depthOrArrayLayers: 2},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let computePassEncoder4 = commandEncoder5.beginComputePass({});
let sampler3 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 47.02,
  lodMaxClamp: 79.81,
  compare: 'always',
});
try {
commandEncoder2.copyBufferToTexture({
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 920 */
  offset: 920,
  bytesPerRow: 1280,
  buffer: buffer1,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470m', transfer: 'iec6196624'} });
let commandEncoder6 = device0.createCommandEncoder({label: '\uc160\ufaf2\u13de\u{1ff43}\uafee\uac9b\u0493\u005f\u1291\udb6e'});
let texture12 = device0.createTexture({
  size: [145, 12, 2],
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture13 = device0.createTexture({
  size: [145, 12, 2],
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView3 = texture6.createView({format: 'r16float', mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder5 = commandEncoder6.beginComputePass({label: '\u03f3\uaf8d\u59f6\u4370'});
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

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

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

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

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

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

struct T0 {
  f0: vec2u,
}

struct VertexOutput0 {
  @location(10) f0: vec2i,
  @location(15) f1: vec2f,
  @location(2) @interpolate(flat, sample) f2: u32,
  @invariant @builtin(position) f3: vec4f,
  @location(12) @interpolate(flat, sample) f4: vec4i,
  @location(9) @interpolate(flat, center) f5: vec2f,
}

fn fn0() -> VertexOutput0 {
  var out: VertexOutput0;
  var vf0: vec4h = log2(vec4h(unconst_f16(-2186.7), unconst_f16(9281.7), unconst_f16(6400.4), unconst_f16(16067.3)));
  let vf1: vec2h = fma(vec2h(unconst_f16(137.0), unconst_f16(-21576.4)), vec2h(unconst_f16(31176.9), unconst_f16(12062.7)), vec2h(unconst_f16(22478.0), unconst_f16(10550.5)));
  out.f1 = vp1.whole;
  let ptr0: ptr<function, vec4h> = &vf0;
  var vf2: u32 = pack4x8unorm(vec4f(unconst_f32(0.07512), unconst_f32(0.04710), unconst_f32(0.4925), unconst_f32(0.03693)));
  let vf3: vec3f = cross(vec3f(unconst_f32(0.06031), unconst_f32(0.2901), unconst_f32(0.04369)), vec3f(unconst_f32(0.05827), unconst_f32(0.3039), unconst_f32(0.1604)));
  out.f5 += atan2(vec3f(sign(f32(unconst_f32(-0.2910)))), vec3f(unconst_f32(0.04126), unconst_f32(0.1493), unconst_f32(0.2106))).yy;
  let vf4: vec3h = degrees(vec3h(unconst_f16(33295.8), unconst_f16(638.9), unconst_f16(1435.5)));
  let vf5: f16 = vf0[u32(unconst_u32(51))];
  var vf6: vec2h = vf1;
  out.f2 = u32(vf3[u32(unconst_u32(85))]);
  let vf7: f32 = pow(f32(unconst_f32(0.00232)), f32(unconst_f32(0.03360)));
  out.f1 += bitcast<vec2f>(firstTrailingBit(vec3u(vf4)).yy);
  out.f0 = bitcast<vec2i>(cross(vec3f(unconst_f32(0.06344), unconst_f32(0.07219), unconst_f32(0.2011)), vec3f(unconst_f32(0.02086), unconst_f32(0.4623), unconst_f32(0.05555))).yx);
  var vf8: f32 = sign(f32(unconst_f32(0.07190)));
  var vf9: f16 = vf1[u32(unconst_u32(144))];
  out.f5 *= cross(vec3f(unconst_f32(0.03426), unconst_f32(0.01506), unconst_f32(0.1046)), vec3f(unconst_f32(0.5056), unconst_f32(0.04982), unconst_f32(0.04307))).zx;
  return out;
}

fn fn1() -> vec4h {
  var out: vec4h;
  vp0 = f16(sinh(vec2f(unconst_f32(0.08741), unconst_f32(-0.1765))).g);
  var vf10: vec4f = cosh(vec4f(unconst_f32(0.1546), unconst_f32(0.2058), unconst_f32(0.3277), unconst_f32(-0.04907)));
  let ptr1: ptr<private, vec2f> = &vp1.whole;
  let ptr2: ptr<private, vec2f> = &vp1.whole;
  vf10 = bitcast<vec4f>(firstTrailingBit(firstTrailingBit(vec3u(unconst_u32(51), unconst_u32(79), unconst_u32(67)))).xzyx);
  vp0 = f16(tan(vp1.fract.rgrg)[1]);
  var vf11: vec4f = tan(vec4f(unconst_f32(0.02300), unconst_f32(0.1625), unconst_f32(0.03714), unconst_f32(-0.02429)));
  let ptr3: ptr<private, vec2f> = &vp1.whole;
  vp0 = max(vec2h(unconst_f16(-6376.7), unconst_f16(1570.0)), vec2h(unconst_f16(15512.4), unconst_f16(6444.8)))[0];
  var vf12: vec3u = firstTrailingBit(vec3u(unconst_u32(315), unconst_u32(63), unconst_u32(252)));
  var vf13: vec2f = sinh(vec2f(unconst_f32(0.04917), unconst_f32(0.07084)));
  let ptr4: ptr<private, vec2f> = &vp1.whole;
  vp0 = vec2h(vf13).r;
  var vf14: f32 = vf11[u32(vf10[u32(unconst_u32(170))])];
  let ptr5: ptr<function, vec4f> = &vf11;
  return out;
}

var<workgroup> vw0: atomic<i32>;

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

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

var<private> vp0: f16 = f16(6613.9);

var<private> vp1 = modf(vec2f(0.4011, 0.1369));

@vertex
fn vertex0(@location(5) a0: u32, @location(14) @interpolate(flat, sample) a1: vec2u, @location(3) @interpolate(perspective) a2: f32, @location(10) a3: i32, @builtin(vertex_index) a4: u32, @location(15) @interpolate(linear, centroid) a5: vec2f, @location(11) a6: vec4h, @builtin(instance_index) a7: u32) -> VertexOutput0 {
  var out: VertexOutput0;
  fn1();
  out.f3 = vec4f(bitcast<f32>(dot4I8Packed(u32(unconst_u32(131)), u32(unconst_u32(10)))));
  var vf15 = fn1();
  out.f0 = vec2i(vp1.whole);
  out.f1 -= vec2f(refract(vec3h(unconst_f16(1250.0), unconst_f16(9774.8), unconst_f16(-1882.0)), vec3h(unconst_f16(-7683.5), unconst_f16(8724.8), unconst_f16(16148.9)), f16(unconst_f16(2742.5))).rr);
  var vf16 = fn1();
  var vf17 = fn1();
  var vf18: u32 = pack2x16snorm(vec2f(unconst_f32(0.06060), unconst_f32(0.07180)));
  out.f5 = vec2f(length(vec4f(unconst_f32(0.2842), unconst_f32(0.2729), unconst_f32(0.5564), unconst_f32(0.08032))));
  out.f5 = unpack2x16float(pack4xU8Clamp(vec4u(unconst_u32(137), unconst_u32(17), unconst_u32(213), unconst_u32(4))));
  fn1();
  let vf19: vec2h = min(vec2h(unconst_f16(8093.7), unconst_f16(467.9)), vec2h(unconst_f16(1338.6), unconst_f16(11939.7)));
  out.f4 = bitcast<vec4i>(unpack2x16snorm(u32(unconst_u32(1000))).xxyy);
  return out;
}

@compute @workgroup_size(2, 1, 2)
fn compute0() {
  let vf20: vec3f = smoothstep(vec3f(unconst_f32(0.02231), unconst_f32(0.01351), unconst_f32(0.5636)), vec3f(unconst_f32(0.01832), unconst_f32(0.5372), unconst_f32(-0.07158)), vec3f(unconst_f32(0.05453), unconst_f32(-0.6449), unconst_f32(0.04939)));
  var vf21 = fn0();
  fn0();
  var vf22: i32 = atomicExchange(&vw0, i32(unconst_i32(70)));
  var vf23 = fn1();
  var vf24 = fn1();
  let ptr6: ptr<workgroup, vec2u> = &(*&vw1)[u32(unconst_u32(203))][u32(unconst_u32(100))].f0;
  let vf25: vec3f = vf20;
  fn1();
  atomicCompareExchangeWeak(&vw2[u32(unconst_u32(234))], unconst_i32(64), unconst_i32(533));
  vf22 -= bitcast<vec2i>((*&vw1)[0][0].f0).g;
  let ptr7: ptr<workgroup, atomic<i32>> = &vw2[u32(unconst_u32(394))];
  vf22 = atomicExchange(&vw2[u32(unconst_u32(54))], i32(all(vec3<bool>(refract(vec3f(unconst_f32(0.03286), unconst_f32(0.4242), unconst_f32(0.01894)), vec3f(unconst_f32(0.05502), unconst_f32(0.09351), unconst_f32(0.2231)), f32(unconst_f32(0.4912)))))));
}

@compute @workgroup_size(1, 1, 1)
fn compute1() {
  var vf26 = fn0();
  var vf27 = fn0();
  var vf28: f32 = log(f32(unconst_f32(0.1542)));
  let ptr8: ptr<workgroup, T0> = &vw1[0][u32(unconst_u32(445))];
  fn0();
  vf28 = vf26.f3[u32(unconst_u32(54))];
  fn1();
  let ptr9: ptr<function, vec2i> = &vf27.f0;
  var vf29 = fn1();
  fn0();
  let ptr10: ptr<function, vec2i> = &vf27.f0;
  atomicOr(&vw0, i32(unconst_i32(128)));
  let ptr11: ptr<function, u32> = &vf27.f2;
  fn1();
  vp1 = modf(vec2f(f32(atomicExchange(&(*&vw2)[0], i32(unconst_i32(66))))));
  vf27.f5 = vec2f(sqrt(vec2h(unconst_f16(1092.7), unconst_f16(830.0))));
  vf27.f1 = vf26.f3.zz;
  let ptr12: ptr<workgroup, T0> = &vw1[u32(unconst_u32(97))][u32(unconst_u32(42))];
  atomicCompareExchangeWeak(&vw0, unconst_i32(70), unconst_i32(22));
  var vf30 = fn1();
  atomicXor(&vw2[u32(unconst_u32(96))], i32(unconst_i32(138)));
  vw1[u32(unconst_u32(429))][u32(unconst_u32(150))].f0 = (*ptr12).f0;
  vf27 = VertexOutput0(firstLeadingBit(vec2i(unconst_i32(64), unconst_i32(158))), vec2f(firstLeadingBit(vec2i(unconst_i32(64), unconst_i32(158)))), u32(firstLeadingBit(vec2i(unconst_i32(64), unconst_i32(158))).g), vec4f(firstLeadingBit(vec2i(unconst_i32(64), unconst_i32(158))).rgrr), firstLeadingBit(vec2i(unconst_i32(64), unconst_i32(158))).xyyy, bitcast<vec2f>(firstLeadingBit(vec2i(unconst_i32(64), unconst_i32(158)))));
}`,
  sourceMap: {},
  hints: {},
});
let texture14 = device0.createTexture({
  size: [145, 12, 2],
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
commandEncoder2.copyBufferToBuffer(buffer1, 9772, buffer0, 172, 228);
} catch {}
try {
commandEncoder2.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 566 */
  offset: 566,
  buffer: buffer1,
}, {
  texture: texture1,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData0 = new ImageData(16, 84);
let commandEncoder7 = device0.createCommandEncoder({});
let texture15 = device0.createTexture({
  size: {width: 145, height: 12, depthOrArrayLayers: 2},
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView4 = texture15.createView({dimension: '2d', format: 'r8sint', mipLevelCount: 1});
let computePassEncoder6 = commandEncoder7.beginComputePass();
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture16 = device0.createTexture({
  size: {width: 26, height: 1, depthOrArrayLayers: 1},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture17 = device0.createTexture({
  label: '\u{1fb03}\u{1fe62}\u3a42\u013c\u0331\u{1fdb0}\ub407',
  size: [105, 1, 1],
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler4 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 42.06,
  lodMaxClamp: 67.60,
  maxAnisotropy: 1,
});
try {
commandEncoder2.copyBufferToBuffer(buffer1, 648, buffer0, 1156, 368);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 5608, new DataView(new ArrayBuffer(1407)), 380, 56);
} catch {}
let shaderModule1 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

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

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

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

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

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

@group(0) @binding(184) var tex1: texture_cube<i32>;

struct T0 {
  @align(64) @size(256) f0: mat3x2f,
  @size(64) f1: mat3x4f,
  @size(64) f2: array<array<vec4i, 1>, 1>,
  @align(64) @size(64) f3: array<array<array<vec4h, 1>, 1>, 1>,
  @align(64) @size(896) f4: mat2x3f,
}

struct T1 {
  @size(16) f0: vec2f,
  @size(232) f1: array<array<array<array<mat2x3h, 1>, 1>, 1>, 14>,
}

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

@id(38500) override override0: u32;

override override1: bool;

override override2: f16;

@id(16953) override override3: f16;

@id(44615) override override4: bool;

override override5 = 0.02879;

fn fn0() -> vec4f {
  var out: vec4f;
  out = vec4f(countOneBits(vec2i(unconst_i32(45), unconst_i32(729))).rggr);
  out = unpack2x16unorm(bitcast<u32>(atan2(vec3f(distance(vec3f(unconst_f32(0.06488), unconst_f32(0.05160), unconst_f32(0.01105)), vec3f(distance(vec3f(unconst_f32(0.02188), unconst_f32(0.04979), unconst_f32(0.06406)), vec3f(unconst_f32(0.4745), unconst_f32(0.09321), unconst_f32(0.02650)))))), vec3f(unconst_f32(0.2868), unconst_f32(0.1371), unconst_f32(0.03215))).z)).yxyy;
  let vf31: vec3h = acos(vec3h(unconst_f16(31655.9), unconst_f16(6222.7), unconst_f16(12819.9)));
  let vf32: u32 = override0;
  let vf33: vec2h = sinh(vec2h(unconst_f16(12730.3), unconst_f16(-21526.5)));
  let vf34: f16 = vf31[u32(unconst_u32(27))];
  let vf35: vec2h = sinh(vec2h(unconst_f16(10934.3), unconst_f16(13398.7)));
  let vf36: vec2h = vf35;
  out = bitcast<vec4f>(countOneBits(vec2i(unconst_i32(2), unconst_i32(32))).xyyx);
  out += vec4f(acos(vec3h(unconst_f16(591.2), unconst_f16(9387.8), unconst_f16(4597.6))).xyzy);
  var vf37: vec2h = sinh(vec2h(unconst_f16(3775.1), unconst_f16(21114.9)));
  let vf38: vec2f = reflect(vec2f(unconst_f32(0.00644), unconst_f32(0.09460)), vec2f(override5));
  return out;
  _ = override5;
  _ = override0;
}

var<workgroup> vw3: atomic<u32>;

@fragment
fn fragment0() {
}

@compute @workgroup_size(4, 3, 1)
fn compute2() {
  atomicXor(&vw3, u32(unconst_u32(58)));
  atomicMin(&vw3, u32(unconst_u32(207)));
  var vf39: f16 = dot(vec3h(unconst_f16(5139.5), unconst_f16(8882.9), unconst_f16(2049.2)), vec3h(unconst_f16(58752.4), unconst_f16(3154.7), unconst_f16(13424.0)));
  let ptr13: ptr<workgroup, atomic<u32>> = &vw3;
  let vf40: bool = all(vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true)));
  var vf41: u32 = atomicExchange(&vw3, u32(unconst_u32(288)));
  let ptr14: ptr<function, u32> = &vf41;
  atomicCompareExchangeWeak(&vw3, unconst_u32(93), unconst_u32(16));
  let vf42: vec3f = sqrt(vec3f(unconst_f32(0.3254), unconst_f32(0.2288), unconst_f32(0.2720)));
  let ptr15: ptr<workgroup, atomic<u32>> = &(*ptr13);
  let vf43: u32 = atomicExchange(&(*ptr15), u32(unconst_u32(297)));
  var vf44: bool = all(vec3<bool>(bool(override0)));
  let vf45: vec2i = countOneBits(vec2i(unconst_i32(-21), unconst_i32(256)));
  var vf46: u32 = pack4xI8Clamp(vec4i(unconst_i32(357), unconst_i32(132), unconst_i32(19), unconst_i32(416)));
  let ptr16: ptr<workgroup, atomic<u32>> = &vw3;
  let vf47: mat4x2h = transpose(mat2x4h(unconst_f16(30081.6), unconst_f16(18162.3), unconst_f16(4231.6), unconst_f16(1693.6), unconst_f16(7384.7), unconst_f16(9350.5), unconst_f16(3667.9), unconst_f16(4240.4)));
  var vf48: vec4f = refract(vec4f(unconst_f32(0.03973), unconst_f32(-0.02314), unconst_f32(0.4946), unconst_f32(0.2059)), vec4f(unconst_f32(0.5490), unconst_f32(1.000), unconst_f32(0.2656), unconst_f32(0.03953)), f32(unconst_f32(0.01057)));
  _ = override0;
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup0 = device0.createBindGroup({
  label: '\u4812\u0c94\u05d3\uf074\u{1f93a}\u{1f63f}\u0e38',
  layout: bindGroupLayout1,
  entries: [
    {binding: 124, resource: {buffer: buffer1, offset: 16640, size: 2172}},
    {binding: 357, resource: {buffer: buffer1, offset: 3328, size: 4972}},
    {binding: 120, resource: {buffer: buffer1, offset: 5120, size: 3178}},
    {binding: 37, resource: {buffer: buffer1, offset: 2304, size: 14378}},
    {binding: 39, resource: textureView1},
  ],
});
let texture18 = device0.createTexture({
  size: {width: 580, height: 48, depthOrArrayLayers: 2},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder7 = commandEncoder2.beginComputePass({});
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(300).fill(122), /* required buffer size: 300 */
{offset: 300}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 14, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline0 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, entryPoint: 'compute0'}});
let buffer2 = device0.createBuffer({
  size: 15417,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture19 = device0.createTexture({
  size: [290, 24, 2],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture20 = device0.createTexture({
  size: [26, 1, 91],
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView5 = texture18.createView({arrayLayerCount: 1});
let sampler5 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 55.69,
  lodMaxClamp: 96.97,
});
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(337).fill(138), /* required buffer size: 337 */
{offset: 29, bytesPerRow: 22, rowsPerImage: 14}, {width: 0, height: 0, depthOrArrayLayers: 2});
} catch {}
let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'unspecified', transfer: 'iec61966-2-1'} });
let buffer3 = device0.createBuffer({size: 7989, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false});
let commandEncoder8 = device0.createCommandEncoder({});
let texture21 = device0.createTexture({
  size: [290, 24, 2],
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder8 = commandEncoder8.beginComputePass({});
let sampler6 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', lodMinClamp: 69.27, lodMaxClamp: 92.15});
let promise0 = device0.queue.onSubmittedWorkDone();
let imageData1 = new ImageData(32, 8);
let texture22 = device0.createTexture({
  size: [290, 24, 2],
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture0 = device0.importExternalTexture({label: '\u5e31\u5e82\u4a3b', source: videoFrame1});
try {
device0.queue.writeBuffer(buffer2, 80, new BigUint64Array(1700), 92, 492);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup1 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 357, resource: {buffer: buffer1, offset: 3584, size: 2460}},
    {binding: 37, resource: {buffer: buffer2, offset: 2048, size: 2748}},
    {binding: 120, resource: {buffer: buffer1, offset: 4864, size: 1481}},
    {binding: 39, resource: textureView1},
    {binding: 124, resource: {buffer: buffer1, offset: 3072, size: 10720}},
  ],
});
let texture23 = device0.createTexture({
  size: [290, 24, 2],
  mipLevelCount: 1,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture24 = device0.createTexture({
  size: [105, 1, 27],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
});
try {
computePassEncoder4.setPipeline(pipeline0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 1, depthOrArrayLayers: 4}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 1,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture25 = device0.createTexture({
  size: {width: 290, height: 24, depthOrArrayLayers: 2},
  format: 'rg16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture26 = device0.createTexture({
  size: {width: 290, height: 24, depthOrArrayLayers: 2},
  mipLevelCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler7 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 88.43,
  compare: 'always',
});
try {
computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(207), 28, 0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 64, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(1_890).fill(20), /* required buffer size: 1_890 */
{offset: 20, bytesPerRow: 34, rowsPerImage: 11}, {width: 14, height: 0, depthOrArrayLayers: 6});
} catch {}
let pipeline1 = device0.createRenderPipeline({
  layout: pipelineLayout0,
  vertex: {
    module: shaderModule0,
    buffers: [
      {
        arrayStride: 548,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 0, shaderLocation: 14},
          {format: 'unorm10-10-10-2', offset: 68, shaderLocation: 3},
          {format: 'sint32x2', offset: 12, shaderLocation: 10},
          {format: 'snorm8x4', offset: 68, shaderLocation: 15},
          {format: 'snorm8x2', offset: 70, shaderLocation: 11},
          {format: 'uint16x2', offset: 88, shaderLocation: 5},
        ],
      },
    ],
  },
});
let texture27 = device0.createTexture({
  label: '\u0072\u0956\u{1f9f6}\u{1fdec}\u0515\ue177\u0a3f\u{1f8c3}\u{1f9b9}\u1bbc\u1645',
  size: {width: 1160, height: 96, depthOrArrayLayers: 2},
  mipLevelCount: 2,
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
device0.queue.submit([]);
} catch {}
let commandEncoder9 = device0.createCommandEncoder({});
let texture28 = device0.createTexture({
  size: [26, 1, 25],
  mipLevelCount: 2,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler8 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'nearest',
  lodMinClamp: 56.11,
  lodMaxClamp: 77.57,
});
try {
computePassEncoder5.setBindGroup(1, bindGroup1, new Uint32Array(4270), 530, 0);
} catch {}
try {
commandEncoder9.copyTextureToTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 0,
  origin: {x: 9, y: 2, z: 0},
  aspect: 'all',
},
{width: 9, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
await gc();
let texture29 = device0.createTexture({
  label: '\uce14\u{1f7ef}',
  size: {width: 52, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView6 = texture17.createView({dimension: '2d-array', format: 'r16float'});
try {
computePassEncoder8.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder5.setBindGroup(0, bindGroup1, new Uint32Array(4462), 47, 0);
} catch {}
let texture30 = device0.createTexture({
  label: '\u3fb8\u{1ffb2}\u81d1\ua0a3',
  size: {width: 26, height: 1, depthOrArrayLayers: 11},
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture31 = device0.createTexture({
  label: '\u{1fa35}\u0547\u6f66\uf5e7\u{1fbe7}\uf135\u0e4b\u9e30\ub632\u{1fb1f}',
  size: [580, 48, 3],
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler9 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 52.97,
  lodMaxClamp: 65.07,
  maxAnisotropy: 10,
});
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
commandEncoder9.copyTextureToBuffer({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 968 */
  offset: 968,
  buffer: buffer0,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline2 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule1, constants: {38_500: 0}}});
let buffer4 = device0.createBuffer({
  label: '\u{1fef9}\u0d5c\u0edc\u5843\u{1ffa3}\u{1fbff}',
  size: 4579,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture32 = device0.createTexture({
  size: [52, 1, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder9 = commandEncoder9.beginComputePass({});
let sampler10 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 9.978,
  lodMaxClamp: 38.25,
  maxAnisotropy: 10,
});
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
let commandEncoder10 = device0.createCommandEncoder({label: '\u{1f840}\u04ec'});
let texture33 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 18},
  dimension: '2d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder10 = commandEncoder10.beginComputePass();
let sampler11 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 90.25,
  maxAnisotropy: 10,
});
try {
computePassEncoder6.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
let commandEncoder11 = device0.createCommandEncoder({});
let textureView7 = texture33.createView({dimension: 'cube'});
let computePassEncoder11 = commandEncoder11.beginComputePass({label: '\u4a3f\uf859\u5066\ud98f\u{1fea0}\ub1ae\u392b\u58eb\u{1fe28}\ufd4c'});
let sampler12 = device0.createSampler({
  label: '\u0564\ua023\u{1f66e}\u6e40',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 31.61,
  lodMaxClamp: 76.93,
  maxAnisotropy: 3,
});
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 7936, new DataView(new ArrayBuffer(25937)), 9884, 3636);
} catch {}
let imageData2 = new ImageData(32, 160);
let commandEncoder12 = device0.createCommandEncoder({});
let texture34 = device0.createTexture({
  size: [210],
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder12 = commandEncoder12.beginComputePass();
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let img0 = await imageWithData(30, 48, '#10101010', '#20202020');
let buffer5 = device0.createBuffer({
  size: 366,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder13 = device0.createCommandEncoder({});
let computePassEncoder13 = commandEncoder13.beginComputePass({});
let sampler13 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  lodMinClamp: 23.88,
  lodMaxClamp: 46.96,
  compare: 'never',
});
let imageData3 = new ImageData(112, 44);
let shaderModule2 = device0.createShaderModule({
  code: `
enable f16;

enable f16;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(184) var tex2: texture_cube<i32>;

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

fn fn0() -> vec2u {
  var out: vec2u;
  out <<= bitcast<vec2u>(max(vec3f(unconst_f32(0.2090), unconst_f32(0.2073), unconst_f32(0.1332)), vec3f(unconst_f32(0.04434), unconst_f32(0.8883), unconst_f32(0.06786))).gr);
  var vf49: bool = any(bool(unconst_bool(true)));
  out ^= bitcast<vec2u>(trunc(max(vec3f(unconst_f32(0.04178), unconst_f32(0.2555), unconst_f32(0.1246)), trunc(vec4f(unconst_f32(0.5075), unconst_f32(-0.09441), unconst_f32(0.2455), unconst_f32(0.1794))).bab).grbr).gr);
  var vf50: bool = all(bool(unconst_bool(false)));
  vp2 = bool(pow(vec2h(unconst_f16(724.1), unconst_f16(4258.9)), vec2h(unconst_f16(21184.4), unconst_f16(1991.7)))[0]);
  let vf51: u32 = pack4xU8(vec4u(unconst_u32(30), unconst_u32(79), unconst_u32(332), unconst_u32(47)));
  vf49 = bool(pack4xU8(countOneBits(vec4u(unconst_u32(78), unconst_u32(7), unconst_u32(7), unconst_u32(190)))));
  vp2 = bool(mix(vec3h(unconst_f16(6019.5), unconst_f16(13707.4), unconst_f16(1514.5)), vec3h(unconst_f16(4206.8), unconst_f16(8864.0), unconst_f16(10374.3)), f16(unconst_f16(19257.3))).x);
  vf50 = vf50;
  return out;
}

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

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

var<private> vp3: mat2x2f = mat2x2f(0.1734, 0.2854, 0.3139, 0.02152);

@fragment
fn fragment1() -> @location(200) f32 {
  var out: f32;
  vp2 = bool(vp3[unconst_i32(0)][1]);
  out -= unpack4x8snorm(u32(unconst_u32(29))).z;
  vp3 += mat2x2f(vec2f(ceil(vec3h(unconst_f16(8873.1), unconst_f16(28004.4), unconst_f16(15223.2))).yx), vec2f(ceil(vec3h(unconst_f16(8873.1), unconst_f16(28004.4), unconst_f16(15223.2))).yx));
  out = vp3[u32(unconst_u32(692))][u32(unconst_u32(117))];
  let vf52: vec2i = firstLeadingBit(vec2i(unconst_i32(136), unconst_i32(17)));
  var vf53 = fn0();
  var vf54 = fn0();
  out = bitcast<f32>(extractBits(i32(unconst_i32(44)), u32(unconst_u32(36)), u32(unconst_u32(473))));
  let vf55: vec4f = log2(vec4f(unconst_f32(0.2490), unconst_f32(0.02217), unconst_f32(0.2427), unconst_f32(0.3200)));
  var vf56 = fn0();
  var vf57 = fn0();
  var vf58 = fn0();
  fn0();
  var vf59 = fn0();
  vf56 <<= textureDimensions(tex2, vec2i(textureDimensions(tex2, i32(unconst_i32(36)))).r);
  fn0();
  vf59 -= vf57;
  return out;
}

@compute @workgroup_size(1, 1, 2)
fn compute3() {
  let ptr17: ptr<workgroup, array<mat2x2f, 1>> = &(*&vw4);
  let vf60: vec2u = countLeadingZeros(vec2u(unconst_u32(53), unconst_u32(33)));
  vp3 += vw4[u32(unconst_u32(166))];
  let vf61: f32 = (*ptr17)[u32(unconst_u32(191))][u32(unconst_u32(484))][u32(unconst_u32(94))];
  var vf62: vec2f = vw4[u32(unconst_u32(171))][u32(unconst_u32(417))];
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup2 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView7}]});
let texture35 = device0.createTexture({
  size: {width: 580, height: 48, depthOrArrayLayers: 61},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder13.setPipeline(pipeline2);
} catch {}
document.body.prepend(img0);
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte432', transfer: 'gamma28curve'} });
let bindGroup3 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView0}]});
let commandEncoder14 = device0.createCommandEncoder({});
try {
computePassEncoder0.setBindGroup(3, bindGroup3);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline2);
} catch {}
try {
buffer5.unmap();
} catch {}
await gc();
try {
sampler2.label = '\u{1f878}\u4ee3\udeab\ub1fc\u0486\ucca0\ue5e1\u{1f8f2}\u{1fb2c}';
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
enable f16;

enable f16;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(184) var tex3: texture_cube<i32>;

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

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

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

struct VertexOutput1 {
  @invariant @builtin(position) f6: vec4f,
  @location(4) @interpolate(flat) f7: vec4i,
  @location(13) f8: vec2f,
  @location(5) f9: vec2h,
  @location(15) @interpolate(perspective) f10: vec2f,
  @location(11) f11: i32,
  @location(14) f12: vec4u,
  @location(12) f13: vec4f,
}

struct FragmentOutput0 {
  @location(0) f0: vec2f,
  @location(7) f1: u32,
}

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

var<private> vp4: array<bool, 2> = array(bool(false), bool(true));

@vertex @must_use
fn vertex1() -> VertexOutput1 {
  var out: VertexOutput1;
  out.f13 = vec4f(determinant(mat3x3f()));
  let vf63: vec3h = cosh(vec3h(unconst_f16(3615.8), unconst_f16(5435.1), unconst_f16(14719.6)));
  let ptr18: ptr<private, bool> = &vp4[1];
  out.f11 &= i32(vp4[u32(unconst_u32(80))]);
  var vf64: vec3h = vf63;
  let ptr19: ptr<private, bool> = &vp4[u32(unconst_u32(21))];
  var vf65: f16 = pow(f16(unconst_f16(15414.1)), f16(unconst_f16(1995.1)));
  vp4[u32(unconst_u32(8))] = bool(tan(vec4h(unconst_f16(18758.3), unconst_f16(22667.5), unconst_f16(-8262.1), unconst_f16(1767.5)))[3]);
  let vf66: f32 = determinant(mat3x3f());
  out.f11 = i32(vf65);
  let ptr20: ptr<private, bool> = &vp4[1];
  return out;
}

@fragment
fn fragment2() -> FragmentOutput0 {
  var out: FragmentOutput0;
  let ptr21: ptr<private, bool> = &vp4[1];
  out.f1 |= textureDimensions(tex3, i32(unconst_i32(297))).y;
  let vf67: u32 = textureNumLevels(tex3);
  let vf68: vec4u = unpack4xU8(u32(unconst_u32(240)));
  let vf69: vec4i = insertBits(vec4i(unconst_i32(312), unconst_i32(140), unconst_i32(639), unconst_i32(314)), vec4i(ceil(vec3h(f16(pack4xU8(vec4u(unconst_u32(273), unconst_u32(223), unconst_u32(26), unconst_u32(71)))))).gbbr), u32(unconst_u32(458)), u32(unconst_u32(163)));
  var vf70: u32 = pack4xU8(vec4u(unconst_u32(176), unconst_u32(308), unconst_u32(60), unconst_u32(76)));
  out = FragmentOutput0(vec2f(bitcast<f32>(firstLeadingBit(u32(unconst_u32(66))))), firstLeadingBit(u32(unconst_u32(66))));
  var vf71: vec3h = atan(vec3h(unconst_f16(6032.7), unconst_f16(6005.3), unconst_f16(14561.1)));
  vf70 >>= firstLeadingBit(u32(vp4[1]));
  return out;
}

@fragment
fn fragment3(@location(2) a0: u32, @location(10) a1: vec2i) -> FragmentOutput1 {
  var out: FragmentOutput1;
  let vf72: vec2f = sin(vec2f(unconst_f32(0.07889), unconst_f32(0.07382)));
  let vf73: vec2i = a1;
  let vf74: vec2u = textureDimensions(tex3);
  out.f1 &= bitcast<vec4i>(transpose(mat4x4f(atan2(vec2f(ceil(vec3h(unconst_f16(4794.9), unconst_f16(4718.5), unconst_f16(19727.0))).xy), vec2f(unconst_f32(0.09944), unconst_f32(0.2975))).yyxx, atan2(vec2f(ceil(vec3h(unconst_f16(4794.9), unconst_f16(4718.5), unconst_f16(19727.0))).xy), vec2f(unconst_f32(0.09944), unconst_f32(0.2975))).xyxy, atan2(vec2f(ceil(vec3h(unconst_f16(4794.9), unconst_f16(4718.5), unconst_f16(19727.0))).xy), vec2f(unconst_f32(0.09944), unconst_f32(0.2975))).xyyy, atan2(vec2f(ceil(vec3h(unconst_f16(4794.9), unconst_f16(4718.5), unconst_f16(19727.0))).xy), vec2f(unconst_f32(0.09944), unconst_f32(0.2975))).xyyx))[unconst_i32(2)]);
  let vf75: vec2f = radians(vec2f(unconst_f32(0.2745), unconst_f32(0.07021)));
  var vf76: f32 = vf72[u32(unconst_u32(7))];
  out.f0 &= u32(vp4[1]);
  vp4[u32(unconst_u32(155))] = bool(textureDimensions(tex3, i32(unconst_i32(191)))[1]);
  var vf77: vec2f = log(vec2f(unconst_f32(0.02800), unconst_f32(0.08612)));
  let ptr22: ptr<function, f32> = &vf76;
  let vf78: vec3h = ceil(vec3h(unconst_f16(308.2), unconst_f16(15276.1), unconst_f16(9641.7)));
  vf77 = vec2f(f32(vp4[1]));
  let vf79: vec2f = reflect(vec2f(unconst_f32(0.3577), unconst_f32(-0.1199)), vec2f(f32(vf78[u32(unconst_u32(213))])));
  var vf80: vec2i = a1;
  vp4[1] = bool(vf72.y);
  vf76 = f32(ceil(vec3h(unconst_f16(-5973.5), unconst_f16(13526.8), unconst_f16(6250.7)))[2]);
  out.f1 |= vec4i(i32(vf78[u32(unconst_u32(19))]));
  let vf81: u32 = textureNumLevels(tex3);
  out.f0 &= vec2u(log(vec2f(unconst_f32(0.2225), unconst_f32(0.04342))))[1];
  var vf82: vec2f = max(vec2f(unconst_f32(0.03918), unconst_f32(0.01456)), vec2f(unconst_f32(0.3100), unconst_f32(0.5375)));
  out.f1 -= bitcast<vec4i>(radians(vec3f(unconst_f32(-0.09835), unconst_f32(-0.1811), unconst_f32(0.5718))).rrrb);
  let vf83: vec2f = radians(vec2f(unconst_f32(0.2359), unconst_f32(0.05306)));
  vf82 = log(vec2f(unconst_f32(0.02902), unconst_f32(0.3336)));
  out.f0 ^= pack4x8unorm(transpose(mat4x4f(radians(vf75).yyxy, radians(vf75).rrgg, radians(vf75).xxyy, radians(vf75).rgrg))[unconst_i32(3)]);
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute4() {
  vp4[bitcast<u32>(quantizeToF16(vec4f(unconst_f32(0.1573), unconst_f32(0.00596), unconst_f32(0.1203), unconst_f32(0.4501)))[3])] = bool(exp2(vec3f(f32(pack4xI8Clamp(vec4i(unconst_i32(407), unconst_i32(155), unconst_i32(95), unconst_i32(759))))))[0]);
  vp4[u32(unconst_u32(76))] = bool(pack4xI8Clamp(vec4i(unconst_i32(222), unconst_i32(29), unconst_i32(193), unconst_i32(18))));
  vp4[u32(unconst_u32(35))] = bool(distance(vec2f(unconst_f32(0.3975), unconst_f32(0.2699)), vec2f(unconst_f32(0.04956), unconst_f32(0.03664))));
  var vf84: u32 = pack4x8snorm(vec4f(unconst_f32(0.04985), unconst_f32(0.3409), unconst_f32(0.1180), unconst_f32(0.1373)));
  vp4[u32(unconst_u32(303))] = bool(atanh(vec3f(unconst_f32(0.6474), unconst_f32(0.3251), unconst_f32(0.1105)))[1]);
}`,
  sourceMap: {},
});
let buffer6 = device0.createBuffer({size: 16307, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
let computePassEncoder14 = commandEncoder14.beginComputePass();
try {
computePassEncoder11.end();
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
  await promise0;
} catch {}
let bindGroup4 = device0.createBindGroup({
  label: '\u7713\ufc39\u071e',
  layout: bindGroupLayout1,
  entries: [
    {binding: 39, resource: textureView1},
    {binding: 37, resource: {buffer: buffer2, offset: 1536, size: 234}},
    {binding: 124, resource: {buffer: buffer1, offset: 4608, size: 5452}},
    {binding: 120, resource: {buffer: buffer1, offset: 2816, size: 404}},
    {binding: 357, resource: {buffer: buffer1, offset: 7168, size: 3164}},
  ],
});
let commandEncoder15 = device0.createCommandEncoder();
let texture36 = device0.createTexture({
  label: '\u795d\u5999',
  size: {width: 580},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView8 = texture16.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
commandEncoder11.copyBufferToBuffer(buffer2, 1476, buffer5, 0, 12);
} catch {}
let commandEncoder16 = device0.createCommandEncoder({});
let textureView9 = texture1.createView({format: 'r16sint', mipLevelCount: 1, baseArrayLayer: 0});
try {
computePassEncoder14.setPipeline(pipeline2);
} catch {}
try {
commandEncoder11.copyTextureToTexture({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 11, y: 4, z: 0},
  aspect: 'all',
},
{
  texture: texture29,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: imageData2,
  origin: { x: 4, y: 16 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 26, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData4 = new ImageData(4, 48);
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

@group(0) @binding(184) var tex4: texture_cube<i32>;

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

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

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

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

struct FragmentOutput2 {
  @location(0) f0: f32,
  @location(4) f1: vec2f,
}

alias vec3b = vec3<bool>;

fn fn0(a0: VertexOutput2) -> array<array<array<i32, 1>, 31>, 1> {
  var out: array<array<array<i32, 1>, 31>, 1>;
  vp5[u32(unconst_u32(264))] = modf(vp5[0].whole);
  out[u32(unconst_u32(20))][u32(any(vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true))))][u32(unconst_u32(10))] -= i32(vp5[0].whole);
  let ptr23 = &vp5[u32(unconst_u32(41))];
  let ptr24 = &vp5;
  out[u32(unconst_u32(449))][u32(unconst_u32(68))][u32(unconst_u32(46))] += i32(a0.f14[u32(unconst_u32(167))]);
  var vf85: vec3h = cos(vec3h(unconst_f16(-5554.4), unconst_f16(5508.6), unconst_f16(2012.5)));
  vp5[u32(unconst_u32(43))].whole = vp5[0].fract;
  var vf86: bool = any(vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false)));
  let vf87: vec2f = unpack2x16unorm(u32(vp5[u32(unconst_u32(45))].fract));
  let ptr25: ptr<function, vec3h> = &vf85;
  let vf88: vec3h = exp(vec3h(unconst_f16(16021.6), unconst_f16(16288.5), unconst_f16(9927.3)));
  var vf89: f16 = vf88[u32(unconst_u32(557))];
  vp5[u32(unconst_u32(412))].whole = f16(unpack2x16unorm(u32(unconst_u32(337)))[1]);
  let ptr26 = &(*ptr24)[0];
  var vf90: f32 = determinant(mat3x3f());
  let ptr27 = &(*ptr26);
  let ptr28 = &(*ptr24)[u32(a0.f14[1])];
  let ptr29: ptr<private, f16> = &vp5[u32(unconst_u32(134))].fract;
  vf85 = vec3h(vp5[u32(unconst_u32(232))].fract);
  let ptr30: ptr<private, f16> = &(*ptr24)[0].fract;
  vf89 -= (*ptr24)[0].whole;
  vf90 = unpack2x16unorm(u32(unconst_u32(26)))[0];
  return out;
}

fn fn1() -> FragmentOutput2 {
  var out: FragmentOutput2;
  vw6 = mat2x3f(f32(atomicLoad(&(*&vw5))), bitcast<f32>(atomicLoad(&(*&vw5))), f32(atomicLoad(&(*&vw5))), f32(atomicLoad(&(*&vw5))), f32(atomicLoad(&(*&vw5))), f32(atomicLoad(&(*&vw5))));
  fn0(VertexOutput2(unpack4x8snorm(atomicLoad(&(*&vw7).f0[0]))));
  let ptr31: ptr<workgroup, atomic<u32>> = &vw7.f0[0];
  vw6 = mat2x3f(f32(atomicLoad(&vw8[60].f0[0])), bitcast<f32>(atomicLoad(&vw8[60].f0[0])), bitcast<f32>(atomicLoad(&vw8[60].f0[0])), f32(atomicLoad(&vw8[60].f0[0])), f32(atomicLoad(&vw8[60].f0[0])), bitcast<f32>(atomicLoad(&vw8[60].f0[0])));
  storageBarrier();
  vw6 = mat2x3f(f32(atomicExchange(&(*&vw8)[60].f0[0], u32(unconst_u32(266)))), f32(atomicExchange(&(*&vw8)[60].f0[0], u32(unconst_u32(266)))), bitcast<f32>(atomicExchange(&(*&vw8)[60].f0[0], u32(unconst_u32(266)))), bitcast<f32>(atomicExchange(&(*&vw8)[60].f0[0], u32(unconst_u32(266)))), bitcast<f32>(atomicExchange(&(*&vw8)[60].f0[0], u32(unconst_u32(266)))), f32(atomicExchange(&(*&vw8)[60].f0[0], u32(unconst_u32(266)))));
  vw6 = mat2x3f(f32(atomicLoad(&vw8[atomicExchange(&(*&vw8)[60].f0[atomicExchange(&(*&vw8)[60].f0[atomicLoad(&(*&vw7).f0[u32(unconst_u32(1))])], u32(unconst_u32(56)))], u32(unconst_u32(88)))].f0[u32(unconst_u32(327))])), f32(atomicLoad(&vw8[atomicExchange(&(*&vw8)[60].f0[atomicExchange(&(*&vw8)[60].f0[atomicLoad(&(*&vw7).f0[u32(unconst_u32(1))])], u32(unconst_u32(56)))], u32(unconst_u32(88)))].f0[u32(unconst_u32(327))])), f32(atomicLoad(&vw8[atomicExchange(&(*&vw8)[60].f0[atomicExchange(&(*&vw8)[60].f0[atomicLoad(&(*&vw7).f0[u32(unconst_u32(1))])], u32(unconst_u32(56)))], u32(unconst_u32(88)))].f0[u32(unconst_u32(327))])), bitcast<f32>(atomicLoad(&vw8[atomicExchange(&(*&vw8)[60].f0[atomicExchange(&(*&vw8)[60].f0[atomicLoad(&(*&vw7).f0[u32(unconst_u32(1))])], u32(unconst_u32(56)))], u32(unconst_u32(88)))].f0[u32(unconst_u32(327))])), bitcast<f32>(atomicLoad(&vw8[atomicExchange(&(*&vw8)[60].f0[atomicExchange(&(*&vw8)[60].f0[atomicLoad(&(*&vw7).f0[u32(unconst_u32(1))])], u32(unconst_u32(56)))], u32(unconst_u32(88)))].f0[u32(unconst_u32(327))])), bitcast<f32>(atomicLoad(&vw8[atomicExchange(&(*&vw8)[60].f0[atomicExchange(&(*&vw8)[60].f0[atomicLoad(&(*&vw7).f0[u32(unconst_u32(1))])], u32(unconst_u32(56)))], u32(unconst_u32(88)))].f0[u32(unconst_u32(327))])));
  var vf91 = fn0(VertexOutput2(vw6[unconst_i32(0)].yyyy));
  out.f0 += bitcast<f32>(atomicLoad(&(*&vw8)[atomicLoad(&(*&vw7).f0[u32(unconst_u32(167))])].f0[u32(unconst_u32(353))]));
  var vf92: u32 = atomicExchange(&(*&vw8)[60].f0[u32(unconst_u32(510))], atomicExchange(&vw8[60].f0[0], u32(unconst_u32(166))));
  fn0(VertexOutput2(vec4f(bitcast<f32>(vf91[0][u32(unconst_u32(183))][0]))));
  let ptr32: ptr<workgroup, atomic<u32>> = &(*&vw7).f0[atomicExchange(&(*&vw7).f0[0], u32(unconst_u32(48)))];
  vf91[u32(unconst_u32(193))][u32(unconst_u32(66))][u32(unconst_u32(767))] &= bitcast<i32>(atomicLoad(&(*&vw8)[60].f0[0]));
  var vf93 = fn0(VertexOutput2(vec4f(f32(atomicExchange(&(*&vw5), u32(unconst_u32(75)))))));
  fn0(VertexOutput2(vec4f(bitcast<f32>(vf93[u32(unconst_u32(27))][u32(unconst_u32(22))][u32(unconst_u32(181))]))));
  var vf94: u32 = atomicLoad(&(*&vw8)[u32(unconst_u32(107))].f0[0]);
  atomicMax(&vw8[u32(unconst_u32(212))].f0[u32(unconst_u32(217))], u32(unconst_u32(840)));
  return out;
}

var<workgroup> vw5: atomic<u32>;

var<workgroup> vw6: mat2x3f;

var<workgroup> vw7: T0;

var<workgroup> vw8: array<T0, 61>;

var<private> vp5 = array(modf(f16(-724.2)));

@vertex
fn vertex2() -> VertexOutput2 {
  var out: VertexOutput2;
  vp5[u32(unconst_u32(13))] = vp5[u32(unconst_u32(58))];
  let ptr33 = &vp5;
  out.f14 = radians(vec3f(unconst_f32(0.02596), unconst_f32(0.2670), unconst_f32(0.2111))).bgrg;
  out = VertexOutput2(radians(vec3f(unconst_f32(0.1159), unconst_f32(0.4852), unconst_f32(0.3708))).bbbr);
  fn0(VertexOutput2(vec4f(f32(vp5[u32(unconst_u32(19))].fract))));
  var vf95 = fn0(VertexOutput2(vec4f(f32(vp5[0].whole))));
  out.f14 = vec4f(f32(vf95[u32(unconst_u32(115))][30][0]));
  var vf96 = fn0(VertexOutput2(vec4f(f32(vf95[u32(unconst_u32(34))][u32(unconst_u32(95))][0]))));
  let ptr34: ptr<function, i32> = &vf96[u32(unconst_u32(61))][30][u32(unconst_u32(423))];
  var vf97: vec3h = refract(vec3h(unconst_f16(1447.6), unconst_f16(6509.3), unconst_f16(10183.0)), vec3h(unconst_f16(6738.2), unconst_f16(16847.5), unconst_f16(25908.7)), f16(vf96[u32(unconst_u32(236))][30][0]));
  out.f14 = vec4f(f32(vf96[u32(unconst_u32(42))][u32(unconst_u32(147))][0]));
  fn0(VertexOutput2(vec4f(f32(vf96[u32(unconst_u32(249))][30][0]))));
  vf95[u32(unconst_u32(18))][30][u32(unconst_u32(136))] = vec3i(sign(vec3h(unconst_f16(9868.0), unconst_f16(-12605.9), unconst_f16(2399.3)))).g;
  fn0(VertexOutput2(vec4f(f32(vf96[u32(unconst_u32(29))][30][0]))));
  return out;
}

@fragment
fn fragment4() -> FragmentOutput2 {
  var out: FragmentOutput2;
  let vf98: vec3f = asin(unpack4x8snorm(u32(unconst_u32(67))).bga);
  var vf99 = fn0(VertexOutput2(vec4f(vf98[u32(unconst_u32(348))])));
  fn0(VertexOutput2(vec4f(unconst_f32(0.3246), unconst_f32(0.2515), unconst_f32(0.6770), unconst_f32(0.05583))));
  var vf100: vec3f = asin(vec3f(unconst_f32(0.02512), unconst_f32(0.09931), unconst_f32(-0.5445)));
  vf99[u32(unconst_u32(251))][u32(unconst_u32(1))][u32(unconst_u32(338))] |= i32(textureDimensions(tex4).y);
  let vf101: vec3h = exp(vec3h(unconst_f16(1509.4), unconst_f16(16599.3), unconst_f16(10274.9)));
  fn0(VertexOutput2(vec4f(unconst_f32(0.06538), unconst_f32(-0.3412), unconst_f32(0.2624), unconst_f32(0.4695))));
  vp5[u32(unconst_u32(19))].fract += vec3h(asin(vec3f(unconst_f32(0.03788), unconst_f32(0.2462), unconst_f32(0.1112))))[2];
  vf99[u32(unconst_u32(432))][u32(unconst_u32(22))][u32(unconst_u32(32))] *= vf99[u32(unconst_u32(92))][30][0];
  var vf102 = fn0(VertexOutput2(vec4f(f32(vp5[u32(unconst_u32(209))].fract))));
  out.f1 -= vec2f(f32(vp5[u32(unconst_u32(122))].fract));
  var vf103 = fn0(VertexOutput2(vec4f(bitcast<f32>(vf102[u32(unconst_u32(336))][u32(unconst_u32(138))][0]))));
  let ptr35: ptr<function, array<i32, 1>> = &vf103[u32(unconst_u32(26))][u32(unconst_u32(90))];
  var vf104 = fn0(VertexOutput2(vec4f(bitcast<f32>(vf99[0][30][u32(vf102[0][30][0])]))));
  vp5[u32(unconst_u32(55))] = vp5[u32(unconst_u32(694))];
  vf102[u32(unconst_u32(105))][u32(unconst_u32(156))][u32(unconst_u32(191))] ^= vf103[0][30][0];
  vf103[bitcast<u32>(vf102[0][30][0])][u32(unconst_u32(46))][u32(unconst_u32(737))] = vf102[0][30][u32(unconst_u32(249))];
  out.f1 = unpack4x8snorm(u32(unconst_u32(2))).br;
  let ptr36: ptr<function, array<i32, 1>> = &vf102[0][u32(unconst_u32(193))];
  out.f0 -= bitcast<f32>(vf103[0][30][u32(unconst_u32(57))]);
  vf100 = vec3f(bitcast<f32>((*ptr36)[0]));
  fn0(VertexOutput2(vec4f(bitcast<f32>(vf103[u32(unconst_u32(97))][u32(unconst_u32(64))][0]))));
  fn0(VertexOutput2(vec4f(f32(vf99[0][30][0]))));
  out.f1 += vec2f(bitcast<f32>((*ptr36)[0]));
  var vf105 = fn0(VertexOutput2(vec4f(f32(vf102[0][30][0]))));
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute5() {
  let vf106: u32 = atomicExchange(&vw7.f0[0], u32(unconst_u32(171)));
  fn0(VertexOutput2(vec4f(unconst_f32(0.1809), unconst_f32(0.1721), unconst_f32(-0.06839), unconst_f32(0.7222))));
  atomicMax(&vw5, u32(unconst_u32(287)));
  var vf107 = fn1();
  let vf108: vec3f = (*&vw6)[u32(unconst_u32(53))];
  var vf109 = fn1();
}`,
  sourceMap: {},
  hints: {},
});
let buffer7 = device0.createBuffer({size: 2495, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandBuffer0 = commandEncoder16.finish();
let computePassEncoder15 = commandEncoder11.beginComputePass({});
let bindGroup5 = device0.createBindGroup({
  label: '\u397f\u06bf\ubdf8',
  layout: bindGroupLayout0,
  entries: [{binding: 184, resource: textureView7}],
});
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 370});
let sampler14 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 14.93,
  lodMaxClamp: 28.18,
  maxAnisotropy: 20,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 1701});
let texture37 = device0.createTexture({
  size: [64, 64, 63],
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder15.setPipeline(pipeline0);
} catch {}
document.body.prepend(img0);
let bindGroup6 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 37, resource: {buffer: buffer2, offset: 9216, size: 773}},
    {binding: 124, resource: {buffer: buffer4, offset: 768, size: 2144}},
    {binding: 39, resource: textureView1},
    {binding: 120, resource: {buffer: buffer2, offset: 10752, size: 507}},
    {binding: 357, resource: {buffer: buffer1, offset: 15616, size: 4196}},
  ],
});
try {
computePassEncoder13.setBindGroup(0, bindGroup5, new Uint32Array(799), 163, 0);
} catch {}
try {
commandEncoder15.copyBufferToTexture({
  /* bytesInLastRow: 5 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 1319 */
  offset: 1319,
  rowsPerImage: 242,
  buffer: buffer1,
}, {
  texture: texture32,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup7 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 120, resource: {buffer: buffer1, offset: 4352, size: 6996}},
    {binding: 357, resource: {buffer: buffer1, offset: 768, size: 568}},
    {binding: 39, resource: textureView1},
    {binding: 124, resource: {buffer: buffer1, offset: 4352, size: 3640}},
    {binding: 37, resource: {buffer: buffer1, offset: 2048, size: 1381}},
  ],
});
let textureView10 = texture34.createView({dimension: '1d', aspect: 'all', arrayLayerCount: 1});
let computePassEncoder16 = commandEncoder15.beginComputePass({label: '\u5719\u0dee\u{1ff7d}\u{1f8c2}\u493c'});
try {
computePassEncoder13.setBindGroup(0, bindGroup5, new Uint32Array(4236), 189, 0);
} catch {}
try {
computePassEncoder2.setPipeline(pipeline2);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder17 = device0.createCommandEncoder();
let texture38 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 1},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder16.setPipeline(pipeline2);
} catch {}
try {
commandEncoder17.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1814 */
  offset: 1814,
  bytesPerRow: 26368,
  rowsPerImage: 321,
  buffer: buffer3,
}, {
  texture: texture1,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder17.resolveQuerySet(querySet0, 43, 101, buffer4, 1024);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: videoFrame2,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 98, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData5 = new ImageData(8, 72);
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'unspecified', transfer: 'smpteSt4281'} });
let computePassEncoder17 = commandEncoder17.beginComputePass({});
let sampler15 = device0.createSampler({
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 49.39,
  lodMaxClamp: 49.72,
  maxAnisotropy: 9,
});
try {
computePassEncoder16.setBindGroup(0, bindGroup4);
} catch {}
try {
computePassEncoder12.setBindGroup(0, bindGroup3, new Uint32Array(491), 79, 0);
} catch {}
let imageData6 = new ImageData(80, 16);
try {
computePassEncoder8.setBindGroup(3, bindGroup0, new Uint32Array(211), 5, 0);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
let commandEncoder18 = device0.createCommandEncoder({});
let computePassEncoder18 = commandEncoder18.beginComputePass({});
try {
computePassEncoder15.setBindGroup(2, bindGroup6);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 11, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(22).fill(90), /* required buffer size: 22 */
{offset: 22, rowsPerImage: 204}, {width: 82, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let commandEncoder19 = device0.createCommandEncoder({});
let computePassEncoder19 = commandEncoder19.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer4, 540); };
} catch {}
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
let textureView11 = texture17.createView({format: 'r16float'});
try {
computePassEncoder18.setPipeline(pipeline2);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
await gc();
let bindGroup8 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView7}]});
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer8 = device0.createBuffer({
  size: 518,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder20 = device0.createCommandEncoder({});
let computePassEncoder20 = commandEncoder20.beginComputePass({});
try {
computePassEncoder8.setBindGroup(0, bindGroup8, new Uint32Array(3136), 330, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); };
} catch {}
let shaderModule5 = device0.createShaderModule({
  label: '\u59b6\ubc48\ud25f\u9329\u0995\u28fc\u0270\u484f\u{1f6f6}',
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

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

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

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

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

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

@group(0) @binding(184) var tex5: texture_cube<i32>;

struct T0 {
  @align(8) @size(160) f0: i32,
}

struct VertexOutput3 {
  @location(7) f15: vec2h,
  @location(11) f16: vec4i,
  @location(15) f17: vec4h,
  @location(14) f18: f16,
  @builtin(position) f19: vec4f,
}

struct FragmentOutput3 {
  @location(0) @interpolate(flat) f0: f32,
  @location(3) @interpolate(flat, centroid) f1: f32,
}

alias vec3b = vec3<bool>;

var<workgroup> vw9: vec4h;

var<workgroup> vw10: f32;

var<workgroup> vw11: FragmentOutput3;

var<workgroup> vw12: atomic<u32>;

var<workgroup> vw13: vec2<bool>;

var<private> vp6 = modf(vec2h(5736.9, 3950.5));

var<private> vp7 = modf(vec2h(1100.8, 17584.0));

var<private> vp8 = array(modf(f16(589.5)), modf(f16(3014.2)), modf(f16(5372.2)), modf(f16(11612.9)), modf(f16(5079.0)), modf(f16(8432.1)));

@vertex @must_use
fn vertex3() -> VertexOutput3 {
  var out: VertexOutput3;
  var vf110: u32 = pack2x16snorm(vec2f(unconst_f32(0.03983), unconst_f32(0.1475)));
  let ptr37: ptr<private, vec2h> = &vp7.fract;
  let ptr38 = &vp7;
  out.f19 = vec4f(vp6.whole.yyyx);
  out.f16 = bitcast<vec4i>(unpack4x8unorm(u32(unconst_u32(175))));
  let ptr39: ptr<private, vec2h> = &(*ptr38).whole;
  let ptr40: ptr<private, vec2h> = &vp6.whole;
  let vf111: vec4f = trunc(vec4f(unconst_f32(0.5171), unconst_f32(0.1881), unconst_f32(0.1675), unconst_f32(0.5579)));
  out.f19 = vec4f(f32((*ptr37)[u32(unconst_u32(49))]));
  let ptr41 = &vp8[u32(unconst_u32(130))];
  var vf112: vec3f = normalize(vec3f(unconst_f32(0.09701), unconst_f32(0.05358), unconst_f32(0.00577)));
  return out;
}

@fragment
fn fragment5(@location(5) a0: vec2h) -> FragmentOutput3 {
  var out: FragmentOutput3;
  var vf113: u32 = pack4xU8Clamp(vec4u(unconst_u32(60), unconst_u32(193), unconst_u32(284), unconst_u32(28)));
  vp6 = modf(bitcast<vec2h>(pack4xU8Clamp(vec4u(unconst_u32(22), unconst_u32(270), unconst_u32(22), unconst_u32(584)))));
  var vf114: vec2h = faceForward(vec2h(unconst_f16(7232.6), unconst_f16(9198.2)), vec2h(vp8[u32(unconst_u32(91))].whole), vec2h(unconst_f16(31515.1), unconst_f16(19337.5)));
  var vf115: u32 = pack4xU8(vec4u(unconst_u32(333), unconst_u32(71), unconst_u32(89), unconst_u32(72)));
  let vf116: vec2u = textureDimensions(tex5);
  let vf117: vec4f = unpack4x8unorm(u32(unconst_u32(12)));
  out = FragmentOutput3(f32(vp8[5].fract), f32(vp8[5].fract));
  vf115 ^= bitcast<u32>(vp7.whole);
  let vf118: vec4f = vf117;
  let vf119: f16 = a0[u32(unconst_u32(95))];
  let vf120: vec2u = textureDimensions(tex5);
  let ptr42: ptr<private, f16> = &vp8[u32(unconst_u32(28))].whole;
  let vf121: u32 = vf116[u32(unconst_u32(273))];
  discard;
  return out;
}

@compute @workgroup_size(1, 1, 2)
fn compute6() {
  var vf122: FragmentOutput3 = workgroupUniformLoad(&vw11);
  let vf123: bool = (*&vw13)[u32(unconst_u32(120))];
  vw11 = FragmentOutput3(bitcast<f32>(vp7.fract), bitcast<f32>(vp7.fract));
  vp8[u32(unconst_u32(104))] = modf(f16(any((*&vw13))));
  let vf124: f16 = (*&vw9)[u32(unconst_u32(30))];
  let vf125: f16 = acos(f16(unconst_f16(12897.2)));
  let ptr43: ptr<workgroup, vec2<bool>> = &(*&vw13);
  let ptr44: ptr<private, f16> = &vp8[u32(unconst_u32(191))].fract;
  var vf126: f16 = (*&vw9)[u32(unconst_u32(32))];
  vw11.f0 = vf122.f1;
  let vf127: bool = vf123;
  let vf128: f32 = workgroupUniformLoad(&vw10);
  vw13 = vec2<bool>(max(vec4i(unconst_i32(569), unconst_i32(228), unconst_i32(23), unconst_i32(60)), vec4i(unconst_i32(58), unconst_i32(12), unconst_i32(48), unconst_i32(2))).rg);
  let vf129: bool = vw13[u32(workgroupUniformLoad(&vw9)[1])];
  let vf130: bool = vf129;
  vw13 = vec2<bool>(atan(vec4f(unconst_f32(0.02800), unconst_f32(0.1097), unconst_f32(0.2527), unconst_f32(0.01309))).gg);
  vp7 = modf(bitcast<vec2h>(atomicExchange(&vw12, u32(unconst_u32(18)))));
}`,
  sourceMap: {},
  hints: {},
});
let buffer9 = device0.createBuffer({label: '\u04b4\u{1fe40}', size: 3525, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder21 = device0.createCommandEncoder({label: '\u4d7c\u074a\u06c7\u{1ffce}\u{1f8fe}\u8554\u057c\u8566'});
try {
computePassEncoder13.setBindGroup(3, bindGroup1);
} catch {}
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
commandEncoder21.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 320 */
  offset: 320,
  rowsPerImage: 88,
  buffer: buffer9,
}, {
  texture: texture29,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte170m', transfer: 'smpte170m'} });
let commandEncoder22 = device0.createCommandEncoder({label: '\u8fd0\u05ab\u{1fee4}\u0ce9\u{1fee1}\uc9c8'});
let computePassEncoder21 = commandEncoder21.beginComputePass({});
try {
computePassEncoder8.end();
} catch {}
try {
device0.queue.writeBuffer(buffer5, 36, new Int16Array(3345), 1090, 56);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'smpte170m'} });
let texture39 = device0.createTexture({
  size: {width: 210},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['r16float'],
});
let computePassEncoder22 = commandEncoder8.beginComputePass();
try {
computePassEncoder19.setPipeline(pipeline2);
} catch {}
try {
commandEncoder22.copyTextureToBuffer({
  texture: texture29,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 368 */
  offset: 368,
  bytesPerRow: 13056,
  rowsPerImage: 474,
  buffer: buffer0,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData7 = new ImageData(24, 28);
try {
commandEncoder22.copyBufferToBuffer(buffer4, 868, buffer5, 108, 8);
} catch {}
let texture40 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 19},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: [undefined]});
try {
computePassEncoder15.setBindGroup(0, bindGroup5, new Uint32Array(1726), 9, 0);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder0.setBindGroup(2, bindGroup6);
} catch {}
try {
renderBundleEncoder0.setBindGroup(3, bindGroup6, new Uint32Array(2183), 88, 0);
} catch {}
try {
renderBundleEncoder0.setIndexBuffer(buffer5, 'uint32', 72);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 4}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder23 = commandEncoder22.beginComputePass({});
let sampler16 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMinClamp: 8.848,
  lodMaxClamp: 15.76,
});
try {
computePassEncoder22.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder0.setBindGroup(3, bindGroup2, new Uint32Array(2578), 273, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture40,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(334).fill(9), /* required buffer size: 334 */
{offset: 334}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule6 = device0.createShaderModule({
  label: '\u48ae\u3a0b\ue75d\u{1fe8e}\u{1ffbd}\u0ed4\u0d3c\u0495',
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

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

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

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

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

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

@group(0) @binding(184) var tex6: texture_cube<i32>;

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

struct S0 {
  @location(12) @interpolate(flat) f0: vec4u,
}

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

fn fn0(a0: array<VertexOutput4, 13>, a1: ptr<uniform, f16>) -> vec2u {
  var out: vec2u;
  let vf131: i32 = dot4I8Packed(u32(unconst_u32(127)), u32(unconst_u32(193)));
  vw14 <<= vw14;
  var vf132: vec4f = a0[12].f20;
  let vf133: u32 = workgroupUniformLoad(&vw14);
  let vf134: f32 = a0[12].f20[u32(unconst_u32(137))];
  let vf135: f32 = distance(vec3f(unconst_f32(0.1685), unconst_f32(0.3425), unconst_f32(0.05744)), vec3f(unconst_f32(0.08914), unconst_f32(0.2088), unconst_f32(-0.1179)));
  vw14 -= pack4x8unorm(a0[bitcast<u32>(transpose(mat3x3f(unconst_f32(0.2610), unconst_f32(0.1159), unconst_f32(0.07422), unconst_f32(0.01071), unconst_f32(0.03283), unconst_f32(0.2898), unconst_f32(0.3136), unconst_f32(0.2427), unconst_f32(0.1223)))[unconst_i32(0)].z)].f20);
  vw14 *= pack4xU8(bitcast<vec4u>(a0[12].f20));
  var vf136: f32 = asin(f32(unconst_f32(0.1447)));
  var vf137: f16 = vw15[bitcast<u32>(a0[12].f20[u32(unconst_u32(203))])][u32(unconst_u32(497))];
  var vf138: mat3x4h = workgroupUniformLoad(&vw15);
  let vf139: u32 = countTrailingZeros(u32(unconst_u32(214)));
  vf138 = mat3x4h(vec4h(a0[12].f20), vec4h(a0[12].f20), vec4h(a0[12].f20));
  vw14 <<= u32((*&vw15)[pack2x16snorm(vec2f(unconst_f32(0.06968), unconst_f32(-0.1259)))][3]);
  vp9 = VertexOutput4(vec4f(workgroupUniformLoad(&vw15)[unconst_i32(1)]));
  out <<= vec2u(vf133);
  vf138 = mat3x4h(f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]), f16(a0[12].f20[u32(unconst_u32(516))]));
  let vf140: VertexOutput4 = a0[12];
  vf132 *= vec4f(f32(pack2x16snorm(vec2f(unconst_f32(0.2326), unconst_f32(0.1048)))));
  let vf141: VertexOutput4 = a0[u32(unconst_u32(354))];
  var vf142: f16 = vf138[u32(unconst_u32(1))][u32(unconst_u32(115))];
  return out;
}

fn fn1(a0: ptr<private, VertexOutput4>) -> VertexOutput4 {
  var out: VertexOutput4;
  out = VertexOutput4(sqrt(vec2f(unconst_f32(0.4497), unconst_f32(0.00076))).grgr);
  out.f20 = unpack2x16unorm(u32(unconst_u32(276))).rggg;
  var vf143: bool = all(vec2<bool>(unconst_bool(true), unconst_bool(false)));
  out.f20 = vec4f(fract(vec4h(cross(vec3f(unconst_f32(0.02845), unconst_f32(0.2525), unconst_f32(0.2853)), vec3f(unconst_f32(0.2971), unconst_f32(0.1480), unconst_f32(0.02131))).yzzx)));
  out.f20 = min(vec3f(unconst_f32(0.01788), unconst_f32(0.1138), unconst_f32(0.5288)), vec3f(unconst_f32(0.3655), unconst_f32(0.06346), unconst_f32(0.4198))).zyzz;
  (*a0) = VertexOutput4(sinh(vec3f(unconst_f32(0.00695), unconst_f32(0.01456), unconst_f32(0.00386))).gbbb);
  var vf144: f16 = length(vec2h(sinh(f16(asinh(vec3f(unconst_f32(0.05414), unconst_f32(-0.09952), unconst_f32(0.2957)))[1]))));
  vf144 -= f16(vp9.f20[3]);
  var vf145: f32 = atan(f32(unconst_f32(0.08618)));
  var vf146: vec3u = countOneBits(vec3u(unconst_u32(244), unconst_u32(0), unconst_u32(866)));
  out.f20 = sinh(vec3f(unconst_f32(0.4890), unconst_f32(0.09412), unconst_f32(0.00237))).zyzy;
  let vf147: vec2u = textureDimensions(tex6);
  return out;
}

fn fn2() -> S0 {
  var out: S0;
  vp9 = VertexOutput4(pow(vec4f(unconst_f32(0.1733), unconst_f32(-0.03889), unconst_f32(0.06324), unconst_f32(0.1808)), vec4f(unconst_f32(0.2485), unconst_f32(0.08655), unconst_f32(-0.03950), unconst_f32(0.1471))));
  let vf148: u32 = pack4xI8Clamp(vec4i(unconst_i32(161), unconst_i32(146), unconst_i32(23), unconst_i32(82)));
  vp9 = VertexOutput4(vec4f(vp9.f20[u32(unconst_u32(19))]));
  var vf149: vec2f = atan(vec2f(unconst_f32(0.1520), unconst_f32(0.1033)));
  return out;
}

var<workgroup> vw14: u32;

var<workgroup> vw15: mat3x4h;

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

@vertex
fn vertex4(a0: S0) -> VertexOutput4 {
  var out: VertexOutput4;
  vp9 = VertexOutput4(vec4f(a0.f0));
  vp9 = VertexOutput4(vec4f(vp9.f20[u32(unconst_u32(77))]));
  out = VertexOutput4(vec4f(f32(abs(f16(unconst_f16(-599.1))))));
  let vf150: f32 = vp9.f20[u32(unconst_u32(500))];
  let vf151: vec3h = trunc(vec3h(unconst_f16(12327.5), unconst_f16(5658.0), unconst_f16(9622.9)));
  vp9.f20 = vec4f(vf151.brrg);
  let vf152: u32 = a0.f0[vec3u(sinh(vec3f(unconst_f32(0.02309), unconst_f32(0.1265), unconst_f32(0.04860)))).x];
  fn2();
  vp9.f20 = bitcast<vec4f>(a0.f0);
  out.f20 = vec4f(trunc(vec3h(unconst_f16(550.1), unconst_f16(8496.5), unconst_f16(4223.0))).zyzz);
  var vf153: u32 = a0.f0[u32(unconst_u32(86))];
  out.f20 = vec4f(vp9.f20[u32(unconst_u32(15))]);
  vp9.f20 = bitcast<vec4f>(a0.f0);
  let ptr45: ptr<function, u32> = &vf153;
  let ptr46: ptr<private, vec4f> = &vp9.f20;
  vp9 = VertexOutput4(vp9.f20);
  var vf154 = fn2();
  vf153 -= pack4x8unorm(vp9.f20);
  out = VertexOutput4(vec4f(f32(a0.f0[u32(unconst_u32(125))])));
  let ptr47: ptr<function, vec4u> = &vf154.f0;
  vf153 ^= insertBits(vec4u(unconst_u32(217), unconst_u32(337), unconst_u32(550), unconst_u32(129)), unpack4xU8(u32((*ptr46)[u32(trunc(vec3h(unconst_f16(2579.9), unconst_f16(-13420.1), unconst_f16(13570.9)))[0])])), u32(unconst_u32(15)), u32(unconst_u32(344))).r;
  out = VertexOutput4(bitcast<vec4f>(insertBits(vec3i(i32(vp9.f20[u32(dot4I8Packed(u32(unconst_u32(77)), u32(unconst_u32(85))))])), vec3i(unconst_i32(29), unconst_i32(190), unconst_i32(5)), u32(dot4I8Packed(u32(unconst_u32(47)), u32(unconst_u32(318)))), u32(unconst_u32(28))).ggrb));
  fn2();
  var vf155 = fn2();
  return out;
}

@fragment
fn fragment6() {
  var vf156: u32 = textureNumLevels(tex6);
  vp9.f20 -= vec4f(countTrailingZeros(vec4i(unconst_i32(75), unconst_i32(148), unconst_i32(-3), unconst_i32(381))));
  let vf157: vec4i = countTrailingZeros(vec4i(unconst_i32(2), unconst_i32(50), unconst_i32(519), unconst_i32(166)));
}

@compute @workgroup_size(2, 1, 1)
fn compute7(@builtin(global_invocation_id) a0: vec3u) {
  let vf158: u32 = pack2x16snorm(vec2f(unconst_f32(0.03842), unconst_f32(0.1300)));
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder23 = device0.createCommandEncoder({});
let textureView12 = texture4.createView({baseMipLevel: 0});
let textureView13 = texture14.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder24 = commandEncoder23.beginComputePass({});
let sampler17 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 61.48,
  lodMaxClamp: 61.60,
  maxAnisotropy: 8,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(1630), 42, 0);
} catch {}
try {
computePassEncoder13.end();
} catch {}
try {
computePassEncoder24.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder0.setBindGroup(3, bindGroup8);
} catch {}
let commandEncoder24 = device0.createCommandEncoder();
let textureView14 = texture1.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], stencilReadOnly: true});
try {
computePassEncoder21.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder1.setBindGroup(0, bindGroup6, new Uint32Array(1204), 100, 0);
} catch {}
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 420 widthInBlocks: 210 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2940 */
  offset: 2940,
  bytesPerRow: 18432,
  buffer: buffer3,
}, {
  texture: texture39,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 210, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder24.copyTextureToTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture36,
  mipLevel: 0,
  origin: {x: 60, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder25 = device0.createCommandEncoder({});
let texture41 = device0.createTexture({
  size: [105, 1, 10],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle0 = renderBundleEncoder0.finish({});
try {
computePassEncoder12.setBindGroup(0, bindGroup8, []);
} catch {}
try {
computePassEncoder23.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup3);
} catch {}
let bindGroup9 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 124, resource: {buffer: buffer4, offset: 0, size: 2328}},
    {binding: 357, resource: {buffer: buffer1, offset: 11520, size: 576}},
    {binding: 120, resource: {buffer: buffer1, offset: 6144, size: 664}},
    {binding: 37, resource: {buffer: buffer1, offset: 0, size: 5015}},
    {binding: 39, resource: textureView12},
  ],
});
let commandBuffer1 = commandEncoder13.finish();
let computePassEncoder25 = commandEncoder24.beginComputePass();
try {
computePassEncoder10.setBindGroup(1, bindGroup4, new Uint32Array(744), 131, 0);
} catch {}
try {
computePassEncoder9.end();
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup5);
} catch {}
try {
renderBundleEncoder1.setBindGroup(1, bindGroup6, new Uint32Array(187), 36, 0);
} catch {}
try {
commandEncoder25.clearBuffer(buffer5, 40, 68);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 38, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(161).fill(175), /* required buffer size: 161 */
{offset: 161}, {width: 92, height: 0, depthOrArrayLayers: 0});
} catch {}
let renderBundle1 = renderBundleEncoder1.finish({});
try {
computePassEncoder25.setPipeline(pipeline0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
await gc();
let bindGroup10 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView9}]});
let texture42 = device0.createTexture({
  size: {width: 1160},
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView15 = texture12.createView({dimension: '2d', arrayLayerCount: 1});
let computePassEncoder26 = commandEncoder9.beginComputePass({label: '\u060c\u{1fb1a}\u{1f74a}\u9abc\u{1f7c4}'});
try {
computePassEncoder14.setBindGroup(2, bindGroup3);
} catch {}
try {
computePassEncoder10.setBindGroup(0, bindGroup7, new Uint32Array(712), 110, 0);
} catch {}
try {
commandEncoder25.copyTextureToBuffer({
  texture: texture2,
  mipLevel: 0,
  origin: {x: 6, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 48 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 856 */
  offset: 856,
  bytesPerRow: 7936,
  buffer: buffer0,
}, {width: 12, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer2, 996, new Float32Array(10703), 1527, 808);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule7 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

@group(0) @binding(184) var tex7: texture_cube<i32>;

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

struct FragmentOutput4 {
  @location(0) f0: vec4f,
  @builtin(sample_mask) f1: u32,
  @location(3) @interpolate(flat, sample) f2: vec2i,
}

alias vec3b = vec3<bool>;

var<workgroup> vw16: array<atomic<i32>, 11>;

var<workgroup> vw17: mat3x2f;

var<workgroup> vw18: FragmentOutput4;

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

var<private> vp10 = array(modf(f32(0.1193)), modf(f32(-0.1068)), modf(f32(0.4123)), modf(f32(0.02871)), modf(f32(0.2786)), modf(f32(0.1066)), modf(f32(0.05423)), modf(f32(0.1578)), modf(f32(0.08776)), modf(f32(0.1684)), modf(f32(0.3109)), modf(f32(0.1138)), modf(f32(0.1243)), modf(f32(0.4695)), modf(f32(0.02283)), modf(f32(0.1338)), modf(f32(0.05370)), modf(f32(0.06001)), modf(f32(0.1778)), modf(f32(0.1862)), modf(f32(-0.04711)), modf(f32(0.3535)), modf(f32(0.00735)), modf(f32(0.4334)), modf(f32(0.1747)), modf(f32(0.1273)), modf(f32(0.07382)), modf(f32(0.2186)));

@fragment
fn fragment7(@location(15) @interpolate(perspective, sample) a0: vec2f, @location(9) @interpolate(linear, center) a1: vec2f, @location(10) @interpolate(flat, centroid) a2: vec2i) -> FragmentOutput4 {
  var out: FragmentOutput4;
  out.f0 = vec4f(vp10[27].whole);
  let vf159: f32 = a1[u32(unconst_u32(64))];
  let vf160: u32 = pack4xU8Clamp(vec4u(unconst_u32(36), unconst_u32(388), unconst_u32(5), unconst_u32(33)));
  let ptr48: ptr<private, f32> = &vp10[u32(unconst_u32(155))].fract;
  var vf161: vec2f = unpack2x16snorm(u32(unconst_u32(58)));
  let ptr49: ptr<private, f32> = &vp10[27].whole;
  let ptr50 = &vp10[27];
  out.f1 = u32(a0[u32(unconst_u32(219))]);
  out = FragmentOutput4(vec4f(sin(vec4h(unconst_f16(13929.7), unconst_f16(3059.4), unconst_f16(10449.1), unconst_f16(1804.0)))), u32(sin(vec4h(unconst_f16(13929.7), unconst_f16(3059.4), unconst_f16(10449.1), unconst_f16(1804.0))).x), bitcast<vec2i>(sin(vec4h(unconst_f16(13929.7), unconst_f16(3059.4), unconst_f16(10449.1), unconst_f16(1804.0)))));
  vf161 = vec2f((*ptr50).fract);
  var vf162: vec2f = sin(vec2f(unconst_f32(0.2108), unconst_f32(0.2157)));
  let ptr51: ptr<private, f32> = &(*ptr50).fract;
  vf162 = vec2f((*ptr48));
  vp10[u32(unconst_u32(1))] = modf((*ptr48));
  out.f1 &= bitcast<u32>(vp10[27].whole);
  vf162 = bitcast<vec2f>(unpack4xU8(u32(unconst_u32(466))).zz);
  let ptr52: ptr<private, f32> = &(*ptr50).whole;
  out = FragmentOutput4(vec4f((*ptr49)), u32((*ptr49)), vec2i(bitcast<i32>((*ptr49))));
  var vf163: vec4h = sin(vec4h(f16(vp10[27].fract)));
  return out;
}

@compute @workgroup_size(1, 2, 1)
fn compute8() {
  let vf164: i32 = atomicLoad(&vw19[9]);
  vp10[u32(unconst_u32(168))] = modf(f32(inverseSqrt(f16(unconst_f16(8251.1)))));
  atomicMax(&vw16[u32(unconst_u32(65))], i32(unconst_i32(-12)));
  let ptr53: ptr<workgroup, atomic<i32>> = &vw19[u32(unconst_u32(288))];
  let ptr54: ptr<workgroup, vec2i> = &(*&vw18).f2;
  vw17 -= mat3x2f(bitcast<f32>(atomicLoad(&(*&vw16)[10])), bitcast<f32>(atomicLoad(&(*&vw16)[10])), f32(atomicLoad(&(*&vw16)[10])), f32(atomicLoad(&(*&vw16)[10])), bitcast<f32>(atomicLoad(&(*&vw16)[10])), bitcast<f32>(atomicLoad(&(*&vw16)[10])));
  let ptr55: ptr<private, f32> = &vp10[u32(unconst_u32(12))].fract;
  atomicExchange(&vw16[u32(unconst_u32(108))], i32(inverseSqrt(f16(vp10[u32(unconst_u32(110))].whole))));
  vw17 = mat3x2f(f32(atomicLoad(&(*&vw16)[10])), f32(atomicLoad(&(*&vw16)[10])), f32(atomicLoad(&(*&vw16)[10])), f32(atomicLoad(&(*&vw16)[10])), bitcast<f32>(atomicLoad(&(*&vw16)[10])), f32(atomicLoad(&(*&vw16)[10])));
  let vf165: vec4h = sinh(vec4h(f16(atomicLoad(&vw19[9]))));
  let vf166: f32 = (*&vw18).f0[u32(atomicExchange(&(*&vw16)[u32(unconst_u32(65))], i32(unconst_i32(251))))];
  vp10[u32(unconst_u32(27))].whole = vec3f(asin(vec3h(unconst_f16(-214.3), unconst_f16(20066.4), unconst_f16(1790.4)))).g;
  let vf167: i32 = atomicExchange(&(*ptr53), i32(unconst_i32(67)));
  let ptr56: ptr<workgroup, vec2i> = &vw18.f2;
  atomicCompareExchangeWeak(&vw19[u32(unconst_u32(43))], unconst_i32(57), unconst_i32(56));
  let vf168: i32 = abs(i32(asin(vec3h(unconst_f16(31938.0), unconst_f16(18415.0), unconst_f16(5939.3))).z));
  let ptr57: ptr<private, f32> = &vp10[u32(unconst_u32(67))].whole;
  let ptr58: ptr<workgroup, vec4f> = &(*&vw18).f0;
  atomicCompareExchangeWeak(&vw19[u32(unconst_u32(57))], unconst_i32(-41), unconst_i32(336));
  let vf169: i32 = atomicLoad(&(*ptr53));
}`,
  sourceMap: {},
  hints: {},
});
let buffer10 = device0.createBuffer({
  label: '\u069f\u{1febf}\u{1f784}\u6bed',
  size: 37052,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder26 = device0.createCommandEncoder({});
let texture43 = device0.createTexture({
  size: {width: 580, height: 48, depthOrArrayLayers: 2},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder7.setBindGroup(2, bindGroup3);
} catch {}
try {
device0.queue.writeBuffer(buffer5, 4, new Float32Array(35293), 421, 40);
} catch {}
let bindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {binding: 16, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
try {
computePassEncoder4.setBindGroup(0, bindGroup6, new Uint32Array(166), 2, 0);
} catch {}
try {
computePassEncoder26.setPipeline(pipeline0);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
commandEncoder25.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2128 */
  offset: 2128,
  bytesPerRow: 2048,
  buffer: buffer1,
}, {
  texture: texture29,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture44 = device0.createTexture({
  size: [1160],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder27 = commandEncoder25.beginComputePass({});
let externalTexture1 = device0.importExternalTexture({label: '\u{1fca1}\u9037\ue1d6\u{1ff88}\u0974\u6380\u2f51\u{1feed}\u{1fece}', source: videoFrame0});
try {
computePassEncoder21.setBindGroup(3, bindGroup10, new Uint32Array(405), 1, 0);
} catch {}
try {
buffer8.unmap();
} catch {}
let buffer11 = device0.createBuffer({
  label: '\u4c8e\u{1fc96}\u6313',
  size: 2110,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder27 = device0.createCommandEncoder({});
try {
computePassEncoder16.setBindGroup(0, bindGroup10);
} catch {}
try {
computePassEncoder27.setBindGroup(3, bindGroup8, new Uint32Array(234), 16, 0);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline2);
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 344 widthInBlocks: 86 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 48 */
  offset: 48,
  buffer: buffer3,
}, {
  texture: texture44,
  mipLevel: 0,
  origin: {x: 541, y: 0, z: 0},
  aspect: 'all',
}, {width: 86, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture45 = device0.createTexture({size: [52], dimension: '1d', format: 'r16float', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(316), 20, 0);
} catch {}
let sampler18 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 88.44,
  lodMaxClamp: 89.30,
});
try {
computePassEncoder2.setBindGroup(3, bindGroup10, new Uint32Array(1288), 328, 0);
} catch {}
try {
commandEncoder27.resolveQuerySet(querySet1, 150, 18, buffer10, 7424);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture19,
  mipLevel: 0,
  origin: {x: 77, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(181).fill(176), /* required buffer size: 181 */
{offset: 181, bytesPerRow: 370, rowsPerImage: 55}, {width: 14, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder26.clearBuffer(buffer1, 2624, 2604);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 4}
*/
{
  source: imageData6,
  origin: { x: 5, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder28 = device0.createCommandEncoder({});
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 204});
let texture46 = device0.createTexture({
  size: {width: 290, height: 24, depthOrArrayLayers: 2},
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder28 = commandEncoder28.beginComputePass();
try {
computePassEncoder20.setBindGroup(0, bindGroup2, new Uint32Array(2853), 28, 0);
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 820 widthInBlocks: 205 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1040 */
  offset: 1040,
  bytesPerRow: 2816,
  buffer: buffer9,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 47, y: 0, z: 0},
  aspect: 'all',
}, {width: 205, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder4.insertDebugMarker('\u13ec');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(230).fill(253), /* required buffer size: 230 */
{offset: 230}, {width: 15, height: 0, depthOrArrayLayers: 1});
} catch {}
let shaderModule8 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

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

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

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

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

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

@group(0) @binding(184) var tex8: texture_cube<i32>;

struct T0 {
  @align(8) @size(8) f0: f16,
  @align(8) @size(48) f1: atomic<i32>,
}

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

struct FragmentOutput5 {
  @location(3) @interpolate(flat) f0: vec2i,
}

alias vec3b = vec3<bool>;

override override6: f16;

@id(60499) override override7: f32;

override override8: i32;

var<workgroup> vw20: array<array<FragmentOutput5, 1>, 2>;

var<workgroup> vw21: T0;

var<workgroup> vw22: atomic<i32>;

var<workgroup> vw23: atomic<i32>;

var<workgroup> vw24: FragmentOutput5;

var<workgroup> vw25: T0;

var<workgroup> vw26: T0;

var<private> vp11 = modf(f32(0.1337));

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

@fragment
fn fragment8(@location(7) a0: vec2h, @location(14) a1: f16) -> FragmentOutput5 {
  var out: FragmentOutput5;
  var vf170: vec4f = quantizeToF16(ceil(quantizeToF16(vec4f(unconst_f32(0.07833), unconst_f32(0.2042), unconst_f32(0.07035), unconst_f32(0.2665)))));
  vp12 = vec2h(unpack2x16unorm(u32(unconst_u32(165)))).x;
  let vf171: i32 = countTrailingZeros(i32(unconst_i32(84)));
  vp11 = modf(vp11.whole);
  var vf172: f32 = override7;
  var vf173: vec4i = clamp(vec4i(unconst_i32(405), unconst_i32(11), unconst_i32(140), unconst_i32(212)), vec4i(unconst_i32(88), unconst_i32(201), unconst_i32(161), unconst_i32(259)), vec4i(unconst_i32(259), unconst_i32(53), unconst_i32(299), unconst_i32(233)));
  let vf174: f16 = override6;
  var vf175: u32 = countTrailingZeros(u32(unconst_u32(72)));
  var vf176: vec2u = textureDimensions(tex8);
  out.f0 ^= vec2i(i32(a0[u32(unconst_u32(123))]));
  out.f0 = vec2i(bitcast<i32>(pack4xU8Clamp(vec4u(u32(countTrailingZeros(i32(unconst_i32(79))))))));
  vp11.fract = ceil(f32(unconst_f32(0.2906)));
  let vf177: u32 = textureNumLevels(tex8);
  vf173 += vec4i(sinh(vec4f(unconst_f32(0.2164), unconst_f32(0.03793), unconst_f32(0.2719), unconst_f32(-0.04827))));
  vf173 = bitcast<vec4i>(select(vec3u(unconst_u32(18), unconst_u32(67), unconst_u32(65)), vec3u(unconst_u32(171), unconst_u32(406), unconst_u32(31)), bool(unconst_bool(true))).bgbr);
  let vf178: vec4i = clamp(vec4i(unconst_i32(142), unconst_i32(-59), unconst_i32(7), unconst_i32(26)), vec4i(unconst_i32(55), unconst_i32(153), unconst_i32(349), unconst_i32(-8)), vec4i(unconst_i32(-44), unconst_i32(129), unconst_i32(98), unconst_i32(297)));
  let vf179: f32 = vf170[u32(unconst_u32(192))];
  return out;
  _ = override7;
  _ = override6;
}

@compute @workgroup_size(2, 1, 1)
fn compute9() {
  atomicAdd(&vw23, i32(unconst_i32(106)));
  let ptr59: ptr<workgroup, vec2i> = &(*&vw24).f0;
  vw20[u32(unconst_u32(330))][u32(unconst_u32(150))].f0 &= vec2i(atomicExchange(&(*&vw25).f1, i32(unconst_i32(-111))));
  vw20[u32(unconst_u32(473))][u32(unconst_u32(26))] = FragmentOutput5(vec2i(i32((*&vw25).f0)));
  let ptr60: ptr<workgroup, vec2i> = &vw20[u32(unconst_u32(32))][u32(unconst_u32(43))].f0;
  atomicCompareExchangeWeak(&vw21.f1, unconst_i32(6), unconst_i32(73));
  let ptr61: ptr<workgroup, FragmentOutput5> = &vw24;
  let ptr62: ptr<workgroup, FragmentOutput5> = &vw20[u32(unconst_u32(1))][u32(unconst_u32(12))];
  let ptr63: ptr<workgroup, atomic<i32>> = &vw26.f1;
  var vf180: vec4i = unpack4xI8(u32(unconst_u32(191)));
  var vf181: i32 = atomicExchange(&vw25.f1, i32(unconst_i32(5)));
  vf181 = sign(vec4i(unconst_i32(199), unconst_i32(171), unconst_i32(151), unconst_i32(345))).g;
  let ptr64: ptr<workgroup, vec2i> = &(*ptr60);
  let ptr65: ptr<workgroup, FragmentOutput5> = &(*&vw20)[u32(unconst_u32(274))][0];
}`,
  sourceMap: {},
  hints: {},
});
let buffer12 = device0.createBuffer({
  label: '\u5b16\u41ac\ubea3\u035d\u04f8\u1458\u{1fb32}\u0f3c',
  size: 677,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder29 = device0.createCommandEncoder();
let textureView16 = texture36.createView({});
try {
computePassEncoder28.setPipeline(pipeline2);
} catch {}
try {
commandEncoder27.copyBufferToTexture({
  /* bytesInLastRow: 76 widthInBlocks: 38 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4472 */
  offset: 4472,
  bytesPerRow: 6912,
  rowsPerImage: 209,
  buffer: buffer2,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {width: 38, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder22.insertDebugMarker('\u0a0c');
} catch {}
document.body.prepend(img0);
let bindGroup11 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView7}]});
let bindGroup12 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView15}]});
let texture47 = device0.createTexture({
  label: '\u7c85\u619f\u0247\u022f\u04bc\ua87d\ubf3b\ub3f4\u880a\ufb8f\u5cfe',
  size: [145],
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
});
let sampler19 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 31.11,
  maxAnisotropy: 3,
});
try {
computePassEncoder28.setBindGroup(3, bindGroup10, new Uint32Array(681), 18, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer4, 592); };
} catch {}
try {
commandEncoder26.copyBufferToBuffer(buffer10, 3324, buffer5, 20, 20);
} catch {}
let imageData8 = new ImageData(16, 76);
let buffer13 = device0.createBuffer({
  label: '\ubecd\u0cc1\u{1fde0}\u0dc5\u{1f81f}\uf721\uecd2\u3921\u5d95\u2938',
  size: 27353,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: false,
});
let texture48 = device0.createTexture({
  size: {width: 145},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler20 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 3.127,
  lodMaxClamp: 67.90,
});
let computePassEncoder29 = commandEncoder27.beginComputePass({});
let sampler21 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 11.00,
  lodMaxClamp: 94.23,
  maxAnisotropy: 14,
});
try {
computePassEncoder12.end();
} catch {}
let buffer14 = device0.createBuffer({
  size: 31167,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let computePassEncoder30 = commandEncoder29.beginComputePass({label: '\ub900\uc69b\u96cd\u8ec6\u0169\u7e7c\u0501\u{1f63f}'});
let sampler22 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 99.30,
});
let externalTexture2 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder0.setBindGroup(1, bindGroup9, new Uint32Array(583), 66, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder20.end();
} catch {}
try {
computePassEncoder29.setPipeline(pipeline2);
} catch {}
try {
commandEncoder12.copyBufferToTexture({
  /* bytesInLastRow: 156 widthInBlocks: 78 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1426 */
  offset: 1426,
  bytesPerRow: 50432,
  buffer: buffer3,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 68, y: 12, z: 0},
  aspect: 'all',
}, {width: 78, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule9 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(184) var tex9: texture_cube<i32>;

struct T0 {
  f0: array<vec4h>,
}

struct S1 {
  @location(15) f0: vec4u,
}

struct S2 {
  @location(3) f0: vec2f,
}

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

alias vec3b = vec3<bool>;

fn fn0() -> array<u32, 1> {
  var out: array<u32, 1>;
  out[0] >>= u32(firstTrailingBit(vec2i(unconst_i32(369), unconst_i32(51))).g);
  let vf182: u32 = pack4x8unorm(vec4f(unconst_f32(0.1486), unconst_f32(0.03560), unconst_f32(0.01843), unconst_f32(0.1226)));
  var vf183: i32 = select(i32(unconst_i32(34)), i32(unconst_i32(62)), bool(unconst_bool(true)));
  let vf184: u32 = pack4x8unorm(vec4f(unconst_f32(0.2759), unconst_f32(0.3187), unconst_f32(0.4562), unconst_f32(0.1432)));
  var vf185: vec2f = atan2(vec2f(unconst_f32(0.04886), unconst_f32(0.1943)), vec2f(unconst_f32(0.1234), unconst_f32(0.01709)));
  var vf186: u32 = vf184;
  vf186 &= pack4x8unorm(unpack4x8unorm(vf182));
  var vf187: u32 = pack4x8unorm(vec4f(unconst_f32(-0.1097), unconst_f32(0.4823), unconst_f32(0.3504), unconst_f32(0.07193)));
  var vf188: vec3f = atan2(vec3f(f32(vf182)), vec3f(unconst_f32(0.02699), unconst_f32(0.3094), unconst_f32(0.09744)));
  var vf189: mat2x2h = transpose(mat2x2h(unconst_f16(-4772.9), unconst_f16(11761.4), unconst_f16(2884.3), unconst_f16(16203.4)));
  out[u32(unconst_u32(146))] = bitcast<u32>(vf189[bitcast<u32>(firstLeadingBit(bitcast<i32>(vf188.r)))]);
  var vf190: u32 = dot(vec4u(unconst_u32(406), unconst_u32(284), unconst_u32(93), unconst_u32(167)), vec4u(unconst_u32(123), unconst_u32(58), unconst_u32(103), unconst_u32(52)));
  let vf191: f32 = vf188[u32(unconst_u32(25))];
  vf185 *= unpack2x16unorm(vf182);
  vf185 = unpack2x16unorm(dot(vec4u(unconst_u32(46), unconst_u32(44), unconst_u32(207), unconst_u32(630)), vec4u(unconst_u32(160), unconst_u32(462), unconst_u32(74), unconst_u32(72))));
  vf185 += log2(vec4f(unconst_f32(0.08597), unconst_f32(0.1161), unconst_f32(0.03965), unconst_f32(0.00211))).yx;
  let ptr66: ptr<function, i32> = &vf183;
  var vf192: vec2f = atan2(vec2f(unconst_f32(0.1071), unconst_f32(0.9868)), vec2f(unconst_f32(0.03847), unconst_f32(0.2449)));
  vf185 = vec2f(textureDimensions(tex9, i32(unconst_i32(4))));
  vf186 = textureDimensions(tex9, i32(unconst_i32(264)))[1];
  var vf193: vec2f = atan2(vec2f(unconst_f32(0.02754), unconst_f32(-0.07679)), vec2f(unconst_f32(0.1641), unconst_f32(0.1276)));
  return out;
}

var<workgroup> vw27: vec2f;

var<workgroup> vw28: atomic<i32>;

var<workgroup> vw29: vec4u;

var<workgroup> vw30: array<array<array<atomic<i32>, 32>, 1>, 1>;

var<workgroup> vw31: VertexOutput5;

var<workgroup> vw32: mat3x3f;

var<workgroup> vw33: atomic<i32>;

@vertex
fn vertex5(@location(9) a0: vec4h, a1: S1, a2: S2, @location(1) @interpolate(flat, center) a3: i32) -> VertexOutput5 {
  var out: VertexOutput5;
  let vf194: vec3f = pow(a2.f0.ggr, vec3f(unconst_f32(0.1305), unconst_f32(0.01051), unconst_f32(0.4783)));
  var vf195: S2 = a2;
  out.f21 *= vec4f(f32(pack4xU8Clamp(vec4u(unconst_u32(408), unconst_u32(85), unconst_u32(191), unconst_u32(646)))));
  var vf196: f32 = a2.f0[u32(unconst_u32(793))];
  vf195.f0 = atan(vec4f(unconst_f32(0.1802), unconst_f32(0.07678), unconst_f32(0.01207), unconst_f32(0.1403))).rr;
  let vf197: vec3u = countLeadingZeros(vec3u(unconst_u32(127), unconst_u32(141), unconst_u32(111)));
  vf196 = f32(a3);
  var vf198: vec3f = vf194;
  return out;
}

@fragment
fn fragment9(@builtin(position) a0: vec4f) -> @location(200) @interpolate(perspective) vec2f {
  var out: vec2f;
  var vf199 = fn0();
  var vf200 = fn0();
  fn0();
  out = vec2f(bitcast<f32>(vf199[0]));
  let vf201: vec4u = firstTrailingBit(vec4u(unconst_u32(30), unconst_u32(466), unconst_u32(75), unconst_u32(15)));
  vf200[u32(unconst_u32(385))] >>= vf199[u32(trunc(vec4h(unconst_f16(2563.7), unconst_f16(29528.4), unconst_f16(2975.6), unconst_f16(4022.7)))[0])];
  fn0();
  vf199[u32(unconst_u32(132))] |= clamp(u32(unconst_u32(110)), u32(unconst_u32(129)), u32(unconst_u32(380)));
  var vf202: bool = all(bool(unconst_bool(true)));
  let ptr67: ptr<function, u32> = &vf199[0];
  out = unpack2x16snorm(pack4xI8(vec4i(unconst_i32(124), unconst_i32(213), unconst_i32(276), unconst_i32(126))));
  var vf203: u32 = textureNumLevels(tex9);
  vf200[u32(unconst_u32(183))] = pack4xU8Clamp(vf201);
  vf203 ^= pack2x16snorm(asinh(vec2f(unconst_f32(-0.02680), unconst_f32(0.1541))));
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup13 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 124, resource: {buffer: buffer11, offset: 0, size: 2076}},
    {binding: 120, resource: {buffer: buffer1, offset: 5376, size: 1345}},
    {binding: 39, resource: textureView12},
    {binding: 37, resource: {buffer: buffer11, offset: 0, size: 1130}},
    {binding: 357, resource: {buffer: buffer1, offset: 5376, size: 11136}},
  ],
});
let commandEncoder30 = device0.createCommandEncoder({});
try {
computePassEncoder30.setPipeline(pipeline2);
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 37, resource: {buffer: buffer11, offset: 512, size: 488}},
    {binding: 120, resource: {buffer: buffer1, offset: 1792, size: 6290}},
    {binding: 39, resource: textureView12},
    {binding: 357, resource: {buffer: buffer1, offset: 3328, size: 3264}},
    {binding: 124, resource: {buffer: buffer4, offset: 256, size: 2128}},
  ],
});
let buffer15 = device0.createBuffer({
  size: 3160,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder31 = commandEncoder20.beginComputePass({});
try {
computePassEncoder18.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder5.setBindGroup(0, bindGroup2, new Uint32Array(4603), 8, 0);
} catch {}
try {
computePassEncoder31.setPipeline(pipeline0);
} catch {}
try {
commandEncoder12.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 168, y: 9, z: 1},
  aspect: 'all',
},
{
  texture: texture29,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder26.clearBuffer(buffer15);
} catch {}
let commandEncoder31 = device0.createCommandEncoder();
let sampler23 = device0.createSampler({
  label: '\u029b\ua709\u9177\u0d07\u6b5e\u5e44',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 2.077,
  lodMaxClamp: 78.80,
  compare: 'greater-equal',
  maxAnisotropy: 20,
});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: imageData1,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 21, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 11, height: 1, depthOrArrayLayers: 0});
} catch {}
await gc();
let commandEncoder32 = device0.createCommandEncoder({});
let texture49 = device0.createTexture({
  size: [580, 48, 2],
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder32 = commandEncoder12.beginComputePass();
let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], depthReadOnly: true});
try {
renderBundleEncoder2.setBindGroup(3, bindGroup5, new Uint32Array(10000), 38, 0);
} catch {}
try {
renderBundleEncoder2.insertDebugMarker('\uc173');
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture40,
  mipLevel: 2,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(37).fill(0), /* required buffer size: 37 */
{offset: 37, bytesPerRow: 14}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup15 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView0}]});
let textureView17 = texture33.createView({label: '\u53c1\u4191\u37ab\u08ec\uc263\u65b2\u{1fd14}\u0a76', dimension: 'cube', baseArrayLayer: 1});
let computePassEncoder33 = commandEncoder30.beginComputePass({});
try {
computePassEncoder27.setBindGroup(3, bindGroup9);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder33.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder2.setVertexBuffer(0, buffer1);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
buffer6.unmap();
} catch {}
try {
commandEncoder31.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 432 */
  offset: 432,
  buffer: buffer3,
}, {
  texture: texture7,
  mipLevel: 0,
  origin: {x: 45, y: 2, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder33 = device0.createCommandEncoder({});
let texture50 = device0.createTexture({
  label: '\u{1fec1}\u0bd0\u6fcc\u5824\u{1ff66}\u07a1\u{1f827}\u1ca6\u0b5a\u01e2\u330f',
  size: [26, 1, 1],
  mipLevelCount: 2,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView18 = texture12.createView({arrayLayerCount: 1});
let renderBundle2 = renderBundleEncoder2.finish({});
let texture51 = device0.createTexture({
  size: [1160, 96, 2],
  sampleCount: 1,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView19 = texture51.createView({label: '\u9e79\u0b61\ue393', dimension: '2d'});
let computePassEncoder34 = commandEncoder32.beginComputePass({});
let sampler24 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 90.84,
  lodMaxClamp: 93.57,
  maxAnisotropy: 1,
});
try {
computePassEncoder15.end();
} catch {}
try {
computePassEncoder34.setPipeline(pipeline0);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
commandEncoder11.copyBufferToTexture({
  /* bytesInLastRow: 298 widthInBlocks: 149 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1712 */
  offset: 1712,
  bytesPerRow: 48896,
  buffer: buffer3,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 149, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 1,
  origin: {x: 17, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(10).fill(104), /* required buffer size: 10 */
{offset: 10}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder33.copyBufferToBuffer(buffer9, 2568, buffer15, 348, 24);
} catch {}
try {
commandEncoder31.copyBufferToTexture({
  /* bytesInLastRow: 118 widthInBlocks: 59 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 74 */
  offset: 74,
  buffer: buffer7,
}, {
  texture: texture34,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, {width: 59, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer0, 992, new Int16Array(7143), 692, 148);
} catch {}
try {
externalTexture2.label = '\uc173\u058a\u99b4\ub752\u61d5\uf461\uc8e6\u5ef8\u5322';
} catch {}
let shaderModule10 = device0.createShaderModule({
  label: '\u0a48\u7965\ub43f\u8d91\u{1fb06}\u13ce\ue723\u0781\ucea4',
  code: `
enable f16;

requires unrestricted_pointer_parameters;

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

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

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

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

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

@group(0) @binding(184) var tex10: texture_cube<i32>;

struct T0 {
  @size(96) f0: mat3x2f,
}

struct VertexOutput6 {
  @location(0) f22: f32,
  @location(3) @interpolate(flat, centroid) f23: vec2i,
  @location(13) @interpolate(perspective, sample) f24: vec4f,
  @invariant @builtin(position) f25: vec4f,
  @location(1) f26: vec4h,
  @location(5) @interpolate(flat) f27: f16,
  @location(11) @interpolate(flat, centroid) f28: vec2f,
  @location(9) @interpolate(linear, sample) f29: f32,
}

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

fn fn0() -> array<array<FragmentOutput6, 1>, 1> {
  var out: array<array<FragmentOutput6, 1>, 1>;
  var vf204: vec4f = unpack4x8snorm(u32(unconst_u32(172)));
  vp14.f0 = mat3x2f(vec2f(tanh(vec3h(unconst_f16(2746.2), unconst_f16(6336.2), unconst_f16(15483.5))).gg), vec2f(tanh(vec3h(unconst_f16(2746.2), unconst_f16(6336.2), unconst_f16(15483.5))).xy), vec2f(tanh(vec3h(unconst_f16(2746.2), unconst_f16(6336.2), unconst_f16(15483.5))).xy));
  var vf205: vec3f = saturate(vec3f(unconst_f32(0.00502), unconst_f32(0.6520), unconst_f32(0.1479)));
  vp14 = T0(mat3x2f(f32(round(vec2h(asin(vec2f(unconst_f32(0.1123), unconst_f32(0.1885))))[1])), f32(round(vec2h(asin(vec2f(unconst_f32(0.1123), unconst_f32(0.1885))))[1])), f32(round(vec2h(asin(vec2f(unconst_f32(0.1123), unconst_f32(0.1885))))[1])), f32(round(vec2h(asin(vec2f(unconst_f32(0.1123), unconst_f32(0.1885))))[1])), f32(round(vec2h(asin(vec2f(unconst_f32(0.1123), unconst_f32(0.1885))))[1])), f32(round(vec2h(asin(vec2f(unconst_f32(0.1123), unconst_f32(0.1885))))[1]))));
  var vf206: vec4f = faceForward(vec4f(unconst_f32(0.02022), unconst_f32(-0.04090), unconst_f32(0.6101), unconst_f32(0.1598)), vec4f(unconst_f32(-0.6246), unconst_f32(0.05545), unconst_f32(-0.05631), unconst_f32(-0.4401)), vec4f(unconst_f32(-0.1572), unconst_f32(0.1244), unconst_f32(0.00830), unconst_f32(0.06065)));
  let vf207: vec2f = acos(vec2f(unconst_f32(0.1994), unconst_f32(0.02722)));
  let ptr68: ptr<function, vec3f> = &vf205;
  vf206 = vf205.yyxz;
  return out;
}

fn fn1() -> f16 {
  var out: f16;
  let vf208: vec3i = min(vec3i(unconst_i32(477), unconst_i32(52), unconst_i32(-180)), vec3i(unconst_i32(21), unconst_i32(96), unconst_i32(356)));
  let vf209: vec3h = ceil(vec3h(unconst_f16(2316.9), unconst_f16(1751.2), unconst_f16(7289.0)));
  let vf210: vec4u = unpack4xU8(u32(unconst_u32(40)));
  out -= f16(countTrailingZeros(vec3i(unconst_i32(-107), unconst_i32(57), unconst_i32(163)))[1]);
  let ptr69: ptr<private, mat3x2f> = &vp14.f0;
  out = length(f16(unconst_f16(-19847.9)));
  let ptr70: ptr<private, T0> = &vp14;
  var vf211: f16 = fract(f16(unconst_f16(11860.9)));
  vp14.f0 = mat3x2f((*ptr70).f0[u32(unconst_u32(283))][u32(unconst_u32(142))], (*ptr70).f0[u32(unconst_u32(283))][u32(unconst_u32(142))], (*ptr70).f0[u32(unconst_u32(283))][u32(unconst_u32(142))], (*ptr70).f0[u32(unconst_u32(283))][u32(unconst_u32(142))], (*ptr70).f0[u32(unconst_u32(283))][u32(unconst_u32(142))], (*ptr70).f0[u32(unconst_u32(283))][u32(unconst_u32(142))]);
  var vf212: vec3i = countTrailingZeros(vec3i(unconst_i32(78), unconst_i32(229), unconst_i32(240)));
  vf211 = vec4h(unpack4xU8(u32(unconst_u32(58)))).y;
  vf211 += f16(vp14.f0[u32(unconst_u32(35))][u32(unconst_u32(64))]);
  let ptr71: ptr<private, mat3x2f> = &vp14.f0;
  vp13 = f16((*ptr70).f0[u32(unconst_u32(18))].x);
  out = vp13;
  return out;
}

var<workgroup> vw34: FragmentOutput6;

var<workgroup> vw35: atomic<i32>;

var<workgroup> vw36: FragmentOutput6;

var<private> vp13: f16 = f16(6834.6);

var<private> vp14: T0 = T0();

@vertex
fn vertex6(@builtin(vertex_index) a0: u32, @location(2) a1: vec4u, @location(4) @interpolate(flat, sample) a2: i32, @location(7) a3: vec2h) -> VertexOutput6 {
  var out: VertexOutput6;
  out.f22 *= vec4f(countOneBits(unpack4xU8(u32(vp14.f0[u32(unconst_u32(196))][u32(unconst_u32(78))])))).r;
  out.f22 *= f32(a2);
  var vf213 = fn0();
  let ptr72: ptr<function, FragmentOutput6> = &vf213[u32(unconst_u32(103))][0];
  let vf214: vec2f = log(vec2f(unconst_f32(0.02830), unconst_f32(0.4185)));
  out.f22 = vf213[0][0].f0.z;
  out.f23 *= bitcast<vec2i>(vf213[0][0].f0.xy);
  let ptr73: ptr<function, FragmentOutput6> = &vf213[0][0];
  vf213[u32(unconst_u32(281))][u32(unconst_u32(54))] = vf213[u32(unconst_u32(13))][0];
  vp14 = T0(mat3x2f(vf213[u32(unconst_u32(1))][u32(unconst_u32(10))].f0.gb, vf213[u32(unconst_u32(1))][u32(unconst_u32(10))].f0.xz, vf213[u32(unconst_u32(1))][u32(unconst_u32(10))].f0.br));
  out.f24 -= vp14.f0[unconst_i32(1)].yxyy;
  out.f25 -= vec4f(vf213[bitcast<u32>(vp14.f0[u32(unconst_u32(65))][0])][u32(unconst_u32(238))].f0[u32(unconst_u32(286))]);
  out.f29 = f32(vp13);
  out.f24 *= vec4f(f32(a3[u32(unconst_u32(113))]));
  vf213[u32(unconst_u32(72))][0] = vf213[u32(unconst_u32(636))][0];
  out.f24 *= (*ptr72).f0;
  out.f26 += vec4h(f16(vf213[0][u32(unconst_u32(153))].f0[u32(unconst_u32(117))]));
  return out;
}

@fragment
fn fragment10() -> FragmentOutput6 {
  var out: FragmentOutput6;
  var vf215 = fn1();
  vp13 = f16(textureNumLevels(tex10));
  fn1();
  let vf216: f32 = length(f32(unconst_f32(0.1542)));
  var vf217 = fn1();
  out.f0 = vec4f(vf216);
  let ptr74: ptr<private, T0> = &vp14;
  fn1();
  let ptr75: ptr<function, f16> = &vf217;
  vp13 += f16(transpose(mat4x3f())[unconst_i32(0)][3]);
  vf215 = vec2h((*ptr74).f0[unconst_i32(1)]).g;
  vf215 = f16((*ptr74).f0[unconst_i32(2)][1]);
  var vf218 = fn1();
  out.f0 -= vp14.f0[u32(unconst_u32(652))].yyyx;
  vp13 = f16((*ptr74).f0[unconst_i32(1)].y);
  discard;
  discard;
  vf217 = vf215;
  let ptr76: ptr<function, f16> = &vf218;
  var vf219 = fn1();
  var vf220 = fn1();
  vf219 -= f16(vf216);
  var vf221 = fn1();
  vf219 = vf220;
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute10(@builtin(local_invocation_id) a0: vec3u, @builtin(workgroup_id) a1: vec3u) {
  vp14 = T0(mat3x2f(vw36.f0[u32(unconst_u32(87))], vw36.f0[u32(unconst_u32(87))], vw36.f0[u32(unconst_u32(87))], vw36.f0[u32(unconst_u32(87))], vw36.f0[u32(unconst_u32(87))], vw36.f0[u32(unconst_u32(87))]));
  var vf222 = fn0();
  vw36.f0 = fract(vec3f(unconst_f32(0.1907), unconst_f32(0.1172), unconst_f32(0.3469))).rrbb;
  vw36 = vf222[0][0];
  fn0();
  vp14.f0 = mat3x2f(vw36.f0.gb, vw36.f0.ba, vw36.f0.ww);
  fn0();
  let ptr77: ptr<workgroup, vec4f> = &(*&vw34).f0;
  let ptr78: ptr<workgroup, vec4f> = &vw34.f0;
  fn0();
  var vf223 = fn0();
  var vf224: f32 = vf222[pack4x8unorm(vf222[0][u32(unconst_u32(615))].f0)][u32(unconst_u32(290))].f0[u32(unconst_u32(178))];
  fn0();
}

@compute @workgroup_size(1, 1, 1)
fn compute11(@builtin(local_invocation_id) a0: vec3u) {
  fn0();
  let vf225: u32 = pack4xI8(vec4i(unconst_i32(81), unconst_i32(71), unconst_i32(3), unconst_i32(133)));
  var vf226 = fn0();
  vf226[u32(unconst_u32(202))][0].f0 -= vf226[u32(unconst_u32(154))][u32(unconst_u32(95))].f0;
  fn0();
  let vf227: f32 = cos(f32(unconst_f32(0.07748)));
  var vf228: f32 = vf226[u32(unconst_u32(357))][0].f0[u32(unconst_u32(23))];
  fn0();
  vf228 = vw36.f0[3];
}

@compute @workgroup_size(2, 1, 1)
fn compute12(@builtin(local_invocation_id) a0: vec3u, @builtin(num_workgroups) a1: vec3u) {
  var vf229: u32 = a1[u32(unconst_u32(198))];
  var vf230: f32 = vw34.f0[u32(unconst_u32(131))];
  fn0();
  let vf231: u32 = pack2x16float(vec2f(unconst_f32(0.1108), unconst_f32(0.4017)));
  vf229 >>= pack4x8snorm(workgroupUniformLoad(&vw34).f0);
  vw34.f0 *= vec4f(bitcast<f32>(a1[u32(unconst_u32(83))]));
  atomicStore(&vw35, i32(unconst_i32(241)));
  fn0();
  fn0();
  var vf232 = fn0();
  fn0();
  vf230 -= vp14.f0[unconst_i32(2)][1];
  let ptr79: ptr<function, array<FragmentOutput6, 1>> = &vf232[u32(unconst_u32(50))];
  vf229 = bitcast<u32>(vf232[u32(unconst_u32(31))][0].f0.g);
  vp13 -= vec4h((*ptr79)[0].f0)[2];
  let ptr80: ptr<function, vec4f> = &vf232[u32(unconst_u32(5))][0].f0;
}

@compute @workgroup_size(1, 2, 2)
fn compute13(@builtin(workgroup_id) a0: vec3u, @builtin(local_invocation_index) a1: u32, @builtin(global_invocation_id) a2: vec3u) {
  var vf233: u32 = pack2x16float(vec2f(unconst_f32(0.2618), unconst_f32(0.1336)));
  let vf234: u32 = a1;
  var vf235 = fn0();
  atomicAnd(&vw35, i32(unconst_i32(57)));
  vf233 <<= pack4x8snorm(vw36.f0);
  var vf236 = fn0();
  let vf237: i32 = firstTrailingBit(bitcast<i32>(vf236[u32(vp14.f0[unconst_i32(1)].g)][0].f0[3]));
  var vf238 = fn0();
}`,
  sourceMap: {},
});
let texture52 = device0.createTexture({
  label: '\u{1fd59}\u2f78\ud34f\u0893\u{1f6cc}\u0e61\u33fc\u069c\u72cf\u{1f9c0}',
  size: {width: 64, height: 64, depthOrArrayLayers: 18},
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder35 = commandEncoder31.beginComputePass({});
try {
computePassEncoder0.setBindGroup(1, bindGroup6, []);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture39,
  mipLevel: 0,
  origin: {x: 85, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(173).fill(133), /* required buffer size: 173 */
{offset: 173}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup16 = device0.createBindGroup({
  label: '\u04f7\u23af\ufa47\u8255\u6577',
  layout: bindGroupLayout2,
  entries: [{binding: 329, resource: textureView4}],
});
let commandEncoder34 = device0.createCommandEncoder({});
let texture53 = device0.createTexture({
  label: '\u0b1b\u7e30\u0da3\u0d30\u6dbe',
  size: {width: 26, height: 1, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView20 = texture47.createView({});
try {
computePassEncoder34.setBindGroup(2, bindGroup13, []);
} catch {}
try {
computePassEncoder35.setPipeline(pipeline0);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(162).fill(38), /* required buffer size: 162 */
{offset: 162}, {width: 31, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup17 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView7}]});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true, stencilReadOnly: false});
try {
renderBundleEncoder3.setIndexBuffer(buffer1, 'uint16', 808, 3_835);
} catch {}
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], depthReadOnly: false, stencilReadOnly: true});
try {
computePassEncoder5.setBindGroup(2, bindGroup13);
} catch {}
try {
computePassEncoder0.setBindGroup(3, bindGroup13, new Uint32Array(3055), 217, 0);
} catch {}
try {
renderBundleEncoder4.setBindGroup(2, bindGroup12);
} catch {}
let promise1 = device0.queue.onSubmittedWorkDone();
let bindGroup18 = device0.createBindGroup({
  label: '\uc1b7\u0dc3\ub7dc',
  layout: bindGroupLayout3,
  entries: [{binding: 16, resource: {buffer: buffer1, offset: 7936, size: 1484}}],
});
let textureView21 = texture38.createView({label: '\u0eb8\u1d4b\u0bdc\u0ea4\ub9ca\u5c39', dimension: '2d-array', baseMipLevel: 0});
let sampler25 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 36.28,
  lodMaxClamp: 98.94,
});
try {
computePassEncoder27.setBindGroup(2, bindGroup7, new Uint32Array(1574), 2, 0);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer14, 'uint32', 3_316, 12_647);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(5, buffer10, 0);
} catch {}
let computePassEncoder36 = commandEncoder26.beginComputePass({});
let renderBundle3 = renderBundleEncoder3.finish();
let sampler26 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 22.72,
  lodMaxClamp: 58.28,
});
try {
renderBundleEncoder4.setVertexBuffer(5, buffer6, 0);
} catch {}
try {
commandEncoder33.copyTextureToBuffer({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 21, y: 4, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 996 widthInBlocks: 249 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1376 */
  offset: 1376,
  bytesPerRow: 2304,
  buffer: buffer14,
}, {width: 249, height: 75, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer10, 9548, new Float32Array(8883), 1319, 272);
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let bindGroup19 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView15}]});
let commandEncoder35 = device0.createCommandEncoder();
let textureView22 = texture47.createView({label: '\u{1fb72}\u18e6\u6c3b\ucc03\u{1facb}', baseMipLevel: 0});
let renderBundle4 = renderBundleEncoder4.finish({});
let computePassEncoder37 = commandEncoder34.beginComputePass();
let sampler27 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 80.22,
  lodMaxClamp: 90.89,
  maxAnisotropy: 11,
});
try {
commandEncoder35.clearBuffer(buffer15);
} catch {}
try {
  await promise1;
} catch {}
let imageData9 = new ImageData(12, 48);
let commandEncoder36 = device0.createCommandEncoder({});
let commandBuffer2 = commandEncoder11.finish();
let computePassEncoder38 = commandEncoder36.beginComputePass({});
let sampler28 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 29.38,
  lodMaxClamp: 65.93,
});
try {
computePassEncoder36.setPipeline(pipeline0);
} catch {}
try {
buffer13.unmap();
} catch {}
try {
commandEncoder33.copyBufferToTexture({
  /* bytesInLastRow: 1208 widthInBlocks: 302 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3732 */
  offset: 3732,
  bytesPerRow: 2816,
  rowsPerImage: 219,
  buffer: buffer10,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 302, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture49,
  mipLevel: 0,
  origin: {x: 197, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(9_568).fill(36), /* required buffer size: 9_568 */
{offset: 28, bytesPerRow: 796}, {width: 196, height: 12, depthOrArrayLayers: 1});
} catch {}
let imageData10 = new ImageData(4, 32);
let textureView23 = texture50.createView({mipLevelCount: 1});
let computePassEncoder39 = commandEncoder33.beginComputePass({label: '\u0f52\ubb87'});
try {
computePassEncoder22.setBindGroup(0, bindGroup11, new Uint32Array(1656), 267, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
commandEncoder35.copyBufferToTexture({
  /* bytesInLastRow: 140 widthInBlocks: 35 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2548 */
  offset: 2548,
  buffer: buffer2,
}, {
  texture: texture44,
  mipLevel: 0,
  origin: {x: 71, y: 0, z: 0},
  aspect: 'all',
}, {width: 35, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout4 = device0.createBindGroupLayout({
  label: '\u2f20\u0201\u07ee\u{1feed}\u{1fc0b}\u0117',
  entries: [
    {
      binding: 409,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let buffer16 = device0.createBuffer({size: 6181, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let computePassEncoder40 = commandEncoder35.beginComputePass();
try {
computePassEncoder4.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder37.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 18, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(24).fill(23), /* required buffer size: 24 */
{offset: 24, bytesPerRow: 497}, {width: 88, height: 5, depthOrArrayLayers: 0});
} catch {}
let bindGroup20 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 16, resource: {buffer: buffer4, offset: 0, size: 840}}],
});
let buffer17 = device0.createBuffer({
  size: 3306,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 373});
let texture54 = device0.createTexture({
  label: '\ubf1e\u4547\ua4d5\u{1fc7a}',
  size: {width: 210, height: 1, depthOrArrayLayers: 39},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder2.setBindGroup(3, bindGroup16, []);
} catch {}
try {
computePassEncoder27.setBindGroup(3, bindGroup0, new Uint32Array(4794), 2_954, 0);
} catch {}
let bindGroup21 = device0.createBindGroup({
  label: '\u{1f7e2}\u5c4f\u{1fa2f}\u{1f778}\ub258\u7c64\u0c12',
  layout: bindGroupLayout2,
  entries: [{binding: 329, resource: textureView15}],
});
let sampler29 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 24.54,
  lodMaxClamp: 59.94,
});
try {
buffer16.unmap();
} catch {}
let buffer18 = device0.createBuffer({size: 11738, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX});
let commandEncoder37 = device0.createCommandEncoder({});
let textureView24 = texture30.createView({dimension: '2d', format: 'rg32sint', baseArrayLayer: 1});
let computePassEncoder41 = commandEncoder37.beginComputePass({});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], depthReadOnly: true});
try {
computePassEncoder30.setBindGroup(0, bindGroup4);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer8, 60); };
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer10, 'uint16', 442, 16_866);
} catch {}
let bindGroup22 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView17}]});
try {
computePassEncoder40.setPipeline(pipeline0);
} catch {}
let texture55 = device0.createTexture({
  size: [580],
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView25 = texture37.createView({aspect: 'all'});
try {
computePassEncoder37.setBindGroup(0, bindGroup9, new Uint32Array(5062), 1_002, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer6, 'uint16', 3_720, 6);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(310).fill(231), /* required buffer size: 310 */
{offset: 310, rowsPerImage: 11}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
let commandEncoder38 = device0.createCommandEncoder({});
let computePassEncoder42 = commandEncoder38.beginComputePass({});
let sampler30 = device0.createSampler({
  label: '\u0dc0\uf3f0\u9e0a',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 97.40,
  lodMaxClamp: 99.94,
  maxAnisotropy: 20,
});
try {
computePassEncoder38.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(3, bindGroup21);
} catch {}
try {
renderBundleEncoder5.setBindGroup(0, bindGroup17, new Uint32Array(2184), 342, 0);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
buffer1.unmap();
} catch {}
let bindGroup23 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 16, resource: {buffer: buffer11, offset: 0, size: 800}}],
});
let commandEncoder39 = device0.createCommandEncoder({});
let computePassEncoder43 = commandEncoder39.beginComputePass({});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true, stencilReadOnly: true});
let sampler31 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 87.30,
  lodMaxClamp: 95.34,
});
try {
computePassEncoder6.setBindGroup(0, bindGroup20, new Uint32Array(2714), 639, 0);
} catch {}
try {
computePassEncoder41.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture54,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(210).fill(104), /* required buffer size: 210 */
{offset: 210}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 1, depthOrArrayLayers: 4}
*/
{
  source: imageData3,
  origin: { x: 35, y: 2 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder42.setPipeline(pipeline0);
} catch {}
try {
  await promise2;
} catch {}
let buffer19 = device0.createBuffer({
  size: 14146,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture56 = device0.createTexture({
  size: [26, 1, 54],
  mipLevelCount: 1,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder22.setBindGroup(2, bindGroup18);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1); };
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(1, buffer10, 184, 25);
} catch {}
try {
buffer17.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer14, 16248, new DataView(new ArrayBuffer(2261)), 2, 16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 44, y: 3, z: 0},
  aspect: 'all',
}, new Uint8Array(201).fill(148), /* required buffer size: 201 */
{offset: 201}, {width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
let shaderModule11 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

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

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

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

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

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

@group(0) @binding(184) var tex11: texture_cube<i32>;

struct T0 {
  @size(96) f0: array<array<mat3x3f, 1>, 1>,
  @size(48) f1: mat2x3h,
}

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

fn fn0(a0: FragmentOutput7, a1: ptr<storage, array<array<array<array<vec2h, 1>, 1>, 1>>, read>) -> array<FragmentOutput7, 1> {
  var out: array<FragmentOutput7, 1>;
  out[u32(unconst_u32(205))] = FragmentOutput7(a0.f0, a0.f0.z);
  let vf239: vec3i = countLeadingZeros(vec3i(unconst_i32(364), unconst_i32(238), unconst_i32(106)));
  out[u32(unconst_u32(325))] = FragmentOutput7(a0.f0, a0.f0[1]);
  let ptr81: ptr<storage, array<vec2h, 1>, read> = &(*a1)[u32(unconst_u32(109))][0][0];
  return out;
}

fn fn1(a0: ptr<uniform, FragmentOutput7>) -> FragmentOutput7 {
  var out: FragmentOutput7;
  out.f0 >>= vec4u(reflect(vec3h(unconst_f16(169.3), unconst_f16(-5177.4), unconst_f16(7586.6)), vec3h(unconst_f16(12660.4), unconst_f16(377.3), unconst_f16(-2250.3))).xzzy);
  out.f0 &= bitcast<vec4u>(countOneBits(vec2i(unconst_i32(105), unconst_i32(-342))).xyxx);
  let vf240: vec2i = countOneBits(vec2i(unconst_i32(26), unconst_i32(376)));
  out.f0 *= bitcast<vec4u>(countOneBits(vec2i(unconst_i32(26), unconst_i32(153))).yxxx);
  var vf241: u32 = pack4x8unorm(vec4f(unconst_f32(0.2472), unconst_f32(0.1308), unconst_f32(0.1400), unconst_f32(0.4613)));
  out.f1 *= (*a0).f0[u32(unconst_u32(452))];
  vf241 &= min(vec2u(unconst_u32(1), unconst_u32(7)), vec2u(unconst_u32(300), unconst_u32(209))).g;
  out.f0 += vec4u(reflect(vec3h(unconst_f16(17413.9), unconst_f16(12642.4), unconst_f16(21519.8)), vec3h(unconst_f16(9404.0), unconst_f16(5836.1), unconst_f16(34599.3))).zxxy);
  out.f0 = (*a0).f0;
  vf241 <<= (*a0).f1;
  out.f1 *= (*a0).f1;
  var vf242: u32 = pack4xI8Clamp(vec4i(unconst_i32(51), unconst_i32(348), unconst_i32(256), unconst_i32(200)));
  out.f1 = u32(vf240[1]);
  out.f1 = bitcast<vec2u>(vf240)[0];
  out = FragmentOutput7(bitcast<vec4u>(countOneBits(vec2i(unconst_i32(86), unconst_i32(-34))).rrrg), bitcast<vec2u>(countOneBits(vec2i(unconst_i32(86), unconst_i32(-34))))[0]);
  return out;
}

var<workgroup> vw37: atomic<i32>;

@vertex
fn vertex7(@location(13) @interpolate(flat) a0: u32, @location(1) @interpolate(perspective) a1: f16) -> @builtin(position) vec4f {
  var out: vec4f;
  out = log(vec2f(unconst_f32(0.1192), unconst_f32(0.04527))).yyxx;
  var vf243: vec2h = saturate(vec2h(unconst_f16(10593.2), unconst_f16(5483.8)));
  let vf244: u32 = pack4xI8Clamp(vec4i(unconst_i32(122), unconst_i32(90), unconst_i32(401), unconst_i32(106)));
  out = unpack4x8snorm(vf244);
  out = vec4f(smoothstep(f32(unconst_f32(0.06345)), f32(unconst_f32(-0.1612)), f32(unconst_f32(0.09383))));
  out = vec4f(vf243.yxyy);
  out = refract(vec3f(unconst_f32(0.2720), unconst_f32(0.07005), unconst_f32(0.2670)), vec3f(unconst_f32(0.04887), unconst_f32(0.01346), unconst_f32(0.01464)), f32(unconst_f32(0.1255))).rrbb;
  var vf245: f16 = sin(f16(unconst_f16(13893.3)));
  let vf246: vec2f = round(unpack2x16float(dot4U8Packed(u32(unconst_u32(202)), u32(unconst_u32(10)))));
  vf245 += sin(vec2h(f16(any(vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false), unconst_bool(true)))))).y;
  let ptr82: ptr<function, vec2h> = &vf243;
  vf243 = vec2h(vf243[u32(unconst_u32(492))]);
  let vf247: u32 = vf244;
  return out;
}

@fragment
fn fragment11(@location(11) @interpolate(perspective) a0: vec2f) -> FragmentOutput7 {
  var out: FragmentOutput7;
  let vf248: u32 = countOneBits(u32(unconst_u32(4)));
  var vf249: u32 = pack4xU8(vec4u(unconst_u32(41), unconst_u32(34), unconst_u32(6), unconst_u32(292)));
  let vf250: vec2u = textureDimensions(tex11, i32(unconst_i32(516)));
  vf249 >>= textureDimensions(tex11, i32(unconst_i32(226)))[1];
  out.f1 &= vf250[u32(unconst_u32(1))];
  out.f0 *= bitcast<vec4u>(max(vec3f(unconst_f32(0.03848), unconst_f32(0.07078), unconst_f32(0.06207)), vec3f(unconst_f32(-0.1348), unconst_f32(0.1897), unconst_f32(0.08993))).zxzy);
  return out;
}

@fragment
fn fragment12(@location(15) @interpolate(perspective, center) a0: vec4h, @location(7) a1: vec2h, @location(11) a2: vec4i) -> @location(200) @interpolate(flat) vec4f {
  var out: vec4f;
  var vf251: vec4f = inverseSqrt(vec4f(unconst_f32(0.1671), unconst_f32(0.09759), unconst_f32(0.02122), unconst_f32(0.06188)));
  var vf252: vec2i = insertBits(vec2i(unconst_i32(-350), unconst_i32(131)), vec2i(unconst_i32(158), unconst_i32(194)), u32(unconst_u32(356)), u32(unconst_u32(354)));
  let vf253: u32 = textureNumLevels(tex11);
  var vf254: vec3h = ceil(vec3h(unconst_f16(23267.1), unconst_f16(6232.5), unconst_f16(7013.3)));
  vf251 = vec4f(round(vec4h(unconst_f16(-10748.3), unconst_f16(6625.5), unconst_f16(12947.9), unconst_f16(2901.8))));
  var vf255: f16 = vf254[u32(unconst_u32(493))];
  out = vec4f(pow(vec4h(unconst_f16(1601.7), unconst_f16(2003.4), unconst_f16(60000.0), unconst_f16(3884.8)), vec4h(unconst_f16(17208.9), unconst_f16(12417.4), unconst_f16(12875.5), unconst_f16(2842.6))));
  vf255 = f16(cos(vec3f(unconst_f32(0.1354), unconst_f32(0.07989), unconst_f32(0.03728))).z);
  out -= vec4f(f32(vf254[u32(unconst_u32(168))]));
  let vf256: f16 = a0[u32(unconst_u32(206))];
  vf255 = f16(log(vec3f(unconst_f32(0.4027), unconst_f32(0.4040), unconst_f32(0.1061)))[1]);
  let ptr83: ptr<function, vec3h> = &vf254;
  let vf257: vec4h = refract(vec4h(unconst_f16(10240.1), unconst_f16(5216.2), unconst_f16(2872.0), unconst_f16(8896.8)), vec4h(inverseSqrt(vec4f(unconst_f32(0.01543), unconst_f32(0.08002), unconst_f32(0.01218), unconst_f32(0.1095)))), f16(unconst_f16(8021.9)));
  vf251 = vec4f(a0);
  out = bitcast<vec4f>(vf252.xxxx);
  let vf258: i32 = vf252[u32(unconst_u32(158))];
  vf251 = vec4f(bitcast<f32>(a2[u32(unconst_u32(341))]));
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup24 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView15}]});
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer20 = device0.createBuffer({label: '\ub7eb\u01ed', size: 2672, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder40 = device0.createCommandEncoder({});
let textureView26 = texture0.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer10, 'uint16', 1_168, 10_380);
} catch {}
try {
commandEncoder40.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 96 */
  offset: 96,
  buffer: buffer19,
}, {
  texture: texture14,
  mipLevel: 1,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder40.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4210 */
  offset: 4210,
  buffer: buffer4,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder40.resolveQuerySet(querySet3, 160, 12, buffer10, 15872);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 580, height: 48, depthOrArrayLayers: 2}
*/
{
  source: imageData6,
  origin: { x: 20, y: 1 },
  flipY: false,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 97, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 13, height: 2, depthOrArrayLayers: 0});
} catch {}
let commandEncoder41 = device0.createCommandEncoder({label: '\u{1fbe8}\u882b\u05c5\u{1fd13}'});
try {
computePassEncoder4.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder32.setBindGroup(0, bindGroup11, new Uint32Array(7229), 412, 0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup6);
} catch {}
let imageBitmap0 = await createImageBitmap(videoFrame1);
let bindGroup25 = device0.createBindGroup({
  label: '\u0a7f\u16c8\u432f\u6877',
  layout: bindGroupLayout3,
  entries: [{binding: 16, resource: {buffer: buffer10, offset: 6400}}],
});
let computePassEncoder44 = commandEncoder40.beginComputePass({label: '\u033f\u08d9\u{1f607}\u090d\u8fa2\ua9e5\ubc47'});
try {
renderBundleEncoder6.setVertexBuffer(6, buffer10, 5_548);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 14400, new DataView(new ArrayBuffer(29977)), 298, 1288);
} catch {}
document.body.append(img0);
let commandEncoder42 = device0.createCommandEncoder({label: '\u0817\u{1fdba}\u4a74\u037b'});
let textureView27 = texture1.createView({mipLevelCount: 1});
let computePassEncoder45 = commandEncoder42.beginComputePass();
try {
computePassEncoder28.setBindGroup(2, bindGroup13);
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 188 widthInBlocks: 47 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 928 */
  offset: 928,
  bytesPerRow: 10240,
  rowsPerImage: 835,
  buffer: buffer19,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
}, {width: 47, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder41.copyTextureToBuffer({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 54, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 392 widthInBlocks: 49 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1200 */
  offset: 1200,
  buffer: buffer10,
}, {width: 49, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder41.copyTextureToTexture({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture13,
  mipLevel: 0,
  origin: {x: 32, y: 6, z: 0},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(25_612).fill(115), /* required buffer size: 25_612 */
{offset: 44, bytesPerRow: 136, rowsPerImage: 94}, {width: 58, height: 0, depthOrArrayLayers: 3});
} catch {}
let commandEncoder43 = device0.createCommandEncoder({label: '\u{1f7b9}\u{1f69b}\u07b7\u{1fc8e}\u1497\u0824'});
let textureView28 = texture33.createView({dimension: 'cube'});
let textureView29 = texture11.createView({arrayLayerCount: 1});
let computePassEncoder46 = commandEncoder43.beginComputePass({});
let renderPassEncoder0 = commandEncoder41.beginRenderPass({colorAttachments: [{view: textureView26, loadOp: 'clear', storeOp: 'store'}]});
try {
renderPassEncoder0.setBindGroup(1, bindGroup12);
} catch {}
try {
renderBundleEncoder5.setVertexBuffer(7, buffer12, 224, 190);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
await gc();
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt2020', transfer: 'smpte240m'} });
let buffer21 = device0.createBuffer({
  label: '\u19fc\u051e\u0230\uab6b\u011a\u05df\ua7c6\u7bda\u0292\u0b5d\u{1fdcc}',
  size: 2690,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let renderBundle5 = renderBundleEncoder5.finish({label: '\u{1fd59}\u07df\ubefc\u0ce5\u4dfa'});
let sampler32 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 76.37,
  lodMaxClamp: 95.77,
  compare: 'less-equal',
});
try {
computePassEncoder5.setBindGroup(0, bindGroup8, new Uint32Array(784), 423, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1, 1); };
} catch {}
try {
computePassEncoder45.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder6.setBindGroup(1, bindGroup2, new Uint32Array(5327), 611, 0);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer21, 'uint32', 432, 124);
} catch {}
try {
buffer3.unmap();
} catch {}
let bindGroup26 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 409, resource: {buffer: buffer2, offset: 1792, size: 5580}}],
});
let buffer22 = device0.createBuffer({
  size: 11869,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder44 = device0.createCommandEncoder({});
let textureView30 = texture30.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 1});
let computePassEncoder47 = commandEncoder44.beginComputePass({});
let renderBundle6 = renderBundleEncoder6.finish({});
try {
renderPassEncoder0.executeBundles([renderBundle6]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(img0);
let bindGroupLayout5 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 156,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let commandEncoder45 = device0.createCommandEncoder({label: '\u7ca8\udd42\u50ea\u{1ffc5}\u0efe'});
let computePassEncoder48 = commandEncoder45.beginComputePass({label: '\u0a98\u{1fa38}\uffec'});
let sampler33 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 84.73,
  lodMaxClamp: 85.50,
  maxAnisotropy: 13,
});
try {
computePassEncoder45.setBindGroup(0, bindGroup13, new Uint32Array(1515), 37, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder34.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer10, 'uint32', 852, 6_275);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 7},
  aspect: 'all',
}, new Uint8Array(7_555).fill(200), /* required buffer size: 7_555 */
{offset: 37, bytesPerRow: 21, rowsPerImage: 179}, {width: 1, height: 0, depthOrArrayLayers: 3});
} catch {}
let textureView31 = texture5.createView({arrayLayerCount: 1});
try {
computePassEncoder31.setBindGroup(0, bindGroup23, new Uint32Array(578), 59, 0);
} catch {}
try {
computePassEncoder33.end();
} catch {}
try {
computePassEncoder47.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer1, 'uint32', 32, 7_906);
} catch {}
try {
commandEncoder30.clearBuffer(buffer4, 8, 996);
} catch {}
let imageBitmap1 = await createImageBitmap(imageData7);
let renderPassEncoder1 = commandEncoder30.beginRenderPass({
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: 274.9, g: 260.5, b: -306.6, a: -830.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 36365979,
});
try {
computePassEncoder27.setBindGroup(0, bindGroup17);
} catch {}
try {
computePassEncoder2.setBindGroup(2, bindGroup23, new Uint32Array(1572), 500, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder39.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup5);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer5, 0, 146);
} catch {}
let commandEncoder46 = device0.createCommandEncoder();
let texture57 = device0.createTexture({
  size: [64, 64, 18],
  mipLevelCount: 1,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder40.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle3]);
} catch {}
let texture58 = device0.createTexture({
  size: [26, 1, 1],
  mipLevelCount: 1,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder42.setBindGroup(3, bindGroup9, new Uint32Array(174), 7, 0);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer18, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer13, 3080, new Int16Array(9066), 867, 868);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture54,
  mipLevel: 2,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(18_075).fill(170), /* required buffer size: 18_075 */
{offset: 35, bytesPerRow: 110, rowsPerImage: 41}, {width: 24, height: 0, depthOrArrayLayers: 5});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 580, height: 48, depthOrArrayLayers: 2}
*/
{
  source: imageData2,
  origin: { x: 4, y: 115 },
  flipY: true,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 43, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 9, height: 1, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder49 = commandEncoder46.beginComputePass({label: '\u8449\u8267\u0cb9\u0e22\ufd99\u0adc\uc992\u7a72'});
try {
computePassEncoder44.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer10, 'uint16', 192, 2_141);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let shaderModule12 = device0.createShaderModule({
  label: '\u{1ff82}\u5948\u0ac9\u6f0b\u8a81\ua4b3\u0e97\u2dcd',
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(184) var tex12: texture_cube<i32>;

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

struct VertexOutput7 {
  @location(6) f30: vec4h,
  @location(8) f31: f32,
  @location(13) @interpolate(linear, sample) f32: vec2h,
  @builtin(position) f33: vec4f,
  @location(9) @interpolate(perspective, sample) f34: f16,
  @location(7) f35: vec4u,
  @location(11) @interpolate(flat, centroid) f36: i32,
  @location(14) f37: vec2f,
  @location(12) @interpolate(linear, centroid) f38: f32,
  @location(5) @interpolate(flat, centroid) f39: i32,
}

struct FragmentOutput8 {
  @location(3) @interpolate(perspective) f0: vec4f,
  @location(2) @interpolate(flat) f1: vec2i,
}

struct FragmentOutput9 {
  @location(0) @interpolate(linear) f0: vec4f,
  @location(4) f1: u32,
}

struct S3 {
  @builtin(front_facing) f0: bool,
}

struct FragmentOutput10 {
  @builtin(sample_mask) f0: u32,
  @location(0) @interpolate(linear) f1: f32,
}

alias vec3b = vec3<bool>;

override override9: bool;

override override10: f16;

@id(10341) override override11: bool;

override override12: bool;

fn fn0() -> mat4x4f {
  var out: mat4x4f;
  vp15[u32(unconst_u32(269))] = vp15[0];
  let ptr84 = &vp15[0];
  out += mat4x4f(f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11));
  var vf259: vec4h = min(vec4h(unconst_f16(6760.2), unconst_f16(4573.3), unconst_f16(480.6), unconst_f16(2319.8)), vec4h(unconst_f16(1018.4), unconst_f16(9741.7), unconst_f16(1238.9), unconst_f16(3491.4)));
  let ptr85: ptr<private, vec3f> = &(*ptr84).whole;
  var vf260: vec3h = fma(vec3h(unconst_f16(4889.4), unconst_f16(1950.1), unconst_f16(4584.7)), vec3h(unconst_f16(5495.3), unconst_f16(3029.2), unconst_f16(2319.3)), vec3h(unconst_f16(1868.0), unconst_f16(6484.0), unconst_f16(3924.5)));
  let vf261: vec3h = reflect(vec3h(unconst_f16(12556.3), unconst_f16(552.0), unconst_f16(26347.4)), vec3h(unconst_f16(6329.3), unconst_f16(3142.5), unconst_f16(5336.2)));
  var vf262: bool = override11;
  var vf263: vec4i = unpack4xI8(u32(unconst_u32(181)));
  return out;
  _ = override11;
}

var<private> vp15 = array(modf(vec3f(0.3464, 0.2617, 0.2201)));

@vertex
fn vertex8(@location(12) a0: vec2i, @location(13) @interpolate(flat, centroid) a1: vec4u) -> VertexOutput7 {
  var out: VertexOutput7;
  let vf264: vec3u = countLeadingZeros(vec3u(unconst_u32(11), unconst_u32(115), unconst_u32(215)));
  var vf265: u32 = pack4xI8(vec4i(unconst_i32(525), unconst_i32(18), unconst_i32(-42), unconst_i32(24)));
  var vf266: vec4f = asin(vec4f(unconst_f32(0.03908), unconst_f32(0.1816), unconst_f32(0.01322), unconst_f32(0.1010)));
  let ptr86: ptr<private, vec3f> = &vp15[bitcast<u32>(a0[u32(unconst_u32(255))])].fract;
  let ptr87 = &vp15[u32(unconst_u32(440))];
  let vf267: vec4u = a1;
  let vf268: f16 = atanh(f16(unconst_f16(-1039.1)));
  let ptr88 = &(*ptr87);
  out.f33 -= vp15[u32(unconst_u32(319))].fract.yxxy;
  vf266 -= vec4f(f32(override11));
  var vf269: vec4f = asin(vec4f(f32(override10)));
  vf265 = pack4xI8Clamp(vec4i(unconst_i32(130), unconst_i32(444), unconst_i32(224), unconst_i32(279)));
  let vf270: bool = override12;
  let ptr89 = &(*ptr88);
  let ptr90: ptr<private, vec3f> = &vp15[0].fract;
  var vf271: f32 = (*ptr90)[u32(unconst_u32(170))];
  vf271 *= f32(vf265);
  out.f38 = min(vec3f(unconst_f32(0.2803), unconst_f32(0.00559), unconst_f32(0.2030)), vec3f(unconst_f32(0.03300), unconst_f32(0.3855), unconst_f32(0.3125))).y;
  vf266 = vec4f(asinh(asinh(f32(unconst_f32(-0.3641)))));
  var vf272: u32 = pack4xI8(vec4i(unconst_i32(243), unconst_i32(-779), unconst_i32(21), unconst_i32(8)));
  var vf273: f32 = asinh(f32(unconst_f32(0.1324)));
  vf272 = bitcast<u32>(vf271);
  return out;
  _ = override10;
  _ = override11;
  _ = override12;
}

@vertex @must_use
fn vertex9(@location(9) @interpolate(flat, sample) a0: vec4u, @location(5) @interpolate(flat) a1: i32) -> @builtin(position) vec4f {
  var out: vec4f;
  out = vec4f(countLeadingZeros(vec2i(unconst_i32(109), unconst_i32(115))).yxyy);
  vp15[u32(unconst_u32(118))] = modf(bitcast<vec3f>(countOneBits(vec2u(unconst_u32(51), unconst_u32(126))).yxy));
  out = vec4f(f32(override11));
  let vf274: vec2u = countOneBits(vec2u(unconst_u32(188), unconst_u32(298)));
  let ptr91 = &vp15[u32(unconst_u32(181))];
  vp15[u32(unconst_u32(224))].fract = vec3f(f32(override10));
  out *= acosh(vec3f(unconst_f32(-0.01682), unconst_f32(0.04392), unconst_f32(0.2705))).grgg;
  vp15[u32(unconst_u32(16))].fract -= vec3f(f32(a0[u32(unconst_u32(66))]));
  var vf275: bool = override12;
  var vf276: vec2f = smoothstep(vec2f(f32(override12)), vec2f(unconst_f32(0.1301), unconst_f32(0.2007)), vec2f(unconst_f32(0.09687), unconst_f32(0.1364)));
  return out;
  _ = override11;
  _ = override12;
  _ = override10;
}

@fragment
fn fragment13() -> FragmentOutput8 {
  var out: FragmentOutput8;
  let vf277: vec4i = unpack4xI8(u32(unconst_u32(14)));
  fn0();
  var vf278 = fn0();
  let vf279: u32 = pack4x8unorm(vec4f(unconst_f32(0.1256), unconst_f32(0.1386), unconst_f32(-1.000), unconst_f32(0.05907)));
  fn0();
  fn0();
  let vf280: vec2u = textureDimensions(tex12);
  vf278 = mat4x4f(vp15[0].whole.ggbg, vp15[0].whole.gbrg, vp15[0].whole.xxzy, vp15[0].whole.yxxx);
  let vf281: f32 = vf278[u32(unconst_u32(28))][u32(unconst_u32(328))];
  discard;
  var vf282: u32 = pack2x16unorm(vec2f(unconst_f32(0.2112), unconst_f32(0.1068)));
  var vf283: bool = override9;
  fn0();
  let vf284: bool = override11;
  let ptr92 = &vp15[0];
  var vf285 = fn0();
  var vf286: f32 = vf278[u32(unconst_u32(16))][u32(unconst_u32(366))];
  vf278 -= mat4x4f(f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11), f32(override11));
  vf278 += mat4x4f(f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283), f32(vf283));
  var vf287 = fn0();
  var vf288 = fn0();
  return out;
  _ = override9;
  _ = override11;
}

@fragment
fn fragment14() -> FragmentOutput9 {
  var out: FragmentOutput9;
  out.f1 = pack2x16unorm(faceForward(vec2f(unconst_f32(0.09309), unconst_f32(0.3015)), vec2f(unconst_f32(-0.04473), unconst_f32(-0.4248)), vec2f(unconst_f32(0.02961), unconst_f32(0.2470))));
  var vf289 = fn0();
  let vf290: vec4h = exp2(vec4h(unconst_f16(865.1), unconst_f16(4331.9), unconst_f16(18011.1), unconst_f16(4143.8)));
  return out;
  _ = override11;
}

@fragment
fn fragment15(a0: S3) -> FragmentOutput10 {
  var out: FragmentOutput10;
  vp15[u32(unconst_u32(40))].fract = vec3f(f32(override10));
  let ptr93: ptr<private, vec3f> = &vp15[0].fract;
  out.f0 = u32(override12);
  var vf291: vec4i = countLeadingZeros(vec4i(unconst_i32(126), unconst_i32(176), unconst_i32(281), unconst_i32(46)));
  out.f1 = f32(a0.f0);
  let vf292: vec4f = step(vec4f(unconst_f32(0.01016), unconst_f32(0.02307), unconst_f32(0.00925), unconst_f32(-0.1034)), vec4f(unconst_f32(0.2981), unconst_f32(0.05092), unconst_f32(0.1183), unconst_f32(0.3674)));
  var vf293: bool = a0.f0;
  fn0();
  var vf294: bool = override12;
  out.f1 = f32(override12);
  vp15[0].fract = vec3f((*ptr93)[u32(unconst_u32(156))]);
  var vf295: u32 = textureNumLevels(tex12);
  var vf296 = fn0();
  fn0();
  out.f0 -= bitcast<u32>(vf291[u32(unconst_u32(44))]);
  fn0();
  vp15[u32(unconst_u32(233))].fract = vec3f(f32(override12));
  let ptr94 = &vp15[0];
  var vf297: vec4f = vf292;
  return out;
  _ = override11;
  _ = override10;
  _ = override12;
}`,
  hints: {},
});
let bindGroup27 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 409, resource: {buffer: buffer22, offset: 512, size: 4704}}],
});
let texture59 = device0.createTexture({
  size: [26, 1, 11],
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView32 = texture15.createView({baseMipLevel: 0, arrayLayerCount: 1});
try {
computePassEncoder5.end();
} catch {}
try {
computePassEncoder43.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup20);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
commandEncoder6.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 5272 */
  offset: 5272,
  bytesPerRow: 2048,
  rowsPerImage: 264,
  buffer: buffer10,
}, {
  texture: texture30,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup28 = device0.createBindGroup({
  label: '\u867b\u0500\u{1fcdc}\u3677\u0b79\ua9c2\ud431\u10a5',
  layout: bindGroupLayout1,
  entries: [
    {binding: 39, resource: textureView1},
    {binding: 124, resource: {buffer: buffer10, offset: 3072, size: 7632}},
    {binding: 120, resource: {buffer: buffer2, offset: 256, size: 71}},
    {binding: 37, resource: {buffer: buffer15, offset: 0}},
    {binding: 357, resource: {buffer: buffer11, offset: 256, size: 440}},
  ],
});
let buffer23 = device0.createBuffer({
  label: '\u4581\u2182\u040b\ua44d\ua8c5\u0425\u080d\u{1faa7}\ud23e',
  size: 14891,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let querySet4 = device0.createQuerySet({type: 'occlusion', count: 860});
let externalTexture3 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'});
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer12, 296); };
} catch {}
try {
commandEncoder6.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 424 */
  offset: 424,
  bytesPerRow: 9984,
  buffer: buffer3,
}, {
  texture: texture16,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder46.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(6, buffer10, 1_716);
} catch {}
try {
commandEncoder6.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 3521 */
  offset: 3521,
  bytesPerRow: 7680,
  buffer: buffer9,
}, {
  texture: texture32,
  mipLevel: 1,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder6.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 6, y: 6, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 180 widthInBlocks: 45 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 432 */
  offset: 432,
  buffer: buffer21,
}, {width: 45, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder6.resolveQuerySet(querySet3, 104, 44, buffer19, 3072);
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
let texture60 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder50 = commandEncoder6.beginComputePass({label: '\u{1f740}\ub200\ue84f\u61fd\u079a\u99e7'});
let sampler34 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 18.79,
  lodMaxClamp: 59.50,
});
let commandEncoder47 = device0.createCommandEncoder({});
let texture61 = device0.createTexture({
  size: [290, 24, 2],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderPassEncoder2 = commandEncoder47.beginRenderPass({
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: -648.2, g: -61.90, b: 800.8, a: 964.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 409236328,
});
try {
computePassEncoder49.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle6, renderBundle6]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer1, 'uint16', 8_062, 8_396);
} catch {}
let commandEncoder48 = device0.createCommandEncoder();
let computePassEncoder51 = commandEncoder48.beginComputePass({});
let sampler35 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.65,
  lodMaxClamp: 99.73,
  maxAnisotropy: 3,
});
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder32.end();
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup12, []);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup19, new Uint32Array(544), 47, 0);
} catch {}
try {
commandEncoder12.copyTextureToTexture({
  texture: texture35,
  mipLevel: 1,
  origin: {x: 29, y: 2, z: 1},
  aspect: 'all',
},
{
  texture: texture34,
  mipLevel: 0,
  origin: {x: 61, y: 0, z: 0},
  aspect: 'all',
},
{width: 43, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData11 = new ImageData(40, 44);
let bindGroup29 = device0.createBindGroup({
  label: '\uc24a\u5a8a\uf7ce\u{1febc}\u49ca\u{1ff04}\u0d75\u034f\u2c95',
  layout: bindGroupLayout3,
  entries: [{binding: 16, resource: {buffer: buffer11, offset: 256, size: 880}}],
});
let commandEncoder49 = device0.createCommandEncoder({});
let computePassEncoder52 = commandEncoder12.beginComputePass({});
let renderPassEncoder3 = commandEncoder49.beginRenderPass({
  label: '\u0918\u3187\u7bc7\u9f15',
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: 418.4, g: -848.9, b: 876.8, a: -271.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder44.setBindGroup(1, bindGroup18);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(1, 2); };
} catch {}
try {
computePassEncoder52.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer8, 40);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: imageData8,
  origin: { x: 0, y: 8 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 100, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture62 = device0.createTexture({
  size: [290, 24, 2],
  mipLevelCount: 2,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder22.end();
} catch {}
try {
computePassEncoder50.setPipeline(pipeline0);
} catch {}
let buffer24 = device0.createBuffer({
  size: 10582,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let renderPassEncoder4 = commandEncoder8.beginRenderPass({
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: 475.2, g: -110.9, b: 784.5, a: -503.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 17627871,
});
let sampler36 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 77.30,
  lodMaxClamp: 90.82,
});
try {
computePassEncoder51.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup23, new Uint32Array(310), 96, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer14, 'uint16', 1_600, 6_583);
} catch {}
let bindGroup30 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView24}]});
let texture63 = device0.createTexture({
  size: [145, 12, 222],
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder2.beginOcclusionQuery(127);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer6, 'uint16', 5_678, 37);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 7, y: 15, z: 6},
  aspect: 'all',
}, new Uint8Array(26_642).fill(100), /* required buffer size: 26_642 */
{offset: 220, bytesPerRow: 93, rowsPerImage: 38}, {width: 5, height: 19, depthOrArrayLayers: 8});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture64 = device0.createTexture({
  size: {width: 64},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let sampler37 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 23.05,
  lodMaxClamp: 67.71,
});
try {
renderPassEncoder4.setVertexBuffer(0, buffer8, 36);
} catch {}
let commandEncoder50 = device0.createCommandEncoder({});
let texture65 = device0.createTexture({
  size: {width: 145, height: 12, depthOrArrayLayers: 2},
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView33 = texture36.createView({dimension: '1d'});
try {
commandEncoder50.copyBufferToTexture({
  /* bytesInLastRow: 464 widthInBlocks: 116 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 332 */
  offset: 332,
  bytesPerRow: 9472,
  rowsPerImage: 1253,
  buffer: buffer23,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 43, y: 0, z: 0},
  aspect: 'all',
}, {width: 116, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder53 = commandEncoder50.beginComputePass({label: '\u{1f927}\u{1fd13}\u{1f8fb}\ua7a5\u{1f6aa}\u{1fc70}\u01d1\u0dea\uaa53'});
try {
computePassEncoder17.setBindGroup(0, bindGroup20, new Uint32Array(520), 60, 0);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(3, buffer5, 40);
} catch {}
let bindGroup31 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 16, resource: {buffer: buffer22, offset: 2560, size: 1220}}],
});
let textureView34 = texture40.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder1.setBindGroup(0, bindGroup10);
} catch {}
try {
computePassEncoder40.setBindGroup(3, bindGroup13, new Uint32Array(6024), 1_685, 0);
} catch {}
try {
computePassEncoder27.end();
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup31, new Uint32Array(160), 1, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer12, 'uint32', 200, 2);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
buffer16.unmap();
} catch {}
try {
commandEncoder25.copyTextureToBuffer({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 4},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 416 */
  offset: 416,
  bytesPerRow: 768,
  buffer: buffer18,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup32 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 409, resource: {buffer: buffer2, offset: 256, size: 4548}}],
});
let buffer25 = device0.createBuffer({
  size: 305,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder51 = device0.createCommandEncoder({});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], depthReadOnly: true});
let renderBundle7 = renderBundleEncoder7.finish({});
try {
computePassEncoder42.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder6.setBindGroup(1, bindGroup32, new Uint32Array(2048), 183, 0);
} catch {}
try {
computePassEncoder53.setPipeline(pipeline2);
} catch {}
try {
commandEncoder51.copyBufferToTexture({
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 308 */
  offset: 308,
  bytesPerRow: 9472,
  buffer: buffer2,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 51, y: 4, z: 0},
  aspect: 'all',
}, {width: 15, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let bindGroup33 = device0.createBindGroup({
  label: '\u{1fb46}\u076f',
  layout: bindGroupLayout5,
  entries: [{binding: 156, resource: textureView23}],
});
let buffer26 = device0.createBuffer({
  size: 1960,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let computePassEncoder54 = commandEncoder25.beginComputePass({});
let renderPassEncoder5 = commandEncoder51.beginRenderPass({
  label: '\u000f\u{1fb86}\u7dc2',
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: 350.8, g: 254.7, b: 446.9, a: 983.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler38 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 3.477,
  compare: 'less-equal',
  maxAnisotropy: 5,
});
try {
computePassEncoder38.setBindGroup(0, bindGroup32, new Uint32Array(693), 137, 0);
} catch {}
try {
computePassEncoder54.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup31, new Uint32Array(3797), 3_472, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer18, 1_380, 8_404);
} catch {}
try {
buffer14.unmap();
} catch {}
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer27 = device0.createBuffer({
  size: 422,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView35 = texture10.createView({label: '\ua1b6\udac1'});
let sampler39 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 97.07,
  lodMaxClamp: 97.57,
});
try {
renderPassEncoder5.setBindGroup(0, bindGroup19, new Uint32Array(3317), 274, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer15, 'uint16', 1_748, 526);
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.prepend(img0);
let commandEncoder52 = device0.createCommandEncoder({});
try {
renderPassEncoder5.setIndexBuffer(buffer24, 'uint16', 2_494, 111);
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 224 widthInBlocks: 56 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 760 */
  offset: 760,
  buffer: buffer11,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, {width: 56, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder52.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture51,
  mipLevel: 0,
  origin: {x: 81, y: 4, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: videoFrame0,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 49, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer28 = device0.createBuffer({
  label: '\u{1fd57}\u3e9f',
  size: 9605,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let sampler40 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 72.35,
  compare: 'less',
});
try {
computePassEncoder38.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup30, new Uint32Array(600), 296, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer15, 'uint32', 1_200, 19);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(334).fill(102), /* required buffer size: 334 */
{offset: 334, rowsPerImage: 8}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder53 = device0.createCommandEncoder();
let sampler41 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 30.34,
  lodMaxClamp: 34.60,
  maxAnisotropy: 1,
});
try {
renderPassEncoder5.setBindGroup(1, bindGroup22, new Uint32Array(1088), 226, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder3.setViewport(14.880787447148947, 0.4294487476302705, 6.142642147250911, 0.2568185863694719, 0.30747578663234854, 0.867008276030375);
} catch {}
let buffer29 = device0.createBuffer({
  label: '\u{1fdda}\u2d1b',
  size: 8874,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder54 = device0.createCommandEncoder({label: '\u0a2a\u3c40\uf812\u0245\u7fbf\ue26e'});
let texture66 = device0.createTexture({
  size: {width: 290, height: 24, depthOrArrayLayers: 2},
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView36 = texture45.createView({});
let renderPassEncoder6 = commandEncoder54.beginRenderPass({
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: -471.7, g: -605.5, b: -725.1, a: -158.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 884192,
});
try {
renderPassEncoder5.setBlendConstant({ r: 526.4, g: -597.1, b: 221.0, a: 364.2, });
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer14, 'uint16', 8_662, 8_251);
} catch {}
try {
device0.queue.writeBuffer(buffer21, 248, new BigUint64Array(26142), 4307, 64);
} catch {}
let texture67 = device0.createTexture({
  size: {width: 105, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
});
let sampler42 = device0.createSampler({
  label: '\ud38c\u{1fff0}\ue49d\u{1fabe}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 97.73,
  lodMaxClamp: 98.96,
});
let externalTexture4 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
try {
renderPassEncoder2.setBindGroup(1, bindGroup23, new Uint32Array(4565), 2_143, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer12, 'uint32', 40, 66);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 4}
*/
{
  source: imageData11,
  origin: { x: 9, y: 2 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame7 = new VideoFrame(videoFrame3, {timestamp: 0});
let buffer30 = device0.createBuffer({size: 771, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE});
let commandEncoder55 = device0.createCommandEncoder({label: '\u0339\u8ae8\ue7c7\u2de4\u8c2d\u2952\u{1f605}\ue4b2\u6883'});
let computePassEncoder55 = commandEncoder53.beginComputePass({});
let sampler43 = device0.createSampler({
  label: '\u0958\u0e21\u31d1\uf094\u04c2\u67d9',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 89.34,
  lodMaxClamp: 99.70,
  maxAnisotropy: 11,
});
let externalTexture5 = device0.importExternalTexture({source: videoFrame7});
try {
{ clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder38.dispatchWorkgroupsIndirect(buffer14, 4_588);
} catch {}
try {
computePassEncoder55.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder2.setScissorRect(5, 0, 2, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer21, 'uint16', 84, 916);
} catch {}
try {
commandEncoder55.clearBuffer(buffer14, 4852, 6284);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await promise3;
} catch {}
await gc();
let bindGroup34 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 156, resource: textureView19}]});
let buffer31 = device0.createBuffer({
  label: '\u074a\u0263\u73ea\u{1f886}\ub422\ub1ab',
  size: 1427,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder56 = device0.createCommandEncoder({label: '\u8092\uc4e2\u8db1\u4f34\u0191\ubc3b\u{1fd1e}\uc651\u0389\u20ec\u{1fda7}'});
let computePassEncoder56 = commandEncoder52.beginComputePass({});
let sampler44 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 15.06,
  lodMaxClamp: 56.46,
  maxAnisotropy: 1,
});
try {
{ clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder56.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup30, new Uint32Array(2173), 689, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 580, height: 48, depthOrArrayLayers: 2}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 25, y: 2, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData12 = new ImageData(32, 12);
let texture68 = device0.createTexture({
  size: [26],
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder57 = commandEncoder56.beginComputePass();
try {
computePassEncoder44.setBindGroup(2, bindGroup10, []);
} catch {}
try {
computePassEncoder38.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer21, 'uint32', 1_392, 413);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder57 = device0.createCommandEncoder();
let texture69 = device0.createTexture({
  label: '\u0c83\udbed\u{1fd7b}\u8c4f\u{1fb56}\u{1f70c}\u7535',
  size: {width: 580, height: 48, depthOrArrayLayers: 2},
  mipLevelCount: 1,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let computePassEncoder58 = commandEncoder57.beginComputePass({});
try {
computePassEncoder52.setBindGroup(0, bindGroup2);
} catch {}
let videoFrame8 = new VideoFrame(img0, {timestamp: 0});
let buffer32 = device0.createBuffer({
  label: '\u{1f8de}\u{1f6bf}\u47ce\u{1fec2}\uea9f\ubda0\uaedc\u0e21',
  size: 15947,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder59 = commandEncoder55.beginComputePass({});
let sampler45 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 26.99,
  lodMaxClamp: 77.33,
  maxAnisotropy: 1,
});
try {
computePassEncoder38.end();
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup28, new Uint32Array(50), 19, 0);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(2, buffer2, 836, 66);
} catch {}
try {
commandEncoder36.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 12 */
  offset: 12,
  bytesPerRow: 18944,
  buffer: buffer27,
}, {
  texture: texture0,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture70 = device0.createTexture({
  label: '\ua7f3\uee57\u207e\ufec6\u05e0',
  size: [64, 64, 18],
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView37 = texture68.createView({});
let renderPassEncoder7 = commandEncoder36.beginRenderPass({
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: 707.2, g: -638.8, b: 236.7, a: 649.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 228738536,
});
let sampler46 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 53.06,
  lodMaxClamp: 86.32,
  maxAnisotropy: 15,
});
try {
{ clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroupsIndirect(buffer22, 1_376); };
} catch {}
try {
computePassEncoder57.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer15, 'uint32', 680, 13);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer27, 156, 9);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 1,
  origin: {x: 6, y: 4, z: 0},
  aspect: 'all',
}, new Uint8Array(156).fill(0), /* required buffer size: 156 */
{offset: 156, rowsPerImage: 100}, {width: 33, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: videoFrame8,
  origin: { x: 1, y: 5 },
  flipY: false,
}, {
  texture: texture65,
  mipLevel: 0,
  origin: {x: 30, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup35 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 16, resource: {buffer: buffer10, offset: 1792}}]});
let buffer33 = device0.createBuffer({
  label: '\u0be4\u{1fdb1}\ub03a\u6c47',
  size: 26078,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder58 = device0.createCommandEncoder({});
let texture71 = device0.createTexture({
  label: '\u{1fa03}\u0fba\ue786',
  size: [145, 12, 22],
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView38 = texture39.createView({});
let computePassEncoder60 = commandEncoder58.beginComputePass({label: '\u8b76\u{1f62a}\u700f'});
try {
computePassEncoder29.setBindGroup(2, bindGroup26);
} catch {}
try {
computePassEncoder57.setBindGroup(1, bindGroup15, new Uint32Array(69), 27, 0);
} catch {}
try {
computePassEncoder52.end();
} catch {}
try {
computePassEncoder59.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup3, new Uint32Array(378), 15, 0);
} catch {}
let texture72 = device0.createTexture({
  size: [52, 1, 1],
  mipLevelCount: 2,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderPassEncoder8 = commandEncoder12.beginRenderPass({
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: 337.2, g: 689.0, b: 613.0, a: 439.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder51.setBindGroup(0, bindGroup20, new Uint32Array(468), 44, 0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup8, new Uint32Array(268), 51, 0);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle3]);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(293, 72);
let bindGroup36 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView2}]});
let textureView39 = texture26.createView({arrayLayerCount: 1});
try {
computePassEncoder42.setBindGroup(3, bindGroup34);
} catch {}
try {
computePassEncoder60.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup18, new Uint32Array(3686), 142, 0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer29, 'uint32', 368, 3_378);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 192, new Float32Array(11883), 396, 180);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 18}
*/
{
  source: imageData6,
  origin: { x: 9, y: 1 },
  flipY: true,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 11},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 4, depthOrArrayLayers: 0});
} catch {}
let bindGroup37 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 16, resource: {buffer: buffer26, offset: 0}}]});
let commandEncoder59 = device0.createCommandEncoder({});
let renderPassEncoder9 = commandEncoder59.beginRenderPass({
  colorAttachments: [{
  view: textureView23,
  clearValue: { r: -903.4, g: -793.7, b: -813.8, a: 212.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet3,
});
try {
computePassEncoder58.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder6.setScissorRect(9, 0, 4, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer18, 224, 1_018);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer15, 316, new BigUint64Array(4540), 564, 92);
} catch {}
offscreenCanvas0.height = 1146;
let commandEncoder60 = device0.createCommandEncoder();
try {
computePassEncoder54.setBindGroup(2, bindGroup19);
} catch {}
try {
computePassEncoder21.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder1.setStencilReference(552);
} catch {}
let promise4 = shaderModule6.getCompilationInfo();
try {
buffer20.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture32,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(715).fill(250), /* required buffer size: 715 */
{offset: 715, bytesPerRow: 12}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu');
await gc();
let computePassEncoder61 = commandEncoder60.beginComputePass({});
let sampler47 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 64.24,
  lodMaxClamp: 76.81,
});
try {
computePassEncoder41.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder61.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup34);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup20, new Uint32Array(1904), 657, 0);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(5, buffer27);
} catch {}
try {
device0.queue.writeBuffer(buffer4, 628, new BigUint64Array(7795), 823, 32);
} catch {}
try {
computePassEncoder55.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, undefined, 432_124_033);
} catch {}
document.body.prepend(img0);
try {
renderPassEncoder9.beginOcclusionQuery(43);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer28, 'uint32', 1_616, 456);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
let imageData13 = new ImageData(36, 60);
let commandEncoder61 = device0.createCommandEncoder({});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['r16float'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true});
let externalTexture6 = device0.importExternalTexture({source: videoFrame7});
try {
renderPassEncoder9.setBindGroup(0, bindGroup37, new Uint32Array(2682), 1_668, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle3, renderBundle3, renderBundle6, renderBundle6, renderBundle3, renderBundle3, renderBundle6]);
} catch {}
try {
renderBundleEncoder8.setIndexBuffer(buffer29, 'uint32', 2_628, 1_311);
} catch {}
try {
renderBundleEncoder8.setVertexBuffer(0, buffer19, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 351, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(355).fill(142), /* required buffer size: 355 */
{offset: 355, rowsPerImage: 2}, {width: 207, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
let bindGroup38 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 39, resource: textureView1},
    {binding: 120, resource: {buffer: buffer24, offset: 512, size: 2344}},
    {binding: 357, resource: {buffer: buffer4, offset: 256, size: 776}},
    {binding: 37, resource: {buffer: buffer32, offset: 1280, size: 4709}},
    {binding: 124, resource: {buffer: buffer33, offset: 256, size: 12224}},
  ],
});
let buffer34 = device0.createBuffer({
  size: 11256,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder62 = device0.createCommandEncoder({});
let texture73 = device0.createTexture({
  size: [1160, 96, 2],
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle8 = renderBundleEncoder8.finish({});
let sampler48 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'clamp-to-edge', lodMaxClamp: 71.38});
try {
renderPassEncoder2.setBindGroup(2, bindGroup23, new Uint32Array(964), 157, 0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer6, 'uint32', 2_364, 486);
} catch {}
try {
commandEncoder61.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture51,
  mipLevel: 0,
  origin: {x: 130, y: 3, z: 0},
  aspect: 'all',
},
{width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 1, depthOrArrayLayers: 4}
*/
{
  source: img0,
  origin: { x: 4, y: 0 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView40 = texture19.createView({arrayLayerCount: 1});
let computePassEncoder62 = commandEncoder61.beginComputePass({label: '\ua373\u08e7\ub61d\u7953\u65f9\u{1f7c9}\u7710\u3d07\ud865\u8e39\u57e3'});
try {
computePassEncoder62.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer25, 'uint16', 68, 156);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await promise4;
} catch {}
let videoFrame9 = videoFrame4.clone();
let computePassEncoder63 = commandEncoder62.beginComputePass({});
try {
computePassEncoder25.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setBlendConstant({ r: 618.5, g: -239.1, b: 553.3, a: 830.4, });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: imageData11,
  origin: { x: 10, y: 3 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 9, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise6;
} catch {}
let imageData14 = new ImageData(52, 128);
let shaderModule13 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

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

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

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

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

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

@group(0) @binding(184) var tex13: texture_cube<i32>;

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

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

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

struct FragmentOutput11 {
  @location(4) @interpolate(flat) f0: i32,
  @location(0) f1: vec4f,
}

alias vec3b = vec3<bool>;

fn fn0() -> array<array<array<array<FragmentOutput11, 1>, 1>, 1>, 1> {
  var out: array<array<array<array<FragmentOutput11, 1>, 1>, 1>, 1>;
  vp17[0].f1 -= vec4f(vp17[vec2u(vp16[u32(unconst_u32(2))]).y].f1[u32(unconst_u32(100))]);
  vp17[0] = FragmentOutput11(i32(vp16[0][u32(vp16[0][u32(unconst_u32(64))])]), vec4f(f32(vp16[0][u32(vp16[0][u32(unconst_u32(64))])])));
  let vf298: bool = any(bool(unconst_bool(false)));
  let ptr95: ptr<private, vec2<bool>> = &vp16[0];
  vp17[u32(unconst_u32(166))] = FragmentOutput11(vec2i(acosh(vec2f(unconst_f32(-0.3372), unconst_f32(0.2451))))[0], acosh(vec2f(unconst_f32(-0.3372), unconst_f32(0.2451))).xyyy);
  let ptr96: ptr<private, i32> = &vp17[0].f0;
  var vf299: f16 = tanh(f16(unconst_f16(17564.1)));
  out[u32(unconst_u32(88))][u32(unconst_u32(5))][u32(unconst_u32(615))][u32(unconst_u32(225))] = FragmentOutput11(vec4i(vp17[0].f1).y, vp17[0].f1);
  let ptr97: ptr<private, vec2<bool>> = &vp16[u32(unconst_u32(345))];
  let ptr98: ptr<private, vec2<bool>> = &vp16[0];
  out[0][u32(unconst_u32(7))][u32(sign(vec4h(unconst_f16(1536.1), unconst_f16(36844.5), unconst_f16(27541.3), unconst_f16(3307.6))).g)][u32(unconst_u32(151))] = FragmentOutput11(vec2i(acosh(vec2f(unconst_f32(0.1479), unconst_f32(0.3321)))).x, acosh(vec2f(unconst_f32(0.1479), unconst_f32(0.3321))).rgrr);
  var vf300: vec4i = unpack4xI8(u32(unconst_u32(47)));
  var vf301: f32 = asin(f32(unconst_f32(0.1491)));
  return out;
}

var<private> vp16: array<vec2<bool>, 1> = array<vec2<bool>, 1>(vec2<bool>(false, false));

var<private> vp17: array<FragmentOutput11, 1> = array(FragmentOutput11());

@fragment
fn fragment16() -> FragmentOutput11 {
  var out: FragmentOutput11;
  var vf302: f32 = atan2(f32(unconst_f32(0.7769)), f32(unconst_f32(0.02330)));
  var vf303: f16 = trunc(f16(unconst_f16(14603.8)));
  out.f1 += vec4f(f32(vf303));
  out.f0 += i32(vp16[0][vec2u(vp16[u32(unconst_u32(317))])[0]]);
  out.f1 -= vec4f(vp16[0].grrg);
  out.f0 ^= vec2i(textureDimensions(tex13, i32(unconst_i32(327))))[1];
  let ptr99: ptr<private, vec4f> = &vp17[0].f1;
  let ptr100: ptr<private, array<FragmentOutput11, 1>> = &vp17;
  let vf304: f16 = trunc(f16(unconst_f16(4924.1)));
  out.f1 = vec4f(f32((*ptr100)[u32(unconst_u32(162))].f0));
  let ptr101: ptr<private, array<FragmentOutput11, 1>> = &(*ptr100);
  let ptr102: ptr<private, vec4f> = &(*ptr100)[0].f1;
  vp17[u32(unconst_u32(54))].f1 = vp17[0].f1;
  vf303 *= f16((*ptr101)[0].f0);
  let ptr103: ptr<private, vec2<bool>> = &vp16[0];
  let ptr104: ptr<private, FragmentOutput11> = &(*ptr101)[0];
  let ptr105: ptr<private, i32> = &(*ptr101)[u32(unconst_u32(251))].f0;
  let vf305: mat3x2f = transpose(mat2x3f(unconst_f32(-0.07517), unconst_f32(0.02727), unconst_f32(0.1345), unconst_f32(0.08302), unconst_f32(0.5294), unconst_f32(0.03885)));
  out.f0 = vec2i(vf305[unconst_i32(0)]).g;
  out.f1 += transpose(mat2x3f(unconst_f32(0.1556), unconst_f32(0.6701), unconst_f32(0.01738), unconst_f32(0.1217), unconst_f32(0.2098), unconst_f32(0.01222)))[unconst_i32(0)].xyyy;
  vf303 += f16(all(vp16[0]));
  let ptr106: ptr<private, i32> = &(*ptr105);
  vf303 += f16(dot4I8Packed(u32(unconst_u32(209)), u32(unconst_u32(206))));
  vf303 -= f16(reverseBits(i32(unconst_i32(624))));
  let vf306: vec2f = sign(vec2f(unconst_f32(0.05014), unconst_f32(0.03414)));
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder63 = device0.createCommandEncoder({});
let texture74 = device0.createTexture({
  label: '\ufbd7\u{1fb85}\u0b21\u{1f6cb}\u6e1a\u017b\ua26c\u0a86\u0d45\u{1fbec}',
  size: [1160, 96, 6],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder64 = commandEncoder63.beginComputePass({label: '\uaf4b\u81ea\u{1facb}\u0135\u01c1'});
let sampler49 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 81.79,
  lodMaxClamp: 91.17,
  maxAnisotropy: 16,
});
try {
renderPassEncoder9.setBindGroup(3, bindGroup37, new Uint32Array(1383), 388, 0);
} catch {}
document.body.prepend(img0);
let commandEncoder64 = device0.createCommandEncoder({label: '\u548d\ua9e4\u0187\u{1fcf0}\u3dde'});
let texture75 = device0.createTexture({
  size: [26, 1, 47],
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let texture76 = gpuCanvasContext0.getCurrentTexture();
let textureView41 = texture64.createView({});
let renderPassEncoder10 = commandEncoder64.beginRenderPass({
  label: '\u{1f9e3}\u{1f76d}\u444e\u6fed\uaae7',
  colorAttachments: [{view: textureView39, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet4,
  maxDrawCount: 110345354,
});
let sampler50 = device0.createSampler({
  label: '\uf6ba\u{1fb02}\u49dc\u2f06\u3066\u02b6\u76cb\u097a\u{1f9fb}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 22.51,
  lodMaxClamp: 25.51,
  compare: 'never',
});
try {
computePassEncoder4.setBindGroup(0, bindGroup5, new Uint32Array(15), 0, 0);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder64.setPipeline(pipeline2);
} catch {}
try {
  await promise5;
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder5.insertDebugMarker('\u{1ff64}');
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder65 = device0.createCommandEncoder({});
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 172});
let texture77 = device0.createTexture({
  size: [290, 24, 71],
  sampleCount: 1,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture7 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder39.setBindGroup(2, bindGroup20);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder1.setViewport(1.6350962549990709, 0.6760438757686588, 6.568725866389455, 0.03589267592813013, 0.8935689256558463, 0.9073663895897218);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer25, 'uint32', 8, 16);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer35 = device0.createBuffer({
  size: 4437,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let texture78 = device0.createTexture({
  label: '\u2981\u6c65\u{1f7a1}\u01dc\u804a',
  size: [64, 64, 18],
  mipLevelCount: 1,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView42 = texture22.createView({dimension: '2d', mipLevelCount: 1});
let computePassEncoder65 = commandEncoder65.beginComputePass();
try {
computePassEncoder45.setBindGroup(3, bindGroup32);
} catch {}
try {
computePassEncoder65.setPipeline(pipeline0);
} catch {}
try {
buffer7.unmap();
} catch {}
let bindGroup39 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 409, resource: {buffer: buffer32, offset: 2304, size: 6418}}],
});
let commandEncoder66 = device0.createCommandEncoder({});
let texture79 = device0.createTexture({size: [52, 1, 24], sampleCount: 1, dimension: '2d', format: 'r16float', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder66 = commandEncoder66.beginComputePass({});
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 67, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise7;
} catch {}
let buffer36 = device0.createBuffer({size: 32504, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView43 = texture36.createView({label: '\u001f\u{1ffa0}\u0120\ufaf9\u073d\u{1fb8b}\u0f43', aspect: 'all', arrayLayerCount: 1});
try {
computePassEncoder45.setBindGroup(1, bindGroup38, new Uint32Array(3816), 557, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle3, renderBundle8, renderBundle8, renderBundle6]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer21, 'uint16', 762, 401);
} catch {}
let buffer37 = device0.createBuffer({
  size: 2886,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let sampler51 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 61.28,
  lodMaxClamp: 64.45,
});
try {
computePassEncoder4.setBindGroup(2, bindGroup7, new Uint32Array(39), 3, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(3); };
} catch {}
try {
computePassEncoder62.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder66.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup31);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle8]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer14, 'uint16', 1_288, 4_948);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 3012, new DataView(new ArrayBuffer(20340)), 18775, 492);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(42).fill(113), /* required buffer size: 42 */
{offset: 42}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder67 = device0.createCommandEncoder({});
let computePassEncoder67 = commandEncoder67.beginComputePass();
try {
computePassEncoder61.setBindGroup(3, bindGroup9);
} catch {}
try {
computePassEncoder67.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup22, new Uint32Array(2713), 1_289, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder1.setViewport(14.784493547468493, 0.8028277142410148, 7.933032504179139, 0.14584956512592115, 0.08792739127712679, 0.48692755693728584);
} catch {}
try {
buffer20.unmap();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(3_152).fill(66), /* required buffer size: 3_152 */
{offset: 160, bytesPerRow: 44, rowsPerImage: 34}, {width: 2, height: 0, depthOrArrayLayers: 3});
} catch {}
let textureView44 = texture22.createView({dimension: '2d', format: 'rgba32sint'});
try {
renderPassEncoder0.setBindGroup(2, bindGroup30);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup27, new Uint32Array(2247), 5, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 3432, new Float32Array(10712), 3833, 2320);
} catch {}
let buffer38 = device0.createBuffer({size: 9016, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE});
let externalTexture8 = device0.importExternalTexture({label: '\u02e7\u0518\u0b5b\uc0d5\u{1ff28}\u{1fa28}\u6060\u08b0\u0201\u7022', source: videoFrame9});
try {
renderPassEncoder8.setBindGroup(0, bindGroup33, new Uint32Array(2438), 419, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 580, height: 48, depthOrArrayLayers: 2}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 1, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup40 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 409, resource: {buffer: buffer32, offset: 256, size: 6306}}],
});
let sampler52 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 84.40,
  lodMaxClamp: 98.68,
  compare: 'equal',
});
try {
computePassEncoder18.setBindGroup(0, bindGroup22);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer4, 248); };
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup11);
} catch {}
let texture80 = device0.createTexture({
  label: '\u0be1\u0881\u2309\u1952\u{1ff9b}\u{1f67b}\u0ca3\u1a4d\u{1fcbd}\u0f0a',
  size: [1160, 96, 2],
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder19.setBindGroup(0, bindGroup22);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroupsIndirect(buffer12, 80); };
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup11, new Uint32Array(236), 31, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle8, renderBundle6, renderBundle8]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer28, 'uint32', 832, 1_193);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 1, depthOrArrayLayers: 4}
*/
{
  source: imageData13,
  origin: { x: 3, y: 34 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'smpteRp431', transfer: 'gamma28curve'} });
let buffer39 = device0.createBuffer({size: 15744, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let commandEncoder68 = device0.createCommandEncoder({});
let texture81 = device0.createTexture({
  size: [105, 1, 39],
  mipLevelCount: 5,
  sampleCount: 1,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView45 = texture68.createView({label: '\u05ae\u8823\u7ec9\u9b7d\u4238', format: 'rgba8unorm-srgb'});
let sampler53 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 25.48,
  lodMaxClamp: 64.45,
  compare: 'greater-equal',
});
try {
computePassEncoder46.setBindGroup(3, bindGroup15);
} catch {}
try {
computePassEncoder48.setBindGroup(3, bindGroup33, new Uint32Array(508), 25, 0);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup39, new Uint32Array(415), 16, 0);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle8, renderBundle3]);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
commandEncoder68.clearBuffer(buffer24, 1628, 7340);
} catch {}
try {
commandEncoder68.resolveQuerySet(querySet2, 1, 11, buffer6, 768);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 1, depthOrArrayLayers: 4}
*/
{
  source: imageBitmap1,
  origin: { x: 4, y: 4 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder68 = commandEncoder68.beginComputePass({label: '\u0507\ub778'});
try {
renderPassEncoder9.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer14, 'uint16', 6_828, 163);
} catch {}
try {
device0.queue.writeBuffer(buffer32, 4304, new BigUint64Array(4568), 1355, 212);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(img0);
let imageBitmap2 = await createImageBitmap(videoFrame6);
try {
sampler47.label = '\u1a87\u3a28\u{1fccc}\ub556\uf28e\u02e8\u{1fd7c}\ue298\u4db6';
} catch {}
let commandEncoder69 = device0.createCommandEncoder({});
let texture82 = device0.createTexture({
  size: {width: 580, height: 48, depthOrArrayLayers: 58},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView46 = texture43.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder69 = commandEncoder69.beginComputePass({label: '\u8178\u001e\u3dd6\u0bec\u04a8\u041f\u00ec'});
try {
computePassEncoder69.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle8, renderBundle8, renderBundle8, renderBundle8, renderBundle8, renderBundle8, renderBundle8]);
} catch {}
let textureView47 = texture46.createView({
  label: '\u4b11\u0bac\ub500\u0756\u{1fded}\u09ea\u1068\u5244\ua44e',
  format: 'r16float',
  arrayLayerCount: 1,
});
try {
computePassEncoder62.setBindGroup(2, bindGroup21, new Uint32Array(762), 161, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroupsIndirect(buffer26, 120); };
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup37);
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 293, height: 1146, depthOrArrayLayers: 1}
*/
{
  source: videoFrame8,
  origin: { x: 3, y: 19 },
  flipY: true,
}, {
  texture: texture76,
  mipLevel: 0,
  origin: {x: 45, y: 268, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 12, depthOrArrayLayers: 0});
} catch {}
let commandEncoder70 = device0.createCommandEncoder({});
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 848});
let renderPassEncoder11 = commandEncoder70.beginRenderPass({
  colorAttachments: [{view: textureView39, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet6,
});
try {
computePassEncoder48.setBindGroup(2, bindGroup34);
} catch {}
try {
computePassEncoder68.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup21, new Uint32Array(60), 48, 0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle7, renderBundle7]);
} catch {}
let textureView48 = texture18.createView({dimension: '2d'});
try {
renderPassEncoder5.setStencilReference(1335);
} catch {}
let imageData15 = new ImageData(4, 24);
let buffer40 = device0.createBuffer({size: 10699, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT});
let commandEncoder71 = device0.createCommandEncoder({});
let textureView49 = texture43.createView({format: 'rgba8unorm-srgb', mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder39.setBindGroup(2, bindGroup24);
} catch {}
try {
computePassEncoder39.setBindGroup(3, bindGroup31, new Uint32Array(5054), 992, 0);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(2, buffer5, 124, 107);
} catch {}
try {
commandEncoder71.copyBufferToTexture({
  /* bytesInLastRow: 684 widthInBlocks: 171 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 980 */
  offset: 980,
  bytesPerRow: 4864,
  buffer: buffer19,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
}, {width: 171, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
let textureView50 = texture46.createView({label: '\u{1f726}\u034e\ucefe\u{1f8f2}\u{1f91a}', arrayLayerCount: 1});
let sampler54 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 91.48,
  lodMaxClamp: 93.95,
});
try {
renderPassEncoder4.setBindGroup(1, bindGroup12);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup17, new Uint32Array(151), 3, 0);
} catch {}
try {
commandEncoder71.copyTextureToTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture59,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 2},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer41 = device0.createBuffer({
  size: 20356,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder72 = device0.createCommandEncoder();
let textureView51 = texture48.createView({});
let computePassEncoder70 = commandEncoder71.beginComputePass({});
let renderPassEncoder12 = commandEncoder72.beginRenderPass({
  colorAttachments: [{view: textureView23, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet2,
});
try {
renderPassEncoder2.setBindGroup(1, bindGroup31, new Uint32Array(1152), 192, 0);
} catch {}
try {
renderPassEncoder9.setScissorRect(3, 0, 6, 0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer5, 'uint32', 24, 64);
} catch {}
let shaderModule14 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

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

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

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

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

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

@group(0) @binding(184) var tex14: texture_cube<i32>;

struct T0 {
  @size(1024) f0: vec4f,
}

var<workgroup> vw38: mat4x2h;

var<workgroup> vw39: atomic<i32>;

var<workgroup> vw40: array<f16, 12>;

var<workgroup> vw41: atomic<i32>;

@vertex
fn vertex10() -> @builtin(position) vec4f {
  var out: vec4f;
  out = bitcast<vec4f>(reverseBits(vec2u(unconst_u32(739), unconst_u32(13))).rrgr);
  let vf307: vec2f = unpack2x16float(u32(unconst_u32(108)));
  out += cross(vec3f(vf307[bitcast<u32>(vf307[1])]), vec3f(unconst_f32(0.3946), unconst_f32(0.5843), unconst_f32(0.00324))).rgrb;
  var vf308: vec2h = min(vec2h(unconst_f16(16398.7), unconst_f16(5262.3)), vec2h(unconst_f16(2546.5), unconst_f16(8208.2)));
  var vf309: vec2h = min(vec2h(unconst_f16(3123.7), unconst_f16(2829.7)), vec2h(unconst_f16(3470.8), unconst_f16(-21669.8)));
  let vf310: u32 = pack4x8unorm(vec4f(unconst_f32(0.2005), unconst_f32(0.2883), unconst_f32(0.2063), unconst_f32(0.02820)));
  out = vec4f(f32(vf308[bitcast<u32>(vf309)]));
  let vf311: f16 = vf309[u32(unconst_u32(125))];
  var vf312: u32 = vf310;
  var vf313: vec3f = normalize(vec3f(unconst_f32(0.3371), unconst_f32(0.5655), unconst_f32(-0.00660)));
  var vf314: u32 = pack4x8unorm(bitcast<vec4f>(reverseBits(vec2u(pack4x8unorm(vec4f(unconst_f32(0.3797), unconst_f32(-0.1078), unconst_f32(0.01886), unconst_f32(-0.1648))))).gggg));
  let vf315: vec2f = vf307;
  vf314 = u32(vf309[u32(unconst_u32(100))]);
  vf312 |= bitcast<u32>(vf315[u32(unconst_u32(431))]);
  vf313 = vf315.yyx;
  out -= vec4f(f32(vf308[u32(unconst_u32(159))]));
  vf314 += vf312;
  vf308 *= vec2h(cross(vec3f(unconst_f32(0.3466), unconst_f32(0.02824), unconst_f32(0.1374)), vec3f(unconst_f32(0.05284), unconst_f32(0.1083), unconst_f32(0.04216))).bg);
  return out;
}

@fragment
fn fragment17() {
  var vf316: f32 = determinant(mat2x2f(unconst_f32(0.03202), unconst_f32(0.3663), unconst_f32(0.3042), unconst_f32(0.3189)));
  var vf317: u32 = pack4xU8(vec4u(unconst_u32(371), unconst_u32(104), unconst_u32(289), unconst_u32(57)));
  var vf318: vec4f = fract(vec4f(unconst_f32(0.4396), unconst_f32(0.04069), unconst_f32(0.2356), unconst_f32(0.1784)));
  var vf319: f32 = determinant(mat2x2f(unconst_f32(0.05433), unconst_f32(0.05423), unconst_f32(0.4385), unconst_f32(0.04587)));
  vf319 *= f32(pack4xU8(vec4u(unconst_u32(270), unconst_u32(136), unconst_u32(43), unconst_u32(197))));
  var vf320: vec4f = degrees(vec4f(determinant(mat2x2f(unconst_f32(0.00627), unconst_f32(0.3686), unconst_f32(0.08551), unconst_f32(0.02330)))));
  let ptr107: ptr<function, f32> = &vf319;
  vf318 = degrees(vec4f(unconst_f32(0.1711), unconst_f32(0.3237), unconst_f32(0.00039), unconst_f32(0.1272)));
  let vf321: vec2f = log(vec2f(unconst_f32(0.08830), unconst_f32(-0.2722)));
  vf320 -= vec4f((*ptr107));
  vf317 <<= pack4xU8(vec4u(unconst_u32(22), unconst_u32(64), unconst_u32(4), unconst_u32(107)));
  let ptr108: ptr<function, f32> = &vf319;
  let ptr109: ptr<function, f32> = &vf316;
  var vf322: u32 = pack4xU8(vec4u(unconst_u32(85), unconst_u32(96), unconst_u32(114), unconst_u32(178)));
  vf318 = vec4f(vf319);
  let vf323: f32 = cos(fract(vec4f(unconst_f32(0.04159), unconst_f32(0.02470), unconst_f32(0.1343), unconst_f32(0.4408))).x);
}

@compute @workgroup_size(1, 1, 1)
fn compute14(@builtin(global_invocation_id) a0: vec3u) {
  var vf324: f16 = (*&vw38)[u32(unconst_u32(284))][u32(unconst_u32(142))];
  let vf325: vec4h = acos(vec4h(unconst_f16(699.0), unconst_f16(1057.3), unconst_f16(5004.8), unconst_f16(11300.7)));
  let ptr110: ptr<workgroup, f16> = &vw40[11];
}`,
  hints: {},
});
try {
computePassEncoder43.setBindGroup(0, bindGroup5, new Uint32Array(167), 37, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(2, 1); };
} catch {}
try {
computePassEncoder70.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(32);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder2.setVertexBuffer(6, buffer27, 16);
} catch {}
let imageData16 = new ImageData(16, 80);
let texture83 = device0.createTexture({
  label: '\u2786\u{1fd5c}\u{1fa9a}\u{1f64a}\u1661\uf0d0\ub868\u0bb5',
  size: [64],
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture84 = device0.createTexture({
  size: [290, 24, 516],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], depthReadOnly: true});
try {
computePassEncoder58.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup33);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup36, new Uint32Array(555), 145, 0);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(7, buffer27);
} catch {}
try {
computePassEncoder23.insertDebugMarker('\u{1fef9}');
} catch {}
let commandEncoder73 = device0.createCommandEncoder();
let texture85 = device0.createTexture({
  size: [210, 1, 7],
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler55 = device0.createSampler({
  label: '\u0ba8\u4aa9',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 46.85,
  lodMaxClamp: 71.14,
});
try {
computePassEncoder50.setBindGroup(3, bindGroup9);
} catch {}
try {
computePassEncoder54.setBindGroup(0, bindGroup5, new Uint32Array(1677), 117, 0);
} catch {}
try {
renderPassEncoder11.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder11.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer32, 'uint16', 1_148, 1_197);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(1, buffer19, 0, 1_100);
} catch {}
try {
commandEncoder73.insertDebugMarker('\u0fe0');
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let bindGroup41 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 409, resource: {buffer: buffer29, offset: 256, size: 4821}}],
});
let commandEncoder74 = device0.createCommandEncoder({});
let texture86 = device0.createTexture({
  size: {width: 580, height: 48, depthOrArrayLayers: 2},
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder71 = commandEncoder74.beginComputePass();
let renderBundle9 = renderBundleEncoder9.finish({});
try {
computePassEncoder70.setBindGroup(0, bindGroup28, new Uint32Array(1405), 600, 0);
} catch {}
try {
computePassEncoder71.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup11, new Uint32Array(3467), 56, 0);
} catch {}
try {
  await buffer31.mapAsync(GPUMapMode.READ, 0, 68);
} catch {}
try {
commandEncoder73.clearBuffer(buffer10);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(35).fill(236), /* required buffer size: 35 */
{offset: 35, rowsPerImage: 30}, {width: 37, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture65,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise9;
} catch {}
let querySet7 = device0.createQuerySet({type: 'occlusion', count: 121});
let computePassEncoder72 = commandEncoder73.beginComputePass({});
try {
computePassEncoder72.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup24, new Uint32Array(595), 134, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 51, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(170).fill(150), /* required buffer size: 170 */
{offset: 170, rowsPerImage: 7}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
try {
globalThis.someLabel = externalTexture7.label;
} catch {}
let bindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 210,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
  ],
});
let bindGroup42 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView48}]});
let buffer42 = device0.createBuffer({size: 13613, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let textureView52 = texture83.createView({baseArrayLayer: 0});
let texture87 = device0.createTexture({
  size: [580, 48, 2],
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView53 = texture75.createView({});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], sampleCount: 1});
let sampler56 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  lodMinClamp: 69.55,
  lodMaxClamp: 82.29,
});
try {
computePassEncoder62.setBindGroup(2, bindGroup27, new Uint32Array(2031), 287, 0);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(3, buffer5, 64, 14);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt2020', transfer: 'log'} });
let buffer43 = device0.createBuffer({
  label: '\u{1ff36}\u0c4c\u{1f739}\u4c4f\u0dba\u441b\u{1fa13}\u0c7a\ud570\ub569',
  size: 1886,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let texture88 = device0.createTexture({
  size: {width: 145},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture89 = device0.createTexture({size: [64, 64, 150], dimension: '3d', format: 'rg16uint', usage: GPUTextureUsage.COPY_SRC});
let textureView54 = texture87.createView({dimension: '2d-array', arrayLayerCount: 1});
let renderBundle10 = renderBundleEncoder10.finish({label: '\ue581\u2e7a\u2daf\u0fe9'});
let sampler57 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMinClamp: 3.709,
  lodMaxClamp: 98.03,
  compare: 'less-equal',
  maxAnisotropy: 1,
});
try {
renderPassEncoder0.executeBundles([renderBundle3, renderBundle6, renderBundle3, renderBundle6, renderBundle8, renderBundle3, renderBundle3, renderBundle6, renderBundle3]);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 11}
*/
{
  source: imageData12,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture59,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView55 = texture88.createView({format: 'r32float'});
let texture90 = device0.createTexture({
  size: {width: 52, height: 1, depthOrArrayLayers: 100},
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture9 = device0.importExternalTexture({source: videoFrame3});
try {
computePassEncoder70.setBindGroup(3, bindGroup12, new Uint32Array(445), 20, 0);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup41);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup34, new Uint32Array(1274), 533, 0);
} catch {}
try {
  await promise8;
} catch {}
let bindGroup43 = device0.createBindGroup({
  label: '\u10d9\u4e66\u{1f7f6}',
  layout: bindGroupLayout3,
  entries: [{binding: 16, resource: {buffer: buffer39, offset: 2048, size: 1440}}],
});
try {
computePassEncoder54.setBindGroup(2, bindGroup34);
} catch {}
try {
computePassEncoder14.setBindGroup(3, bindGroup3, new Uint32Array(1449), 58, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer14, 'uint16', 1_888, 146);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture50,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(8).fill(64), /* required buffer size: 8 */
{offset: 8}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder75 = device0.createCommandEncoder({});
let computePassEncoder73 = commandEncoder75.beginComputePass({label: '\u5ec1\u7249\u43d9'});
let sampler58 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 67.48,
  lodMaxClamp: 90.17,
});
try {
computePassEncoder70.setBindGroup(1, bindGroup40, new Uint32Array(270), 13, 0);
} catch {}
try {
computePassEncoder73.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup28, new Uint32Array(3019), 448, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 52, height: 1, depthOrArrayLayers: 100}
*/
{
  source: imageData10,
  origin: { x: 0, y: 16 },
  flipY: true,
}, {
  texture: texture90,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 17},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup44 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView28}]});
let commandEncoder76 = device0.createCommandEncoder();
let computePassEncoder74 = commandEncoder76.beginComputePass({});
try {
computePassEncoder53.setBindGroup(0, bindGroup10, new Uint32Array(1623), 569, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup24);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpteRp431', transfer: 'bt2020_12bit'} });
let bindGroup45 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 329, resource: textureView30}]});
let textureView56 = texture9.createView({
  label: '\u0c1a\u51ba\u0a62\u0aee\u09a8\u4f34\u09bd\u09a4\uaef0\u95dc',
  aspect: 'all',
  baseArrayLayer: 0,
  arrayLayerCount: 1,
});
try {
computePassEncoder28.setBindGroup(2, bindGroup39);
} catch {}
try {
computePassEncoder74.setPipeline(pipeline0);
} catch {}
try {
  await promise10;
} catch {}
let commandEncoder77 = device0.createCommandEncoder({});
let computePassEncoder75 = commandEncoder77.beginComputePass();
try {
computePassEncoder44.setBindGroup(1, bindGroup45);
} catch {}
try {
computePassEncoder19.end();
} catch {}
try {
computePassEncoder75.setPipeline(pipeline0);
} catch {}
try {
commandEncoder19.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 848 */
  offset: 848,
  bytesPerRow: 256,
  rowsPerImage: 552,
  buffer: buffer21,
}, {
  texture: texture83,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder19.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 71, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 268 */
  offset: 268,
  buffer: buffer18,
}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise11 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture65,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView57 = texture69.createView({label: '\u{1ffc4}\u98a6\u936e\u0870\u45fe', dimension: '2d'});
let renderPassEncoder13 = commandEncoder19.beginRenderPass({
  colorAttachments: [{
  view: textureView53,
  depthSlice: 9,
  clearValue: { r: -945.1, g: -616.5, b: 167.4, a: 751.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder4.end();
} catch {}
try {
renderPassEncoder3.setBindGroup(1, bindGroup34);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer17, 'uint32', 428, 130);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 46, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(202).fill(29), /* required buffer size: 202 */
{offset: 202, bytesPerRow: 144}, {width: 62, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder78 = device0.createCommandEncoder({});
let renderPassEncoder14 = commandEncoder78.beginRenderPass({
  colorAttachments: [{
  view: textureView47,
  clearValue: { r: 574.1, g: -758.7, b: 619.0, a: 166.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 131724664,
});
try {
renderPassEncoder10.setBindGroup(3, bindGroup20, new Uint32Array(4022), 541, 0);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(0, buffer5, 108, 27);
} catch {}
let arrayBuffer0 = buffer31.getMappedRange(0, 12);
try {
commandEncoder5.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 76, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 144 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1444 */
  offset: 1444,
  bytesPerRow: 8192,
  buffer: buffer1,
}, {width: 36, height: 4, depthOrArrayLayers: 0});
} catch {}
let commandEncoder79 = device0.createCommandEncoder({});
let computePassEncoder76 = commandEncoder5.beginComputePass({label: '\uc4b6\u0b5c\ud420\u86a8\u0e3e\u82a8\u{1fbd3}\ue540\u690f'});
try {
computePassEncoder53.setBindGroup(2, bindGroup1, new Uint32Array(716), 280, 0);
} catch {}
try {
computePassEncoder43.end();
} catch {}
try {
computePassEncoder76.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup22);
} catch {}
try {
renderPassEncoder9.setBindGroup(3, bindGroup5, new Uint32Array(442), 81, 0);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer19, 2_028, 3_103);
} catch {}
try {
commandEncoder39.copyTextureToBuffer({
  texture: texture87,
  mipLevel: 0,
  origin: {x: 90, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1064 */
  offset: 1064,
  bytesPerRow: 17152,
  rowsPerImage: 371,
  buffer: buffer0,
}, {width: 3, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture83,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(145).fill(130), /* required buffer size: 145 */
{offset: 145}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer44 = device0.createBuffer({size: 32328, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder80 = device0.createCommandEncoder({});
let textureView58 = texture36.createView({});
try {
renderPassEncoder5.executeBundles([renderBundle8]);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer17, 'uint32', 964, 200);
} catch {}
try {
commandEncoder80.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1300 */
  offset: 1300,
  buffer: buffer9,
}, {
  texture: texture83,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {width: 14, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder81 = device0.createCommandEncoder();
try {
computePassEncoder73.setBindGroup(2, bindGroup37);
} catch {}
try {
computePassEncoder58.setBindGroup(1, bindGroup31, new Uint32Array(157), 4, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup16);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer34, 'uint16', 528, 114);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer25, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(645).fill(233), /* required buffer size: 645 */
{offset: 645}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let textureView59 = texture48.createView({label: '\u549c\u93fb\u0888\u379a\u66be\u{1fc1a}\udece\u0d8b\u75a6\u0682'});
let renderPassEncoder15 = commandEncoder81.beginRenderPass({
  label: '\u0824\u{1fed7}\u9b8c\u099e',
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: 87.54, g: 760.8, b: -397.7, a: -543.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet7,
  maxDrawCount: 14581675,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup41);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder54); computePassEncoder54.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer35, 108); };
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer17, 'uint16', 634, 574);
} catch {}
try {
commandEncoder39.resolveQuerySet(querySet5, 12, 4, buffer17, 256);
} catch {}
try {
computePassEncoder71.pushDebugGroup('\u{1fe37}');
} catch {}
document.body.append(img0);
let textureView60 = texture88.createView({label: '\u0d79\u198e\u{1f974}\ud9a2'});
let computePassEncoder77 = commandEncoder80.beginComputePass({label: '\u47fc\u044f\u1e74'});
try {
computePassEncoder77.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer40, 'uint16', 552, 1_868);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, buffer10, 0, 2_563);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'log'} });
let videoFrame14 = new VideoFrame(videoFrame10, {timestamp: 0});
let commandEncoder82 = device0.createCommandEncoder({});
try {
renderPassEncoder1.setBindGroup(1, bindGroup44);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer38, 'uint32', 1_204, 51);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer33, 0, 1_132);
} catch {}
let imageData17 = new ImageData(28, 52);
let commandEncoder83 = device0.createCommandEncoder({});
let textureView61 = texture49.createView({mipLevelCount: 1, arrayLayerCount: 1});
let renderPassEncoder16 = commandEncoder83.beginRenderPass({
  colorAttachments: [{
  view: textureView23,
  clearValue: { r: 639.1, g: -777.4, b: 618.8, a: -734.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder7.setBindGroup(2, bindGroup9, new Uint32Array(3345), 816, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer34);
} catch {}
try {
commandEncoder82.copyBufferToBuffer(buffer27, 28, buffer18, 3388, 172);
} catch {}
try {
computePassEncoder71.popDebugGroup();
} catch {}
let texture91 = device0.createTexture({
  size: {width: 580, height: 48, depthOrArrayLayers: 2},
  mipLevelCount: 3,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView62 = texture32.createView({label: '\u09a1\u229b\uc53f\u61e0\u063c\u97cc', dimension: '2d-array', mipLevelCount: 1});
try {
computePassEncoder40.setBindGroup(2, bindGroup6, []);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 1, depthOrArrayLayers: 4}
*/
{
  source: imageData16,
  origin: { x: 1, y: 3 },
  flipY: false,
}, {
  texture: texture0,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise11;
} catch {}
let bindGroup46 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 37, resource: {buffer: buffer24, offset: 2048, size: 837}},
    {binding: 39, resource: textureView1},
    {binding: 357, resource: {buffer: buffer38, offset: 0, size: 1640}},
    {binding: 120, resource: {buffer: buffer2, offset: 1024, size: 2940}},
    {binding: 124, resource: {buffer: buffer1, offset: 256, size: 19332}},
  ],
});
let computePassEncoder78 = commandEncoder39.beginComputePass({});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint']});
let renderBundle11 = renderBundleEncoder11.finish({label: '\u{1fc15}\u1568\u09eb\u14bd\u1f1a\uc626\u{1fc8f}\u{1f898}\u67f5\ud395'});
try {
computePassEncoder6.setBindGroup(0, bindGroup36, new Uint32Array(1198), 2, 0);
} catch {}
try {
computePassEncoder54.end();
} catch {}
try {
renderPassEncoder7.setBindGroup(1, bindGroup20, new Uint32Array(261), 36, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer6, 'uint32', 1_364, 4_628);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture65,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(47).fill(30), /* required buffer size: 47 */
{offset: 47}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder84 = device0.createCommandEncoder({});
let textureView63 = texture22.createView({dimension: '2d'});
let renderPassEncoder17 = commandEncoder79.beginRenderPass({
  colorAttachments: [{
  view: textureView23,
  clearValue: { r: 437.1, g: 403.3, b: -711.6, a: -792.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder78.setBindGroup(2, bindGroup6, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder29.setPipeline(pipeline0);
} catch {}
try {
commandEncoder82.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2152 */
  offset: 2152,
  buffer: buffer42,
}, {
  texture: texture40,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 1},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture59,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(746).fill(187), /* required buffer size: 746 */
{offset: 53, bytesPerRow: 21, rowsPerImage: 33}, {width: 3, height: 0, depthOrArrayLayers: 2});
} catch {}
let img1 = await imageWithData(110, 130, '#10101010', '#20202020');
let computePassEncoder79 = commandEncoder25.beginComputePass();
let renderPassEncoder18 = commandEncoder82.beginRenderPass({
  colorAttachments: [{
  view: textureView53,
  depthSlice: 29,
  clearValue: { r: 946.7, g: -202.7, b: -307.0, a: -93.30, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler59 = device0.createSampler({
  label: '\u065f\u8588\uc9b0\ufe25\ud80c\u{1f8e2}\u0473\u0b39\u0081',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 38.20,
  lodMaxClamp: 71.98,
});
try {
computePassEncoder49.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder41.setBindGroup(0, bindGroup34, new Uint32Array(624), 23, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup34, new Uint32Array(28), 2, 0);
} catch {}
try {
renderPassEncoder17.end();
} catch {}
try {
renderPassEncoder16.setVertexBuffer(1, buffer1, 0, 5_236);
} catch {}
try {
externalTexture5.label = '\ua922\u{1f7ad}\u0076\uef13\u0ba8';
} catch {}
let commandEncoder85 = device0.createCommandEncoder();
let texture92 = device0.createTexture({
  size: [26, 1, 129],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView64 = texture33.createView({label: '\u{1f8ce}\u084c\u6f26\u3820\u0106', dimension: 'cube', baseArrayLayer: 1, arrayLayerCount: 6});
let computePassEncoder80 = commandEncoder85.beginComputePass({});
try {
computePassEncoder78.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setBindGroup(2, bindGroup17, new Uint32Array(631), 65, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 18}
*/
{
  source: imageData0,
  origin: { x: 2, y: 31 },
  flipY: false,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 17, y: 33, z: 9},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 26, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img0);
await gc();
let bindGroup47 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 39, resource: textureView1},
    {binding: 37, resource: {buffer: buffer1, offset: 256, size: 12068}},
    {binding: 124, resource: {buffer: buffer39, offset: 256}},
    {binding: 357, resource: {buffer: buffer37, offset: 512, size: 444}},
    {binding: 120, resource: {buffer: buffer1, offset: 3072, size: 5826}},
  ],
});
let sampler60 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 49.70,
  lodMaxClamp: 71.74,
});
try {
renderPassEncoder13.setBindGroup(1, bindGroup32, new Uint32Array(37), 0, 0);
} catch {}
try {
renderPassEncoder15.beginOcclusionQuery(26);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle3]);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer28, 'uint16', 1_498, 631);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer28, 676, 2_401);
} catch {}
try {
commandEncoder79.clearBuffer(buffer31, 76, 276);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let bindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {binding: 91, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 258,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let bindGroup48 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 210, resource: textureView60}]});
let commandBuffer3 = commandEncoder79.finish();
let texture93 = device0.createTexture({
  label: '\u{1fca0}\u{1f868}\uec5e\u0622\u123a\u025a\u507d\u9718\ub751\u01e7\u31e6',
  size: {width: 52, height: 1, depthOrArrayLayers: 1},
  format: 'r32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder19 = commandEncoder84.beginRenderPass({
  colorAttachments: [{
  view: textureView61,
  clearValue: { r: -117.2, g: -18.84, b: 563.9, a: 453.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
renderPassEncoder18.setBindGroup(0, bindGroup27);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(4, buffer2, 832, 2_423);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
  await promise12;
} catch {}
await gc();
let commandEncoder86 = device0.createCommandEncoder();
let texture94 = device0.createTexture({
  size: {width: 580, height: 48, depthOrArrayLayers: 2},
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder81 = commandEncoder86.beginComputePass({});
try {
computePassEncoder17.setBindGroup(2, bindGroup15);
} catch {}
try {
computePassEncoder71.setBindGroup(0, bindGroup18, new Uint32Array(509), 79, 0);
} catch {}
try {
renderPassEncoder10.beginOcclusionQuery(113);
} catch {}
try {
renderPassEncoder10.endOcclusionQuery();
} catch {}
let bindGroup49 = device0.createBindGroup({
  label: '\u7fe8\u0a9a\u0a7b\u0550\ucf58\ue2c8',
  layout: bindGroupLayout0,
  entries: [{binding: 184, resource: textureView64}],
});
let texture95 = device0.createTexture({
  label: '\u68df\u906d',
  size: [26, 1, 20],
  format: 'r32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder8.setIndexBuffer(buffer12, 'uint16', 48, 74);
} catch {}
let arrayBuffer1 = buffer31.getMappedRange(24, 8);
try {
device0.queue.submit([]);
} catch {}
let buffer45 = device0.createBuffer({size: 15472, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let textureView65 = texture20.createView({});
let textureView66 = texture87.createView({dimension: '2d', arrayLayerCount: 1});
let externalTexture10 = device0.importExternalTexture({source: videoFrame5});
try {
computePassEncoder31.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup30, []);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup12, new Uint32Array(204), 53, 0);
} catch {}
try {
computePassEncoder67.pushDebugGroup('\u5bd6');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture90,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 15},
  aspect: 'all',
}, new Uint8Array(2_416).fill(151), /* required buffer size: 2_416 */
{offset: 295, bytesPerRow: 101, rowsPerImage: 1}, {width: 1, height: 0, depthOrArrayLayers: 22});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let buffer46 = device0.createBuffer({
  size: 18717,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let textureView67 = texture94.createView({arrayLayerCount: 1});
let textureView68 = texture8.createView({baseMipLevel: 0, mipLevelCount: 1});
let sampler61 = device0.createSampler({
  label: '\ub319\u822a\ub933\u{1f965}\uc373\ufd9e\u0794\u{1fbfe}\ub014\u7444',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 54.32,
  lodMaxClamp: 86.66,
  compare: 'less',
});
try {
computePassEncoder56.setBindGroup(1, bindGroup24);
} catch {}
try {
computePassEncoder79.setPipeline(pipeline2);
} catch {}
let textureView69 = texture94.createView({arrayLayerCount: 1});
let sampler62 = device0.createSampler({
  label: '\u38a7\u{1f8a5}\ua049\u5e64\u0845\ud773\ubbac\u8113\uba33\u{1f7da}\u4398',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 95.56,
  lodMaxClamp: 95.78,
  maxAnisotropy: 19,
});
try {
computePassEncoder51.setBindGroup(3, bindGroup27, new Uint32Array(484), 178, 0);
} catch {}
try {
computePassEncoder81.setPipeline(pipeline2);
} catch {}
try {
computePassEncoder67.popDebugGroup();
} catch {}
let texture96 = device0.createTexture({
  label: '\u{1fe25}\uccd3',
  size: {width: 26},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder74.setBindGroup(0, bindGroup30, new Uint32Array(960), 244, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup26);
} catch {}
try {
renderPassEncoder4.setViewport(14.83473687751119, 0.6918715255084185, 5.513310076640483, 0.04466230874936465, 0.04254133816793848, 0.5769607284989507);
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer40, 'uint16', 360, 4_334);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let textureView70 = texture93.createView({dimension: '2d-array'});
try {
computePassEncoder39.setBindGroup(2, bindGroup15, new Uint32Array(294), 71, 0);
} catch {}
try {
computePassEncoder80.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup27);
} catch {}
try {
renderPassEncoder13.end();
} catch {}
try {
commandEncoder19.clearBuffer(buffer5, 16, 24);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 2}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(118, 208);
let buffer47 = device0.createBuffer({
  size: 18294,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView71 = texture10.createView({mipLevelCount: 1});
let computePassEncoder82 = commandEncoder19.beginComputePass({});
try {
computePassEncoder18.end();
} catch {}
try {
commandEncoder18.copyBufferToBuffer(buffer7, 624, buffer27, 20, 12);
} catch {}
try {
computePassEncoder36.insertDebugMarker('\u09b1');
} catch {}
let gpuCanvasContext1 = offscreenCanvas1.getContext('webgpu');
let offscreenCanvas2 = new OffscreenCanvas(21, 28);
let commandEncoder87 = device0.createCommandEncoder({});
let texture97 = device0.createTexture({
  size: {width: 52, height: 1, depthOrArrayLayers: 3},
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView72 = texture91.createView({dimension: '2d', mipLevelCount: 1});
let renderPassEncoder20 = commandEncoder87.beginRenderPass({
  colorAttachments: [{
  view: textureView39,
  clearValue: { r: 613.7, g: 867.8, b: 875.5, a: 786.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder73.setBindGroup(0, bindGroup17);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroupsIndirect(buffer29, 2_392); };
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup43);
} catch {}
let shaderModule15 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

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

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

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

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

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

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

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

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

fn fn0(a0: array<vec2h, 1>) -> array<array<u32, 3>, 1> {
  var out: array<array<u32, 3>, 1>;
  vp18[u32(unconst_u32(4))] *= vp18[13];
  let vf326: array<vec2h, 1> = a0;
  vp18[u32(unconst_u32(240))] += vec4f(f32(vf326[u32(unconst_u32(23))][u32(unconst_u32(119))]));
  out[u32(unconst_u32(159))][u32(unconst_u32(228))] <<= pack2x16unorm(unpack2x16snorm(u32(unconst_u32(29))));
  out[min(vec2u(unconst_u32(137), unconst_u32(149)), vec2u(unconst_u32(87), unconst_u32(52))).r][2] = u32(acos(f16(vp18[13].x)));
  return out;
}

var<workgroup> vw42: i32;

var<private> vp18: array<vec4f, 14> = array(vec4f(0.08276, 0.2701, 0.4609, 0.1927), vec4f(0.02929, 0.3730, 0.1604, 0.01944), vec4f(0.06471, 0.04198, 0.2888, 0.05706), vec4f(0.4769, 0.1396, 0.1142, 0.1406), vec4f(0.06674, 0.4692, 1.000, 0.1755), vec4f(0.09280, 0.1566, 0.2309, 0.3882), vec4f(0.05877, 0.3145, 0.01190, 0.08373), vec4f(0.09112, 0.03458, 0.2851, 0.4032), vec4f(0.03779, 0.06377, 0.03958, 0.03092), vec4f(0.5156, 0.04491, 0.2431, 0.02145), vec4f(0.4196, 0.00136, 0.00752, 0.1074), vec4f(-0.01522, -0.01890, 0.06028, 0.1360), vec4f(0.3219, 0.09870, 0.06294, 0.2421), vec4f(0.05739, 0.06944, -0.05949, 0.06048));

@compute @workgroup_size(1, 1, 1)
fn compute15() {
  vw42 -= bitcast<vec4i>(sqrt(vec4f(unconst_f32(0.05224), unconst_f32(-0.05750), unconst_f32(0.1013), unconst_f32(0.1442)))).a;
  fn0(array<vec2h, 1>(radians(vec4h(unconst_f16(18868.4), unconst_f16(304.6), unconst_f16(-3106.6), unconst_f16(1656.7))).xx));
}`,
  hints: {},
});
let textureView73 = texture95.createView({label: '\u9b2f\uc5d2\ube9e\u9ae4\u19e1\u0b59\u1395\udf0b\u443f', dimension: '2d'});
let computePassEncoder83 = commandEncoder18.beginComputePass({});
let sampler63 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 48.51,
  lodMaxClamp: 78.37,
});
try {
computePassEncoder82.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder5.setBlendConstant({ r: 6.464, g: -658.8, b: -512.3, a: -276.2, });
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
await gc();
let buffer48 = device0.createBuffer({size: 1218, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder88 = device0.createCommandEncoder({label: '\u4cb1\u3aa0\u{1f6db}\u113a\u5e3b\u2dde\ud59c\u0280\u26a8\ua438\u9088'});
let renderPassEncoder21 = commandEncoder88.beginRenderPass({
  label: '\u9f4b\ucc5b\u066e\u08ab',
  colorAttachments: [{
  view: textureView61,
  clearValue: { r: 252.7, g: 592.3, b: 389.2, a: 456.7, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet6,
  maxDrawCount: 538370999,
});
try {
{ clearResourceUsages(device0, computePassEncoder49); computePassEncoder49.dispatchWorkgroupsIndirect(buffer47, 3_888); };
} catch {}
try {
renderPassEncoder10.setIndexBuffer(buffer14, 'uint16', 6_084, 1_038);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(3, buffer26);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(4).fill(142), /* required buffer size: 4 */
{offset: 4}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer49 = device0.createBuffer({
  label: '\u06af\udbf8\u83cc\u04ef\u4707\u{1f6f7}\u08d4\u0042\u{1f8b6}',
  size: 18659,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
try {
computePassEncoder64.setBindGroup(0, bindGroup48);
} catch {}
try {
computePassEncoder83.setPipeline(pipeline2);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
let bindGroup50 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 16, resource: {buffer: buffer1, offset: 6912, size: 1068}}],
});
let buffer50 = device0.createBuffer({
  size: 5420,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture98 = device0.createTexture({
  label: '\u99b2\u0b16',
  size: [580],
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder24.setBindGroup(1, bindGroup38);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup26, new Uint32Array(519), 256, 0);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, buffer28, 316);
} catch {}
let gpuCanvasContext2 = offscreenCanvas2.getContext('webgpu');
try {
adapter0.label = '\u{1ff10}\u{1f86b}\u1191\u9be3';
} catch {}
let buffer51 = device0.createBuffer({
  label: '\ue6cf\u69cc\uea79\u0ffe\u010e\u97df\u1a3e\uf54b\uf835\u7bcf',
  size: 15129,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder89 = device0.createCommandEncoder({});
let texture99 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 18},
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder84 = commandEncoder89.beginComputePass({});
try {
computePassEncoder49.dispatchWorkgroupsIndirect(buffer29, 1_992);
} catch {}
try {
computePassEncoder84.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup22);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer32, 'uint16', 4_184, 2_090);
} catch {}
try {
computePassEncoder36.pushDebugGroup('\ubc7d');
} catch {}
let buffer52 = device0.createBuffer({size: 2817, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let texture100 = device0.createTexture({
  size: [1160, 96, 1396],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
});
try {
{ clearResourceUsages(device0, computePassEncoder49); computePassEncoder49.dispatchWorkgroups(2); };
} catch {}
try {
device0.queue.writeBuffer(buffer40, 244, new BigUint64Array(6622), 17, 88);
} catch {}
try {
computePassEncoder64.setBindGroup(3, bindGroup40, new Uint32Array(2094), 56, 0);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let commandEncoder90 = device0.createCommandEncoder({});
let computePassEncoder85 = commandEncoder90.beginComputePass();
let sampler64 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  lodMaxClamp: 63.30,
  maxAnisotropy: 1,
});
try {
computePassEncoder85.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer18, 0, 1_192);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
document.body.append(img0);
let buffer53 = device0.createBuffer({
  size: 25106,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder70.setBindGroup(2, bindGroup50, []);
} catch {}
try {
computePassEncoder39.setBindGroup(1, bindGroup10, new Uint32Array(750), 8, 0);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup8);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup40, new Uint32Array(356), 41, 0);
} catch {}
try {
renderPassEncoder6.setStencilReference(1068);
} catch {}
let bindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 89,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {binding: 435, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 171, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
  ],
});
let commandEncoder91 = device0.createCommandEncoder({});
let renderPassEncoder22 = commandEncoder91.beginRenderPass({
  colorAttachments: [{
  view: textureView72,
  clearValue: { r: -324.4, g: -168.2, b: 997.9, a: 34.68, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 876289481,
});
let imageData18 = new ImageData(20, 64);
let buffer54 = device0.createBuffer({size: 7177, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let commandEncoder92 = device0.createCommandEncoder({});
try {
computePassEncoder66.setBindGroup(2, bindGroup41, []);
} catch {}
try {
computePassEncoder49.end();
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup37);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer35, 0, 1_790);
} catch {}
try {
commandEncoder46.copyBufferToTexture({
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1720 */
  offset: 1720,
  rowsPerImage: 892,
  buffer: buffer7,
}, {
  texture: texture68,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder93 = device0.createCommandEncoder({label: '\u41c9\u021e\u{1fdd3}\u7eb0\u{1f9cf}\u371b\u07df\u8e96\u{1f9be}\u229b'});
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroupsIndirect(buffer46, 1_036); };
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup36);
} catch {}
try {
commandEncoder93.copyBufferToTexture({
  /* bytesInLastRow: 176 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 424 */
  offset: 424,
  buffer: buffer43,
}, {
  texture: texture7,
  mipLevel: 1,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
}, {width: 22, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder56.pushDebugGroup('\u{1fd44}');
} catch {}
let canvas0 = document.createElement('canvas');
try {
externalTexture9.label = '\u7233\u03ef\u{1facb}\u3f5c\u{1f671}\u{1f777}\u{1f853}\u{1fb3c}\uae4f';
} catch {}
let commandBuffer4 = commandEncoder46.finish();
let textureView74 = texture58.createView({dimension: '2d'});
let computePassEncoder86 = commandEncoder93.beginComputePass();
let sampler65 = device0.createSampler({
  label: '\u531c\u13ed\u{1f9dc}\u1cfa\u9cfa\ub347\ucc87',
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 66.95,
  lodMaxClamp: 88.88,
  maxAnisotropy: 3,
});
try {
computePassEncoder6.setBindGroup(3, bindGroup36);
} catch {}
try {
computePassEncoder86.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer1, 'uint16', 2_762, 15_045);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder92.copyBufferToTexture({
  /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1888 */
  offset: 1888,
  buffer: buffer1,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
try {
adapter0.label = '\u{1fc69}\u0f37\uda35\u{1f7ef}\u{1feb3}\u{1fa6a}\u631a\u04ef\ua325';
} catch {}
let textureView75 = texture91.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1});
let computePassEncoder87 = commandEncoder92.beginComputePass();
try {
computePassEncoder81.setBindGroup(2, bindGroup45);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroupsIndirect(buffer17, 920); };
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroup51 = device0.createBindGroup({
  label: '\u0cba\u6673\u0c9c\ub901\u07d0\u9a4e',
  layout: bindGroupLayout7,
  entries: [{binding: 91, resource: sampler31}, {binding: 258, resource: textureView69}],
});
let buffer55 = device0.createBuffer({size: 1195, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let texture101 = device0.createTexture({
  size: [145, 12, 4],
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let sampler66 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 60.40,
  lodMaxClamp: 70.65,
});
try {
computePassEncoder87.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle8]);
} catch {}
try {
buffer54.unmap();
} catch {}
try {
computePassEncoder86.pushDebugGroup('\udea3');
} catch {}
let buffer56 = device0.createBuffer({size: 14942, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
try {
renderPassEncoder22.setBindGroup(0, bindGroup49, new Uint32Array(1074), 13, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 105, height: 1, depthOrArrayLayers: 7}
*/
{
  source: img1,
  origin: { x: 7, y: 4 },
  flipY: false,
}, {
  texture: texture85,
  mipLevel: 1,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let img2 = await imageWithData(16, 10, '#10101010', '#20202020');
let commandEncoder94 = device0.createCommandEncoder();
let renderPassEncoder23 = commandEncoder94.beginRenderPass({
  colorAttachments: [{
  view: textureView50,
  clearValue: { r: -666.9, g: 333.0, b: 436.5, a: 763.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 281680305,
});
try {
computePassEncoder30.setBindGroup(2, bindGroup24);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup44);
} catch {}
try {
device0.queue.writeBuffer(buffer14, 3112, new BigUint64Array(5128), 1370, 408);
} catch {}
let externalTexture11 = device0.importExternalTexture({label: '\u0413\u035f', source: videoFrame5});
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder23.setBindGroup(1, bindGroup11, new Uint32Array(2160), 1_544, 0);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
try {
  await promise13;
} catch {}
let bindGroup52 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 258, resource: textureView70}, {binding: 91, resource: sampler48}],
});
let commandEncoder95 = device0.createCommandEncoder();
let texture102 = device0.createTexture({
  size: [580, 48, 2],
  mipLevelCount: 1,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder23.setBindGroup(0, bindGroup46);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(1, buffer45, 0);
} catch {}
try {
commandEncoder95.copyBufferToTexture({
  /* bytesInLastRow: 1240 widthInBlocks: 310 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 52 */
  offset: 52,
  buffer: buffer11,
}, {
  texture: texture42,
  mipLevel: 0,
  origin: {x: 192, y: 0, z: 0},
  aspect: 'all',
}, {width: 310, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder12.resolveQuerySet(querySet5, 42, 11, buffer33, 3328);
} catch {}
try {
computePassEncoder86.popDebugGroup();
} catch {}
let shaderModule16 = device0.createShaderModule({
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

requires pointer_composite_access;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(184) var tex16: texture_cube<i32>;

struct T0 {
  @align(8) @size(1216) f0: mat4x2h,
  @size(2432) f1: array<array<vec2u, 1>>,
}

struct T1 {
  @size(236) f0: array<vec2h>,
}

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

struct FragmentOutput12 {
  @location(7) @interpolate(flat, center) f0: vec4u,
}

alias vec3b = vec3<bool>;

fn fn0() -> mat2x3f {
  var out: mat2x3f;
  let vf327: vec4f = reflect(vec4f(unconst_f32(-0.2033), unconst_f32(0.01857), unconst_f32(0.4611), unconst_f32(0.1180)), vec4f(unconst_f32(0.4263), unconst_f32(0.1819), unconst_f32(0.2350), unconst_f32(0.01561)));
  out = mat2x3f(vf327.xxw, vf327.zzx);
  out = mat2x3f(vec3f(log(vec2h(unconst_f16(339.6), unconst_f16(4590.2))).rgr), vec3f(log(vec2h(unconst_f16(339.6), unconst_f16(4590.2))).grg));
  out += mat2x3f(reflect(vec4f(unconst_f32(0.06398), unconst_f32(0.3802), unconst_f32(-0.07463), unconst_f32(-0.06493)), vec4f(unconst_f32(0.2215), unconst_f32(0.00937), unconst_f32(0.08436), unconst_f32(0.1929))).xwx, reflect(vec4f(unconst_f32(0.06398), unconst_f32(0.3802), unconst_f32(-0.07463), unconst_f32(-0.06493)), vec4f(unconst_f32(0.2215), unconst_f32(0.00937), unconst_f32(0.08436), unconst_f32(0.1929))).rgb);
  out = mat2x3f(tanh(vec4f(unconst_f32(0.1285), unconst_f32(-0.1608), unconst_f32(0.2054), unconst_f32(0.9583))).gra, tanh(vec4f(unconst_f32(0.1285), unconst_f32(-0.1608), unconst_f32(0.2054), unconst_f32(0.9583))).xwx);
  let vf328: vec4f = tanh(vec4f(unconst_f32(-0.07177), unconst_f32(0.1194), unconst_f32(0.1355), unconst_f32(0.07680)));
  out = mat2x3f(vf328[u32(unconst_u32(82))], vf328[u32(unconst_u32(82))], vf328[u32(unconst_u32(82))], vf328[u32(unconst_u32(82))], vf328[u32(unconst_u32(82))], vf328[u32(unconst_u32(82))]);
  var vf329: vec2u = countTrailingZeros(vec2u(unconst_u32(512), unconst_u32(257)));
  out = mat2x3f(bitcast<f32>(vf329[u32(unconst_u32(378))]), f32(vf329[u32(unconst_u32(378))]), bitcast<f32>(vf329[u32(unconst_u32(378))]), bitcast<f32>(vf329[u32(unconst_u32(378))]), f32(vf329[u32(unconst_u32(378))]), f32(vf329[u32(unconst_u32(378))]));
  let vf330: vec4f = vf327;
  var vf331: vec2f = asinh(vec2f(unconst_f32(0.01253), unconst_f32(0.3838)));
  out = mat2x3f(asinh(vec2f(unconst_f32(0.09042), unconst_f32(0.1774))).rrg, asinh(vec2f(unconst_f32(0.09042), unconst_f32(0.1774))).grr);
  var vf332: vec2u = countTrailingZeros(vec2u(unconst_u32(46), unconst_u32(232)));
  let vf333: vec2h = sin(vec2h(unconst_f16(16832.1), unconst_f16(-7707.1)));
  return out;
}

fn fn1(a0: vec4f) -> mat3x2f {
  var out: mat3x2f;
  let vf334: vec3h = acosh(vec3h(unconst_f16(1300.1), unconst_f16(2894.7), unconst_f16(25046.9)));
  out = mat3x2f(bitcast<f32>(dot(vec2i(unconst_i32(22), unconst_i32(199)), vec2i(unconst_i32(228), unconst_i32(-209)))), bitcast<f32>(dot(vec2i(unconst_i32(22), unconst_i32(199)), vec2i(unconst_i32(228), unconst_i32(-209)))), bitcast<f32>(dot(vec2i(unconst_i32(22), unconst_i32(199)), vec2i(unconst_i32(228), unconst_i32(-209)))), bitcast<f32>(dot(vec2i(unconst_i32(22), unconst_i32(199)), vec2i(unconst_i32(228), unconst_i32(-209)))), f32(dot(vec2i(unconst_i32(22), unconst_i32(199)), vec2i(unconst_i32(228), unconst_i32(-209)))), f32(dot(vec2i(unconst_i32(22), unconst_i32(199)), vec2i(unconst_i32(228), unconst_i32(-209)))));
  let vf335: vec3f = degrees(vec3f(unconst_f32(0.1202), unconst_f32(0.2481), unconst_f32(0.06591)));
  out += mat3x2f(a0.ab, a0.wx, a0.wy);
  var vf336 = fn0();
  fn0();
  var vf337 = fn0();
  out = mat3x2f(bitcast<f32>(pack4xI8Clamp(vec4i(unconst_i32(510), unconst_i32(80), unconst_i32(178), unconst_i32(214)))), f32(pack4xI8Clamp(vec4i(unconst_i32(510), unconst_i32(80), unconst_i32(178), unconst_i32(214)))), bitcast<f32>(pack4xI8Clamp(vec4i(unconst_i32(510), unconst_i32(80), unconst_i32(178), unconst_i32(214)))), bitcast<f32>(pack4xI8Clamp(vec4i(unconst_i32(510), unconst_i32(80), unconst_i32(178), unconst_i32(214)))), f32(pack4xI8Clamp(vec4i(unconst_i32(510), unconst_i32(80), unconst_i32(178), unconst_i32(214)))), bitcast<f32>(pack4xI8Clamp(vec4i(unconst_i32(510), unconst_i32(80), unconst_i32(178), unconst_i32(214)))));
  let vf338: u32 = pack4xU8(vec4u(unconst_u32(196), unconst_u32(206), unconst_u32(139), unconst_u32(505)));
  var vf339 = fn0();
  vf337 = mat2x3f(vf339[u32(unconst_u32(69))][u32(unconst_u32(61))], vf339[u32(unconst_u32(69))][u32(unconst_u32(61))], vf339[u32(unconst_u32(69))][u32(unconst_u32(61))], vf339[u32(unconst_u32(69))][u32(unconst_u32(61))], vf339[u32(unconst_u32(69))][u32(unconst_u32(61))], vf339[u32(unconst_u32(69))][u32(unconst_u32(61))]);
  let ptr111: ptr<function, mat2x3f> = &vf336;
  vf339 += mat2x3f(bitcast<f32>(pack4xU8(vec4u(u32((*ptr111)[u32(unconst_u32(194))][u32(unconst_u32(21))])))), f32(pack4xU8(vec4u(u32((*ptr111)[u32(unconst_u32(194))][u32(unconst_u32(21))])))), bitcast<f32>(pack4xU8(vec4u(u32((*ptr111)[u32(unconst_u32(194))][u32(unconst_u32(21))])))), f32(pack4xU8(vec4u(u32((*ptr111)[u32(unconst_u32(194))][u32(unconst_u32(21))])))), bitcast<f32>(pack4xU8(vec4u(u32((*ptr111)[u32(unconst_u32(194))][u32(unconst_u32(21))])))), f32(pack4xU8(vec4u(u32((*ptr111)[u32(unconst_u32(194))][u32(unconst_u32(21))])))));
  var vf340 = fn0();
  var vf341 = fn0();
  let vf342: i32 = dot(vec2i(unconst_i32(237), unconst_i32(-18)), vec2i(unconst_i32(181), unconst_i32(69)));
  return out;
}

var<workgroup> vw43: array<VertexOutput8, 1>;

var<workgroup> vw44: mat3x2f;

var<workgroup> vw45: atomic<i32>;

var<workgroup> vw46: array<VertexOutput8, 1>;

@vertex
fn vertex11(@location(15) a0: vec2i, @location(2) a1: vec4h) -> VertexOutput8 {
  var out: VertexOutput8;
  fn0();
  var vf343: f32 = distance(vec4f(unconst_f32(0.04693), unconst_f32(0.1459), unconst_f32(-0.3176), unconst_f32(0.3499)), vec4f(unconst_f32(0.1370), unconst_f32(0.04565), unconst_f32(0.3892), unconst_f32(-0.05213)));
  out.f40 = asinh(vec2f(unconst_f32(0.3705), unconst_f32(0.01658))).rgrg;
  var vf344 = fn1(vec4f(a1));
  out.f40 *= vec4f(f32(log(f16(unconst_f16(9553.6)))));
  return out;
}

@fragment
fn fragment18() -> FragmentOutput12 {
  var out: FragmentOutput12;
  let vf345: u32 = textureNumLevels(tex16);
  out = FragmentOutput12(vec4u(u32(sinh(f16(unconst_f16(-24048.9))))));
  out = FragmentOutput12(textureDimensions(tex16, i32(unconst_i32(-95))).grgg);
  var vf346: vec2f = asinh(vec2f(unconst_f32(0.00045), unconst_f32(0.1438)));
  vf346 = vec2f(textureDimensions(tex16));
  let vf347: u32 = textureNumLevels(tex16);
  var vf348: vec2f = select(vec2f(unconst_f32(0.02304), unconst_f32(0.06601)), vec2f(unconst_f32(0.02901), unconst_f32(-0.3119)), bool(unconst_bool(false)));
  let vf349: vec2u = textureDimensions(tex16, vec2i(insertBits(vec2u(unconst_u32(8), unconst_u32(8)), vec2u(unconst_u32(99), unconst_u32(116)), u32(unconst_u32(86)), u32(unconst_u32(84))))[1]);
  var vf350: f16 = sinh(f16(unconst_f16(3772.5)));
  var vf351: vec2u = textureDimensions(tex16);
  let vf352: u32 = vf345;
  let vf353: u32 = vf349[u32(unconst_u32(331))];
  var vf354: u32 = vf347;
  let ptr112: ptr<function, vec2f> = &vf346;
  var vf355: u32 = vf349[u32(unconst_u32(395))];
  var vf356: vec2u = textureDimensions(tex16, i32(unconst_i32(96)));
  vf356 = vf351;
  var vf357: u32 = vf347;
  let ptr113: ptr<function, vec2u> = &vf356;
  vf356 |= vec2u(vf354);
  vf356 = vec2u(select(vec2f(unconst_f32(0.1035), unconst_f32(0.07768)), vec2f(unconst_f32(0.00452), unconst_f32(0.05839)), bool(unconst_bool(false))));
  let ptr114: ptr<function, u32> = &vf355;
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder96 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  label: '\u0ad0\ue480\u{1feea}\u0ca2',
  size: [1160, 96, 2],
  mipLevelCount: 2,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder81.setBindGroup(0, bindGroup38);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroupsIndirect(buffer26, 152); };
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup33);
} catch {}
try {
commandEncoder96.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 316 */
  offset: 316,
  bytesPerRow: 2560,
  buffer: buffer48,
}, {
  texture: texture96,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture104 = device0.createTexture({
  size: {width: 64, height: 64, depthOrArrayLayers: 18},
  dimension: '2d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture105 = device0.createTexture({
  size: {width: 145, height: 12, depthOrArrayLayers: 119},
  sampleCount: 1,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler67 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 12.30,
  compare: 'always',
});
try {
computePassEncoder30.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, undefined);
} catch {}
let buffer57 = device0.createBuffer({size: 23445, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let texture106 = device0.createTexture({size: {width: 580}, dimension: '1d', format: 'rgba8unorm-srgb', usage: GPUTextureUsage.COPY_SRC});
let textureView76 = texture95.createView({dimension: '2d', baseArrayLayer: 4});
try {
renderPassEncoder18.setBindGroup(0, bindGroup15, new Uint32Array(1601), 317, 0);
} catch {}
try {
renderPassEncoder20.setIndexBuffer(buffer12, 'uint16', 106, 47);
} catch {}
try {
commandEncoder12.copyBufferToTexture({
  /* bytesInLastRow: 420 widthInBlocks: 105 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1272 */
  offset: 1272,
  bytesPerRow: 15872,
  rowsPerImage: 38,
  buffer: buffer43,
}, {
  texture: texture102,
  mipLevel: 0,
  origin: {x: 93, y: 8, z: 0},
  aspect: 'all',
}, {width: 105, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder12.clearBuffer(buffer31, 464, 128);
} catch {}
try {
globalThis.someLabel = externalTexture10.label;
} catch {}
let commandEncoder97 = device0.createCommandEncoder({});
let textureView77 = texture19.createView({dimension: '2d'});
let renderPassEncoder24 = commandEncoder95.beginRenderPass({
  label: '\u1f86\uc485\ud876\u{1ffd6}\u8bec\u0668\u041a\u9796\u0b5a\u042d\u23c2',
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: 39.71, g: -180.5, b: 941.2, a: -895.5, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroupsIndirect(buffer22, 8_168); };
} catch {}
let gpuCanvasContext3 = canvas0.getContext('webgpu');
document.body.append(img1);
try {
adapter0.label = '\u{1fdc6}\u43e0\u95f7\u3ec2\u{1f737}\udb38';
} catch {}
let commandEncoder98 = device0.createCommandEncoder({});
let computePassEncoder88 = commandEncoder98.beginComputePass();
let externalTexture12 = device0.importExternalTexture({source: videoFrame11, colorSpace: 'display-p3'});
try {
computePassEncoder42.setBindGroup(2, bindGroup38);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup20);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle8, renderBundle8]);
} catch {}
try {
renderPassEncoder11.setBlendConstant({ r: -56.10, g: 643.9, b: -74.10, a: 38.91, });
} catch {}
try {
computePassEncoder56.popDebugGroup();
} catch {}
let commandEncoder99 = device0.createCommandEncoder({});
let texture107 = device0.createTexture({
  size: {width: 145, height: 12, depthOrArrayLayers: 21},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView78 = texture67.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0});
let renderPassEncoder25 = commandEncoder96.beginRenderPass({
  label: '\u1f7a\u7d09\ud52c\ue113\u{1fb48}\u{1f9c3}\u{1fd48}\u9ff4',
  colorAttachments: [{
  view: textureView46,
  clearValue: { r: -434.0, g: 619.8, b: 423.2, a: 902.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
let sampler68 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 8.946,
  lodMaxClamp: 23.12,
});
try {
{ clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroupsIndirect(buffer26, 576); };
} catch {}
try {
computePassEncoder29.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder18.setBindGroup(2, bindGroup36, new Uint32Array(1347), 700, 0);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle10, renderBundle10]);
} catch {}
try {
commandEncoder12.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1200 */
  offset: 1200,
  bytesPerRow: 6912,
  buffer: buffer35,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder100 = device0.createCommandEncoder({});
let texture108 = device0.createTexture({
  size: {width: 52, height: 1, depthOrArrayLayers: 81},
  mipLevelCount: 2,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder46.setBindGroup(0, bindGroup34);
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup43, new Uint32Array(1105), 103, 0);
} catch {}
try {
commandEncoder12.copyTextureToTexture({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture30,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img2);
let commandEncoder101 = device0.createCommandEncoder({label: '\u51c2\u{1f856}\ucacd\u0177'});
let texture109 = device0.createTexture({
  label: '\u{1fc7d}\u9d68\u4c4b\u09f8\u{1fcda}\u{1f9f9}\u{1fb87}\u9d32',
  size: [64],
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
renderPassEncoder14.setBindGroup(3, bindGroup48);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer28, 'uint16', 1_294, 2_579);
} catch {}
try {
commandEncoder97.copyBufferToTexture({
  /* bytesInLastRow: 468 widthInBlocks: 117 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2744 */
  offset: 2744,
  bytesPerRow: 15360,
  buffer: buffer1,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 23, y: 10, z: 0},
  aspect: 'all',
}, {width: 117, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let bindGroup53 = device0.createBindGroup({
  label: '\u1f88\u{1fb67}\u{1f76a}\u52c1\u{1fe21}\uec66\u{1f700}\u{1f81d}\u7d14\u81bf\uec62',
  layout: bindGroupLayout5,
  entries: [{binding: 156, resource: textureView73}],
});
let commandBuffer5 = commandEncoder12.finish();
let texture110 = device0.createTexture({
  size: [105, 1, 14],
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView79 = texture82.createView({
  label: '\u0981\u5c1d\u04ec\u6302',
  aspect: 'all',
  mipLevelCount: 1,
  baseArrayLayer: 0,
  arrayLayerCount: 1,
});
let renderPassEncoder26 = commandEncoder99.beginRenderPass({
  colorAttachments: [{
  view: textureView23,
  clearValue: { r: -767.1, g: -610.1, b: 88.86, a: -840.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet5,
});
try {
renderPassEncoder2.setIndexBuffer(buffer12, 'uint16', 12, 213);
} catch {}
try {
commandEncoder97.copyBufferToBuffer(buffer27, 104, buffer53, 3256, 64);
} catch {}
try {
commandEncoder100.insertDebugMarker('\uc400');
} catch {}
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt709', transfer: 'hlg'} });
try {
globalThis.someLabel = sampler63.label;
} catch {}
let bindGroup54 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [{binding: 258, resource: textureView70}, {binding: 91, resource: sampler5}],
});
let buffer58 = device0.createBuffer({
  label: '\uf571\u408b\u3fbe\u{1f7b0}\u8c42\u{1fb95}',
  size: 2849,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder102 = device0.createCommandEncoder({});
let computePassEncoder89 = commandEncoder97.beginComputePass();
try {
computePassEncoder73.end();
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup17);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer34, 'uint16', 1_314, 1_248);
} catch {}
try {
buffer52.unmap();
} catch {}
let img3 = await imageWithData(2, 46, '#10101010', '#20202020');
let imageBitmap3 = await createImageBitmap(canvas0);
let commandBuffer6 = commandEncoder75.finish();
let texture111 = device0.createTexture({
  label: '\ucece\u0923\u44ea\u2448\u2085\u6c28\u8b06',
  size: {width: 52, height: 1, depthOrArrayLayers: 20},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture112 = gpuCanvasContext2.getCurrentTexture();
let textureView80 = texture97.createView({dimension: '2d', baseArrayLayer: 0});
let sampler69 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 11.62,
});
try {
computePassEncoder88.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder23.setBindGroup(3, bindGroup48);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle8, renderBundle3, renderBundle8, renderBundle8]);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer12, 'uint16', 20, 30);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(6, buffer26, 0);
} catch {}
let buffer59 = device0.createBuffer({size: 11470, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX});
try {
computePassEncoder83.setBindGroup(2, bindGroup37, new Uint32Array(808), 296, 0);
} catch {}
try {
renderPassEncoder11.setViewport(224.28595032726574, 7.512810423084466, 32.936200367797994, 1.3331626197390984, 0.29021048179302855, 0.8559704991022343);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let bindGroup55 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView64}]});
let commandEncoder103 = device0.createCommandEncoder({});
let computePassEncoder90 = commandEncoder101.beginComputePass({});
try {
computePassEncoder89.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer21, 'uint32', 408, 70);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
commandEncoder100.resolveQuerySet(querySet1, 1700, 0, buffer19, 7680);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer60 = device0.createBuffer({
  label: '\uf510\u0ec0\u{1f7a3}\ue3e3\u1c2a\u{1f8d0}\u1afb',
  size: 251,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
});
let texture113 = device0.createTexture({
  size: [52, 1, 51],
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView81 = texture80.createView({label: '\ue39e\u{1ff15}\u38b9\ud1bc', dimension: '2d'});
let computePassEncoder91 = commandEncoder100.beginComputePass({});
let renderPassEncoder27 = commandEncoder103.beginRenderPass({
  colorAttachments: [{
  view: textureView65,
  depthSlice: 1,
  clearValue: { r: -983.4, g: 656.6, b: 909.7, a: -145.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet2,
});
try {
computePassEncoder87.setBindGroup(0, bindGroup17, []);
} catch {}
try {
computePassEncoder31.setBindGroup(2, bindGroup45, new Uint32Array(489), 125, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder18.setBlendConstant({ r: -885.3, g: -316.3, b: -249.5, a: 296.8, });
} catch {}
try {
renderPassEncoder2.setScissorRect(2, 0, 0, 0);
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer61 = device0.createBuffer({size: 7807, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView82 = texture88.createView({format: 'r32float'});
let renderPassEncoder28 = commandEncoder102.beginRenderPass({
  colorAttachments: [{
  view: textureView72,
  clearValue: { r: -623.5, g: 245.3, b: -19.67, a: -261.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 440685292,
});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: [undefined], depthReadOnly: true, stencilReadOnly: true});
let sampler70 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 68.86,
  lodMaxClamp: 82.93,
});
let commandEncoder104 = device0.createCommandEncoder();
let sampler71 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 18.53,
  lodMaxClamp: 38.03,
  maxAnisotropy: 7,
});
try {
renderPassEncoder26.beginOcclusionQuery(2);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer5, 'uint32', 76, 73);
} catch {}
let computePassEncoder92 = commandEncoder104.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder87); computePassEncoder87.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder87.end();
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer35, 'uint32', 620, 381);
} catch {}
let computePassEncoder93 = commandEncoder92.beginComputePass({});
try {
computePassEncoder71.setBindGroup(1, bindGroup13);
} catch {}
try {
computePassEncoder80.setBindGroup(3, bindGroup40, new Uint32Array(956), 163, 0);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer37, 'uint32', 1_544, 104);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(5, buffer44, 836, 1_922);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup24, new Uint32Array(3114), 97, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer12, 'uint32', 36, 176);
} catch {}
let canvas1 = document.createElement('canvas');
let bindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 66,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 83,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 90,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 17,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let texture114 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 64},
  sampleCount: 1,
  format: 'rgba8snorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], depthReadOnly: false});
try {
computePassEncoder29.setBindGroup(0, bindGroup49, new Uint32Array(6371), 984, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder93.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder12.setScissorRect(23, 0, 0, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer32, 'uint32', 4_060, 1_457);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(6, buffer26, 0, 59);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup34);
} catch {}
try {
computePassEncoder36.popDebugGroup();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let bindGroupLayout10 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 64,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 196, hasDynamicOffset: false },
    },
    {
      binding: 327,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 314,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: true },
    },
    {
      binding: 153,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder105 = device0.createCommandEncoder();
let textureView83 = texture114.createView({baseMipLevel: 0, baseArrayLayer: 13, arrayLayerCount: 4});
let computePassEncoder94 = commandEncoder105.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder26.endOcclusionQuery();
} catch {}
try {
renderPassEncoder28.setVertexBuffer(5, buffer5, 116, 53);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup12, new Uint32Array(3729), 169, 0);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(3, undefined, 0, 896_649_796);
} catch {}
try {
buffer17.unmap();
} catch {}
let commandEncoder106 = device0.createCommandEncoder();
let sampler72 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 16.91,
  lodMaxClamp: 70.63,
});
try {
computePassEncoder55.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder92.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup16, new Uint32Array(1307), 644, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle8]);
} catch {}
try {
renderPassEncoder10.setViewport(4.719277903552202, 18.353747337794424, 160.12746799453274, 2.420813121724243, 0.6310227801332455, 0.6875430152891493);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 4}
*/
{
  source: videoFrame4,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup56 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 64, resource: {buffer: buffer39, offset: 768, size: 11952}},
    {binding: 314, resource: {buffer: buffer10, offset: 1792}},
    {binding: 327, resource: {buffer: buffer24, offset: 1024, size: 1162}},
    {binding: 153, resource: textureView77},
  ],
});
let buffer62 = device0.createBuffer({size: 44500, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let commandEncoder107 = device0.createCommandEncoder({});
let texture115 = device0.createTexture({
  size: [26, 1, 1],
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler73 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 61.51,
  lodMaxClamp: 80.58,
});
try {
computePassEncoder75.setBindGroup(0, bindGroup38, new Uint32Array(828), 33, 0);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(7, buffer53, 0);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup44);
} catch {}
let arrayBuffer2 = buffer31.getMappedRange(16, 0);
let commandEncoder108 = device0.createCommandEncoder();
let texture116 = device0.createTexture({
  size: {width: 1160, height: 96, depthOrArrayLayers: 2},
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle12 = renderBundleEncoder13.finish({});
try {
renderBundleEncoder12.setVertexBuffer(3, buffer8, 0);
} catch {}
let shaderModule17 = device0.createShaderModule({
  label: '\u3944\u9488\u0d0d\u1b89\ub6cb\udc87\u{1f9e4}\u07ff\u7927',
  code: `
enable f16;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(184) var tex17: texture_cube<i32>;

struct T0 {
  @align(16) @size(640) f0: mat4x2f,
  @size(2816) f1: array<vec4h, 9>,
  @align(8) @size(128) f2: array<array<array<vec2h, 1>, 1>, 1>,
  @align(32) @size(1408) f3: mat4x3f,
  @align(16) @size(128) f4: mat2x2f,
  @align(8) @size(1152) f5: array<f32, 1>,
  @align(128) @size(5376) f6: mat3x4h,
}

struct T1 {
  @size(16) f0: array<vec2h, 1>,
  @size(96) f1: mat3x4f,
}

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

struct VertexOutput10 {
  @location(0) f42: vec4i,
  @builtin(position) f43: vec4f,
  @location(3) @interpolate(flat, centroid) f44: u32,
}

struct S4 {
  @location(7) f0: vec4u,
  @location(13) @interpolate(linear, sample) f1: vec2h,
  @location(14) f2: vec2f,
  @location(11) @interpolate(flat, centroid) f3: i32,
  @location(12) @interpolate(linear, centroid) f4: f32,
}

struct FragmentOutput13 {
  @location(0) f0: f32,
}

override override13: i32;

@id(37031) override override14 = false;

@id(51159) override override15: f16;

override override16 = true;

@id(48107) override override17: u32 = 65;

fn fn0() -> array<u32, 9> {
  var out: array<u32, 9>;
  var vf358: vec4f = round(vec4f(unconst_f32(0.05971), unconst_f32(0.02704), unconst_f32(0.1550), unconst_f32(0.1326)));
  var vf359: vec2h = round(vec2h(unconst_f16(3280.1), unconst_f16(12933.9)));
  vf359 = vec2h(log2(vec3f(unconst_f32(0.6581), unconst_f32(0.3409), unconst_f32(0.2191))).rg);
  let vf360: f32 = vf358[u32(vf359[u32(unconst_u32(37))])];
  let vf361: u32 = override17;
  var vf362: vec2h = round(vec2h(unconst_f16(31727.0), unconst_f16(11245.6)));
  let vf363: vec2f = cos(vec2f(unconst_f32(0.1417), unconst_f32(0.1693)));
  out[u32(unconst_u32(192))] = u32(vf362[u32(unconst_u32(92))]);
  let vf364: bool = override14;
  vf359 = bitcast<vec2h>(vf363[u32(unconst_u32(5))]);
  vf359 = vec2h(cos(vec2f(unconst_f32(0.1304), unconst_f32(0.2192))));
  vf359 -= bitcast<vec2h>(vf360);
  vf359 = vec2h(vf358.wx);
  out[u32(unconst_u32(505))] *= bitcast<u32>(vf363[u32(unconst_u32(147))]);
  vf359 = bitcast<vec2h>(vf363[bitcast<u32>(round(vec2h(unconst_f16(5885.8), unconst_f16(11913.4))))]);
  var vf365: f32 = vf363[u32(unconst_u32(202))];
  let vf366: f16 = override15;
  let vf367: vec2f = cos(vec2f(unconst_f32(0.2895), unconst_f32(0.3962)));
  vf358 += vf358;
  vf362 += reflect(vec2h(vf363), vec2h(unconst_f16(4614.4), unconst_f16(8167.4)));
  let vf368: vec2h = round(vec2h(unconst_f16(23017.9), unconst_f16(21877.6)));
  let ptr115: ptr<function, f32> = &vf365;
  let ptr116: ptr<function, f32> = &vf365;
  var vf369: vec3f = log2(vec3f(unconst_f32(-0.02196), unconst_f32(0.05196), unconst_f32(0.05612)));
  out[u32(unconst_u32(53))] = u32(override15);
  return out;
  _ = override14;
  _ = override15;
  _ = override17;
}

fn fn1(a0: ptr<storage, array<FragmentOutput13>, read>) -> f16 {
  var out: f16;
  out = f16(cosh(vec3f(unconst_f32(0.1091), unconst_f32(0.01937), unconst_f32(0.06801))).g);
  out *= pow(vec3h(unconst_f16(4691.6), unconst_f16(6167.4), unconst_f16(354.8)), vec3h(unconst_f16(9499.8), unconst_f16(8229.9), unconst_f16(19570.2)))[2];
  out -= f16(firstLeadingBit(u32(unconst_u32(291))));
  fn0();
  out = vec2h(countOneBits(vec2i(unconst_i32(-139), unconst_i32(87))))[0];
  let vf370: u32 = firstLeadingBit(vec3u(ceil(vec3h(unconst_f16(2059.9), unconst_f16(25255.1), unconst_f16(-41185.1)))).b);
  out = f16((*a0)[arrayLength(&(*a0)) - 1].f0);
  let vf371: i32 = override13;
  var vf372: u32 = override17;
  out = distance(f16(unconst_f16(1368.3)), f16(unconst_f16(27665.3)));
  fn0();
  fn0();
  var vf373: vec2u = textureDimensions(tex17, i32(unconst_i32(396)));
  var vf374: f16 = log2(f16(unconst_f16(8500.7)));
  vf373 >>= vec2u(u32(override14));
  fn0();
  vf373 = textureDimensions(tex17, i32(unconst_i32(36)));
  fn0();
  vf373 -= vec2u(ceil(vec3h(vf374)).bb);
  let ptr117: ptr<storage, FragmentOutput13, read> = &(*a0)[arrayLength(&(*a0))];
  out = sin(vec4h(unconst_f16(17395.7), unconst_f16(6446.2), unconst_f16(17593.7), unconst_f16(14359.2)))[1];
  return out;
  _ = override13;
  _ = override14;
  _ = override17;
  _ = override15;
}

var<workgroup> vw47: vec2<bool>;

var<workgroup> vw48: array<atomic<i32>, 6>;

var<workgroup> vw49: VertexOutput9;

@vertex
fn vertex12(@builtin(vertex_index) a0: u32, @location(12) @interpolate(flat) a1: vec4i, @location(4) a2: vec2i) -> VertexOutput9 {
  var out: VertexOutput9;
  out.f41 -= vec4f(f32(override14));
  var vf375: vec3h = ldexp(vec3h(unconst_f16(3760.9), unconst_f16(2587.3), unconst_f16(15250.4)), vec3i(unconst_i32(467), unconst_i32(34), unconst_i32(63)));
  let vf376: u32 = pack2x16unorm(vec2f(unconst_f32(0.2647), unconst_f32(0.4075)));
  out.f41 = quantizeToF16(vec2f(unconst_f32(0.9290), unconst_f32(0.04455))).grgg;
  let vf377: vec4f = unpack4x8snorm(u32(unconst_u32(147)));
  var vf378: vec3i = countTrailingZeros(vec3i(unconst_i32(407), unconst_i32(299), unconst_i32(394)));
  let ptr118: ptr<function, vec3i> = &vf378;
  let vf379: vec4h = atanh(vec4h(unconst_f16(4244.3), unconst_f16(15681.2), unconst_f16(893.7), unconst_f16(1805.4)));
  return out;
  _ = override14;
}

@vertex
fn vertex13() -> VertexOutput10 {
  var out: VertexOutput10;
  out.f43 += unpack4x8unorm(pack4x8unorm(vec4f(unconst_f32(0.01395), unconst_f32(0.3159), unconst_f32(0.04468), unconst_f32(0.3303))));
  var vf380: f16 = override15;
  var vf381: bool = override16;
  return out;
  _ = override15;
  _ = override16;
}

@fragment
fn fragment19(@location(8) @interpolate(perspective, center) a0: f32, @location(5) a1: i32, a2: S4) -> FragmentOutput13 {
  var out: FragmentOutput13;
  var vf382 = fn0();
  out.f0 = bitcast<f32>(textureDimensions(tex17).r);
  let vf383: f16 = override15;
  var vf384: vec3h = asin(vec3h(vf383));
  var vf385: f16 = round(f16(unconst_f16(6671.6)));
  vf382[u32(unconst_u32(668))] += textureDimensions(tex17, i32(unconst_i32(392)))[0];
  vf384 = a2.f1.rrg;
  out.f0 *= f32(override15);
  var vf386: u32 = pack4x8snorm(vec4f(unconst_f32(0.02382), unconst_f32(0.01111), unconst_f32(0.02156), unconst_f32(0.2025)));
  out = FragmentOutput13(f32(vf383));
  let ptr119: ptr<function, u32> = &vf386;
  let ptr120: ptr<function, vec3h> = &vf384;
  vf384 -= vf384;
  out = FragmentOutput13(f32(all(vec2<bool>(unconst_bool(true), unconst_bool(true)))));
  vf386 <<= vf382[8];
  let vf387: f32 = a2.f4;
  var vf388: bool = override16;
  var vf389: f16 = round(f16(unconst_f16(2219.7)));
  vf386 <<= a2.f0[u32(unconst_u32(322))];
  vf386 += vf382[u32(unconst_u32(504))];
  let ptr121: ptr<function, f16> = &vf385;
  vf382[8] |= u32(override16);
  return out;
  _ = override14;
  _ = override15;
  _ = override17;
  _ = override16;
}`,
  hints: {},
});
let bindGroup57 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView7}]});
let textureView84 = texture114.createView({baseArrayLayer: 6, arrayLayerCount: 3});
let texture117 = device0.createTexture({
  size: [145, 12, 2],
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView85 = texture112.createView({dimension: '2d-array', arrayLayerCount: 1});
let externalTexture13 = device0.importExternalTexture({source: videoFrame10});
try {
renderBundleEncoder12.setBindGroup(0, bindGroup48);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 18}
*/
{
  source: videoFrame11,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 21, y: 10, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
globalThis.someLabel = externalTexture12.label;
} catch {}
try {
computePassEncoder53.setBindGroup(1, bindGroup52);
} catch {}
try {
computePassEncoder94.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup30, new Uint32Array(819), 93, 0);
} catch {}
let computePassEncoder95 = commandEncoder108.beginComputePass({});
let renderPassEncoder29 = commandEncoder107.beginRenderPass({
  colorAttachments: [{view: textureView26, loadOp: 'clear', storeOp: 'discard'}],
  maxDrawCount: 583712779,
});
let renderBundle13 = renderBundleEncoder12.finish({});
let sampler74 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 51.44,
  lodMaxClamp: 92.75,
  compare: 'greater-equal',
});
try {
computePassEncoder57.setBindGroup(3, bindGroup12, new Uint32Array(143), 1, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder91.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup38);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder14.setViewport(32.787706533561355, 3.6653814779324216, 121.53481513318565, 12.228501081060289, 0.04883688145201048, 0.3606059293961175);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer44, 'uint16', 17_466, 629);
} catch {}
let commandEncoder109 = device0.createCommandEncoder({});
let computePassEncoder96 = commandEncoder109.beginComputePass({});
try {
computePassEncoder96.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(0, buffer35, 0, 72);
} catch {}
try {
commandEncoder106.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 516 */
  offset: 516,
  bytesPerRow: 4096,
  buffer: buffer1,
}, {
  texture: texture91,
  mipLevel: 0,
  origin: {x: 36, y: 6, z: 0},
  aspect: 'all',
}, {width: 3, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder106.resolveQuerySet(querySet2, 37, 46, buffer34, 1024);
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'film', transfer: 'bt709'} });
let bindGroup58 = device0.createBindGroup({
  layout: bindGroupLayout4,
  entries: [{binding: 409, resource: {buffer: buffer1, offset: 3584, size: 4830}}],
});
let texture118 = device0.createTexture({
  size: [105, 1, 40],
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder97 = commandEncoder106.beginComputePass();
try {
computePassEncoder0.setBindGroup(0, bindGroup10, new Uint32Array(1055), 237, 0);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer29, 0, 224);
} catch {}
let buffer63 = device0.createBuffer({
  size: 8816,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let textureView86 = texture77.createView({baseMipLevel: 0});
try {
renderPassEncoder22.setBindGroup(2, bindGroup29);
} catch {}
let promise14 = shaderModule14.getCompilationInfo();
let bindGroup59 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 90, resource: textureView84},
    {binding: 83, resource: {buffer: buffer1, offset: 11520, size: 10168}},
    {binding: 17, resource: textureView74},
    {binding: 66, resource: {buffer: buffer30, offset: 0, size: 712}},
  ],
});
let commandEncoder110 = device0.createCommandEncoder({label: '\u0e6c\u01a1\u91f0\uff4d\u088c\ud0df\ub227'});
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer60, 24); };
} catch {}
try {
renderPassEncoder25.setBindGroup(2, bindGroup16, new Uint32Array(1704), 323, 0);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer32, 'uint32', 9_352, 1_189);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(2, buffer52, 400, 159);
} catch {}
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470bg', transfer: 'logSqrt'} });
let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout9]});
let buffer64 = device0.createBuffer({size: 12787, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
let computePassEncoder98 = commandEncoder110.beginComputePass();
try {
computePassEncoder29.end();
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder6.setViewport(9.253136270371716, 0.36785170172805504, 11.104404084222725, 0.2684582426402854, 0.7237490722967131, 0.9410773889505808);
} catch {}
try {
renderPassEncoder20.setVertexBuffer(4, buffer5, 0);
} catch {}
try {
commandEncoder27.resolveQuerySet(querySet7, 0, 21, buffer11, 512);
} catch {}
try {
device0.queue.submit([commandBuffer6]);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer65 = device0.createBuffer({
  size: 16020,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder111 = device0.createCommandEncoder({});
let computePassEncoder99 = commandEncoder27.beginComputePass({});
try {
computePassEncoder75.setBindGroup(0, bindGroup18);
} catch {}
try {
computePassEncoder97.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer5, 'uint32', 60, 17);
} catch {}
try {
commandEncoder111.resolveQuerySet(querySet7, 13, 3, buffer65, 4352);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let commandEncoder112 = device0.createCommandEncoder({});
let texture119 = device0.createTexture({
  size: {width: 1160, height: 96, depthOrArrayLayers: 2},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture120 = device0.createTexture({
  size: {width: 1160, height: 96, depthOrArrayLayers: 2},
  mipLevelCount: 4,
  sampleCount: 1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC,
});
let renderPassEncoder30 = commandEncoder112.beginRenderPass({
  colorAttachments: [{
  view: textureView23,
  clearValue: { r: 943.7, g: -381.8, b: 535.2, a: 724.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet7,
});
try {
computePassEncoder66.setBindGroup(0, bindGroup57, []);
} catch {}
try {
computePassEncoder98.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer17, 'uint32', 1_116, 306);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(3, buffer50, 500, 4_041);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder111.copyTextureToBuffer({
  texture: texture109,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 100 widthInBlocks: 25 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 64 */
  offset: 64,
  rowsPerImage: 309,
  buffer: buffer18,
}, {width: 25, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\uef18\u0b10\u{1f648}\u{1f6dc}\u{1fccf}\u1342\u434f\u0825\u6df0\u7276\u{1f630}';
} catch {}
let buffer66 = device0.createBuffer({
  size: 2144,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let renderPassEncoder31 = commandEncoder111.beginRenderPass({
  label: '\u{1ff11}\u0b65\u{1fc04}\u0d7d\u8a6e\ub4f9',
  colorAttachments: [{
  view: textureView23,
  clearValue: { r: -153.8, g: -811.0, b: -114.4, a: -628.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler75 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 66.95,
  lodMaxClamp: 78.00,
  compare: 'not-equal',
});
try {
renderPassEncoder10.beginOcclusionQuery(21);
} catch {}
try {
renderPassEncoder10.endOcclusionQuery();
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(2, buffer10);
} catch {}
let bindGroup60 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 314, resource: {buffer: buffer53, offset: 4352, size: 12008}},
    {binding: 327, resource: {buffer: buffer63, offset: 1792, size: 614}},
    {binding: 153, resource: textureView2},
    {binding: 64, resource: {buffer: buffer22, offset: 5376, size: 752}},
  ],
});
let commandEncoder113 = device0.createCommandEncoder({});
let texture121 = device0.createTexture({
  size: {width: 26},
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder100 = commandEncoder113.beginComputePass();
try {
computePassEncoder89.setBindGroup(2, bindGroup30, new Uint32Array(369), 163, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder66); computePassEncoder66.dispatchWorkgroupsIndirect(buffer52, 92); };
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer50, 'uint32', 2_432, 1_081);
} catch {}
try {
device0.queue.writeBuffer(buffer51, 5580, new BigUint64Array(10927), 991, 112);
} catch {}
let texture122 = device0.createTexture({
  size: {width: 145},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView87 = texture40.createView({mipLevelCount: 1});
try {
computePassEncoder58.setBindGroup(2, bindGroup1, new Uint32Array(405), 41, 0);
} catch {}
let sampler76 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 41.86,
  maxAnisotropy: 1,
});
try {
computePassEncoder0.setBindGroup(0, bindGroup55);
} catch {}
try {
computePassEncoder90.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup27, []);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(5, buffer33, 0, 10_272);
} catch {}
let buffer67 = device0.createBuffer({
  size: 6931,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder114 = device0.createCommandEncoder({label: '\u694f\u0dc5\u0857\u0da1\u029d'});
let texture123 = device0.createTexture({
  size: [210],
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView88 = texture5.createView({dimension: '2d'});
let computePassEncoder101 = commandEncoder114.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder66); computePassEncoder66.dispatchWorkgroupsIndirect(buffer28, 536); };
} catch {}
try {
computePassEncoder95.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(6, buffer50, 0, 894);
} catch {}
try {
computePassEncoder26.insertDebugMarker('\uaa88');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 100}
*/
{
  source: imageData10,
  origin: { x: 1, y: 8 },
  flipY: false,
}, {
  texture: texture90,
  mipLevel: 1,
  origin: {x: 11, y: 0, z: 22},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let bindGroup61 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [
    {binding: 66, resource: {buffer: buffer14, offset: 8448, size: 11928}},
    {binding: 17, resource: textureView80},
    {binding: 83, resource: {buffer: buffer65, offset: 1280}},
    {binding: 90, resource: textureView84},
  ],
});
let buffer68 = device0.createBuffer({size: 1437, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
try {
{ clearResourceUsages(device0, computePassEncoder66); computePassEncoder66.dispatchWorkgroups(1, 1, 1); };
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup26, new Uint32Array(192), 13, 0);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer27, 4, new BigUint64Array(8105), 909, 0);
} catch {}
let bindGroup62 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 409, resource: {buffer: buffer34, offset: 0}}]});
let texture124 = device0.createTexture({
  label: '\u{1f7ad}\uc58b\ub2eb\u{1f749}',
  size: [210, 1, 40],
  mipLevelCount: 5,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler77 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMaxClamp: 88.07,
});
try {
computePassEncoder57.setBindGroup(3, bindGroup9);
} catch {}
try {
computePassEncoder101.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(1, bindGroup59, new Uint32Array(1496), 84, 0);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer37, 'uint32', 28, 318);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer57, 3024, new DataView(new ArrayBuffer(9165)), 6858, 872);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 1, depthOrArrayLayers: 64}
*/
{
  source: imageData10,
  origin: { x: 1, y: 4 },
  flipY: true,
}, {
  texture: texture92,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 15},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(28, 19);
let commandEncoder115 = device0.createCommandEncoder();
let computePassEncoder102 = commandEncoder115.beginComputePass({label: '\uf8ea\u489a\u0eda\u0136\u89d2\uac16\u{1fa30}\u9a7b\u{1f7b2}\u{1f72c}\u{1fbeb}'});
let buffer69 = device0.createBuffer({size: 6658, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
try {
computePassEncoder17.setBindGroup(3, bindGroup27);
} catch {}
try {
renderPassEncoder30.setIndexBuffer(buffer60, 'uint16', 80, 24);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(0, buffer68, 0);
} catch {}
await gc();
let commandEncoder116 = device0.createCommandEncoder({});
let computePassEncoder103 = commandEncoder116.beginComputePass();
let sampler78 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 59.90,
  lodMaxClamp: 78.51,
  compare: 'less-equal',
  maxAnisotropy: 1,
});
try {
computePassEncoder40.setBindGroup(0, bindGroup28, []);
} catch {}
try {
computePassEncoder0.setBindGroup(0, bindGroup8, new Uint32Array(1176), 58, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer37, 124); };
} catch {}
let gpuCanvasContext4 = canvas1.getContext('webgpu');
let shaderModule18 = device0.createShaderModule({
  code: `
enable f16;

enable f16;

requires pointer_composite_access;

requires readonly_and_readwrite_storage_textures;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(184) var tex18: texture_cube<i32>;

struct T0 {
  @size(112) f0: mat2x3h,
}

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

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

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

struct FragmentOutput14 {
  @location(0) @interpolate(flat) f0: vec4f,
}

var<workgroup> vw50: T3;

var<workgroup> vw51: FragmentOutput14;

var<workgroup> vw52: mat4x2f;

var<workgroup> vw53: atomic<u32>;

var<workgroup> vw54: atomic<i32>;

var<workgroup> vw55: atomic<u32>;

var<workgroup> vw56: atomic<u32>;

var<private> vp19 = modf(vec3f(0.1090, -0.1068, 0.2901));

var<private> vp20 = modf(f16(-551.1));

var<private> vp21: FragmentOutput14 = FragmentOutput14(vec4f(0.4288, 0.2895, 0.05076, -0.1866));

@fragment
fn fragment20() -> FragmentOutput14 {
  var out: FragmentOutput14;
  vp20 = modf(vec4h(smoothstep(vec4f(unconst_f32(0.04263), unconst_f32(0.03095), unconst_f32(0.04220), unconst_f32(0.04983)), vec4f(transpose(mat4x3h())[unconst_i32(0)]), vec4f(unconst_f32(0.2524), unconst_f32(0.01421), unconst_f32(0.1329), unconst_f32(0.08458))))[1]);
  let vf390: vec2u = max(vec2u(unconst_u32(68), unconst_u32(35)), vec2u(unconst_u32(96), unconst_u32(158)));
  vp20 = modf(f16(pack4xI8(vec4i(unconst_i32(36), unconst_i32(481), unconst_i32(-405), unconst_i32(61)))));
  vp21 = FragmentOutput14(smoothstep(vec4f(unconst_f32(0.6077), unconst_f32(0.2616), unconst_f32(0.2371), unconst_f32(0.1199)), vec4f(unconst_f32(0.3332), unconst_f32(0.1858), unconst_f32(0.2443), unconst_f32(0.00957)), vec4f(unconst_f32(0.03194), unconst_f32(0.1938), unconst_f32(-0.02962), unconst_f32(0.4902))));
  out = FragmentOutput14(vp19.fract.rrgr);
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 111,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 52,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let texture125 = device0.createTexture({
  size: {width: 52, height: 1, depthOrArrayLayers: 9},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView89 = texture83.createView({mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder67.setBindGroup(1, bindGroup34);
} catch {}
try {
computePassEncoder103.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer29, 'uint16', 1_588, 373);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer33);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext5 = offscreenCanvas3.getContext('webgpu');
let bindGroup63 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 156, resource: textureView23}]});
let commandEncoder117 = device0.createCommandEncoder({label: '\ub51c\u{1fefd}\u{1f7e3}\u08b6\u{1fcac}\u7d6f\u{1f991}'});
let textureView90 = texture66.createView({arrayLayerCount: 1});
let computePassEncoder104 = commandEncoder117.beginComputePass();
try {
renderPassEncoder1.setStencilReference(85);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(4, buffer53);
} catch {}
try {
buffer26.unmap();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let texture126 = device0.createTexture({
  size: {width: 290, height: 24, depthOrArrayLayers: 53},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let sampler79 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 70.99,
  maxAnisotropy: 12,
});
try {
computePassEncoder42.setBindGroup(0, bindGroup27);
} catch {}
try {
computePassEncoder30.setBindGroup(0, bindGroup11, new Uint32Array(1743), 192, 0);
} catch {}
try {
computePassEncoder0.end();
} catch {}
try {
computePassEncoder104.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setBlendConstant({ r: -441.3, g: -209.1, b: -935.0, a: -685.5, });
} catch {}
try {
commandEncoder0.copyBufferToBuffer(buffer64, 1212, buffer59, 3060, 1116);
} catch {}
try {
commandEncoder0.copyTextureToBuffer({
  texture: texture44,
  mipLevel: 0,
  origin: {x: 206, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 196 widthInBlocks: 49 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 140 */
  offset: 140,
  buffer: buffer2,
}, {width: 49, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let shaderModule19 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

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

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

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

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

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

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

struct VertexOutput11 {
  @invariant @builtin(position) f45: vec4f,
  @location(9) f46: vec4h,
}

@id(59661) override override18: i32;

fn fn0() -> VertexOutput11 {
  var out: VertexOutput11;
  out = VertexOutput11(unpack2x16float(u32(unconst_u32(164))).gggr, bitcast<vec4h>(unpack2x16float(u32(unconst_u32(164)))));
  let vf391: vec3h = tan(vec3h(unconst_f16(16207.5), unconst_f16(2917.9), unconst_f16(7934.4)));
  var vf392: vec3f = ldexp(vec3f(unconst_f32(0.1029), unconst_f32(0.2348), unconst_f32(0.3666)), vec3i(unconst_i32(279), unconst_i32(36), unconst_i32(103)));
  out.f46 = vec4h(f16(override18));
  out.f46 = vf391.xzzx;
  let vf393: vec4f = ceil(vec4f(unconst_f32(0.08363), unconst_f32(0.08284), unconst_f32(0.8193), unconst_f32(0.04740)));
  let vf394: u32 = dot4U8Packed(u32(unconst_u32(176)), u32(unconst_u32(208)));
  var vf395: vec3h = vf391;
  vf395 *= transpose(mat2x2h())[unconst_i32(1)].xxy;
  out = VertexOutput11(floor(vec2f(unconst_f32(0.06547), unconst_f32(0.05245))).grrr, bitcast<vec4h>(floor(vec2f(unconst_f32(0.06547), unconst_f32(0.05245)))));
  let vf396: vec3f = ldexp(vec3f(unconst_f32(0.07811), unconst_f32(0.3242), unconst_f32(-0.1260)), vec3i(unconst_i32(253), unconst_i32(57), unconst_i32(127)));
  let vf397: vec2f = log2(vec2f(unconst_f32(0.09197), unconst_f32(0.2679)));
  var vf398: f32 = quantizeToF16(f32(unconst_f32(0.1643)));
  vf398 += bitcast<f32>(transpose(mat2x2h(f16(quantizeToF16(f32(unconst_f32(0.1342)))), f16(quantizeToF16(f32(unconst_f32(0.1342)))), f16(quantizeToF16(f32(unconst_f32(0.1342)))), f16(quantizeToF16(f32(unconst_f32(0.1342))))))[unconst_i32(0)]);
  let vf399: f32 = vf396[bitcast<vec3u>(vf392)[0]];
  var vf400: vec4i = unpack4xI8(u32(unconst_u32(79)));
  return out;
  _ = override18;
}

fn fn1() -> mat4x2h {
  var out: mat4x2h;
  out = mat4x2h(log2(vec2h(unconst_f16(21988.3), unconst_f16(3558.5))), log2(vec2h(unconst_f16(21988.3), unconst_f16(3558.5))), log2(vec2h(unconst_f16(21988.3), unconst_f16(3558.5))), log2(vec2h(unconst_f16(21988.3), unconst_f16(3558.5))));
  var vf401 = fn0();
  let vf402: u32 = dot4U8Packed(u32(unconst_u32(236)), u32(unconst_u32(22)));
  out = mat4x2h(cross(vec3h(unconst_f16(2010.3), unconst_f16(43301.6), unconst_f16(24085.0)), vec3h(unconst_f16(9702.3), unconst_f16(4355.8), unconst_f16(18467.2))).br, cross(vec3h(unconst_f16(2010.3), unconst_f16(43301.6), unconst_f16(24085.0)), vec3h(unconst_f16(9702.3), unconst_f16(4355.8), unconst_f16(18467.2))).rg, cross(vec3h(unconst_f16(2010.3), unconst_f16(43301.6), unconst_f16(24085.0)), vec3h(unconst_f16(9702.3), unconst_f16(4355.8), unconst_f16(18467.2))).gr, cross(vec3h(unconst_f16(2010.3), unconst_f16(43301.6), unconst_f16(24085.0)), vec3h(unconst_f16(9702.3), unconst_f16(4355.8), unconst_f16(18467.2))).bb);
  vf401.f45 *= vec4f(f32(all(bool(unconst_bool(false)))));
  let vf403: i32 = dot4I8Packed(u32(cross(vec3h(mix(f16(unconst_f16(42461.8)), f16(unconst_f16(1253.7)), f16(unconst_f16(111.9)))), vec3h(unconst_f16(26600.5), unconst_f16(43.70), unconst_f16(12399.7))).g), u32(unconst_u32(107)));
  fn0();
  let vf404: vec4f = fract(vec4f(unconst_f32(0.01232), unconst_f32(0.04372), unconst_f32(-0.06628), unconst_f32(0.04401)));
  fn0();
  fn0();
  out = mat4x2h(vec2h(step(vec4f(unconst_f32(0.6890), unconst_f32(-0.1750), unconst_f32(0.2393), unconst_f32(0.2083)), vec4f(unconst_f32(0.4110), unconst_f32(0.2573), unconst_f32(0.04424), unconst_f32(0.00049))).xy), vec2h(step(vec4f(unconst_f32(0.6890), unconst_f32(-0.1750), unconst_f32(0.2393), unconst_f32(0.2083)), vec4f(unconst_f32(0.4110), unconst_f32(0.2573), unconst_f32(0.04424), unconst_f32(0.00049))).rb), vec2h(step(vec4f(unconst_f32(0.6890), unconst_f32(-0.1750), unconst_f32(0.2393), unconst_f32(0.2083)), vec4f(unconst_f32(0.4110), unconst_f32(0.2573), unconst_f32(0.04424), unconst_f32(0.00049))).ar), vec2h(step(vec4f(unconst_f32(0.6890), unconst_f32(-0.1750), unconst_f32(0.2393), unconst_f32(0.2083)), vec4f(unconst_f32(0.4110), unconst_f32(0.2573), unconst_f32(0.04424), unconst_f32(0.00049))).zy));
  fn0();
  var vf405 = fn0();
  out += mat4x2h(sin(vec2h(unconst_f16(426.0), unconst_f16(4401.7))), sin(vec2h(unconst_f16(426.0), unconst_f16(4401.7))), sin(vec2h(unconst_f16(426.0), unconst_f16(4401.7))), sin(vec2h(unconst_f16(426.0), unconst_f16(4401.7))));
  let vf406: vec3f = smoothstep(vec3f(unconst_f32(0.1394), unconst_f32(0.1215), unconst_f32(-0.2353)), vec3f(unconst_f32(0.1139), unconst_f32(0.09572), unconst_f32(0.1743)), vec3f(unconst_f32(0.2018), unconst_f32(0.4362), unconst_f32(0.05978)));
  let ptr122: ptr<function, VertexOutput11> = &vf401;
  vf405.f45 = vec4f(vf405.f45[u32(unconst_u32(306))]);
  vf401.f46 = vec4h(f16(vf406[u32(unconst_u32(167))]));
  vf401 = VertexOutput11(vec4f(log2(vec2h(unconst_f16(9352.7), unconst_f16(12248.6))).rggg), log2(vec2h(unconst_f16(9352.7), unconst_f16(12248.6))).rggg);
  vf401 = VertexOutput11(smoothstep(vec3f(unconst_f32(-0.06120), unconst_f32(0.04015), unconst_f32(0.1086)), vec3f(unconst_f32(0.00444), unconst_f32(0.1248), unconst_f32(0.1717)), vec3f(unconst_f32(0.03857), unconst_f32(0.07399), unconst_f32(0.1219))).xxyy, vec4h(smoothstep(vec3f(unconst_f32(-0.06120), unconst_f32(0.04015), unconst_f32(0.1086)), vec3f(unconst_f32(0.00444), unconst_f32(0.1248), unconst_f32(0.1717)), vec3f(unconst_f32(0.03857), unconst_f32(0.07399), unconst_f32(0.1219))).rrbg));
  return out;
  _ = override18;
}

fn fn2() -> VertexOutput11 {
  var out: VertexOutput11;
  var vf407: vec4f = workgroupUniformLoad(&vw59);
  vw61 *= f16(atomicExchange(&vw63, i32(unconst_i32(187))));
  vw58 = bool(vw64[0].f46[bitcast<u32>(vf407[u32(unconst_u32(8))])]);
  out.f46 = vec4h(f16((*&vw60)[u32(unconst_u32(174))][u32(unconst_u32(80))]));
  vw57[u32(unconst_u32(135))] = VertexOutput11(vw57[u32(unconst_u32(181))].f45, vec4h(vw57[u32(unconst_u32(181))].f45));
  var vf408: bool = workgroupUniformLoad(&vw58);
  return out;
}

var<workgroup> vw57: array<VertexOutput11, 1>;

var<workgroup> vw58: bool;

var<workgroup> vw59: vec4f;

var<workgroup> vw60: mat4x2f;

var<workgroup> vw61: f16;

var<workgroup> vw62: vec4f;

var<workgroup> vw63: atomic<i32>;

var<workgroup> vw64: array<VertexOutput11, 1>;

@vertex
fn vertex14() -> VertexOutput11 {
  var out: VertexOutput11;
  var vf409 = fn0();
  out = VertexOutput11(vec4f(f32(all(bool(unconst_bool(false))))), vec4h(f16(all(bool(unconst_bool(false))))));
  fn1();
  fn0();
  out.f45 = vec4f(tanh(vec3h(unconst_f16(11199.3), unconst_f16(9971.9), unconst_f16(10789.3))).zzzy);
  var vf410: vec4h = tan(vec4h(unconst_f16(1168.8), unconst_f16(-4240.9), unconst_f16(697.9), unconst_f16(83.17)));
  fn0();
  fn1();
  var vf411 = fn1();
  vf409.f46 -= vf411[unconst_i32(2)].gggr;
  var vf412 = fn1();
  let ptr123: ptr<function, vec4h> = &vf410;
  var vf413: vec4f = fract(vec4f(unconst_f32(0.3521), unconst_f32(-0.4527), unconst_f32(0.04438), unconst_f32(0.1362)));
  vf412 = mat4x2h(tan(vf411[unconst_i32(1)].rrrg).wy, tan(vf411[unconst_i32(1)].rrrg).wx, tan(vf411[unconst_i32(1)].rrrg).ga, tan(vf411[unconst_i32(1)].rrrg).gb);
  fn1();
  return out;
  _ = override18;
}

@compute @workgroup_size(1, 1, 1)
fn compute16() {
  var vf414 = fn2();
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup64 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 409, resource: {buffer: buffer34, offset: 0}}]});
let computePassEncoder105 = commandEncoder0.beginComputePass();
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['r16float'], depthReadOnly: true});
let sampler80 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 89.89,
  lodMaxClamp: 91.40,
  maxAnisotropy: 17,
});
let externalTexture14 = device0.importExternalTexture({source: videoFrame13});
try {
computePassEncoder100.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder30.beginOcclusionQuery(1);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer5, 'uint16', 38, 94);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer35, 'uint32', 1_936, 179);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture118,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(22_043).fill(118), /* required buffer size: 22_043 */
{offset: 164, bytesPerRow: 33, rowsPerImage: 39}, {width: 8, height: 0, depthOrArrayLayers: 18});
} catch {}
try {
adapter0.label = '\u0724\u0bc2\u5e61\u022c\u02ba';
} catch {}
let renderBundle14 = renderBundleEncoder14.finish({});
try {
computePassEncoder99.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer62, 'uint16', 18_160, 5_105);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(0, buffer1);
} catch {}
try {
buffer1.unmap();
} catch {}
let textureView91 = texture121.createView({aspect: 'all'});
try {
computePassEncoder34.setBindGroup(0, bindGroup52);
} catch {}
try {
computePassEncoder74.setBindGroup(0, bindGroup49, new Uint32Array(3523), 137, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(0, bindGroup27, new Uint32Array(91), 10, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle6, renderBundle3]);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 210, height: 1, depthOrArrayLayers: 7}
*/
{
  source: imageData12,
  origin: { x: 9, y: 0 },
  flipY: false,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 63, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer70 = device0.createBuffer({
  label: '\u5144\u4c6e\u5f69\ueb2e\u3e55\u00c7\u{1fde6}\u61fa',
  size: 5350,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
try {
computePassEncoder24.setBindGroup(1, bindGroup40);
} catch {}
try {
computePassEncoder105.setBindGroup(3, bindGroup8, new Uint32Array(3839), 1_888, 0);
} catch {}
try {
computePassEncoder105.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle6, renderBundle6, renderBundle8]);
} catch {}
try {
renderPassEncoder16.setViewport(2.4992159821832507, 0.9862007343341462, 10.474683109719047, 0.00808528702282861, 0.9571204836459707, 0.9878217829185114);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
let commandEncoder118 = device0.createCommandEncoder({});
let computePassEncoder106 = commandEncoder118.beginComputePass({});
let sampler81 = device0.createSampler({
  label: '\u{1f7c3}\u{1fd52}\u0852\u{1fe3b}\uca7d\u067f',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 4.685,
  lodMaxClamp: 45.91,
  compare: 'equal',
  maxAnisotropy: 15,
});
let externalTexture15 = device0.importExternalTexture({source: videoFrame14, colorSpace: 'display-p3'});
try {
computePassEncoder40.setBindGroup(2, bindGroup6);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroupsIndirect(buffer68, 556); };
} catch {}
try {
computePassEncoder102.setPipeline(pipeline2);
} catch {}
try {
buffer36.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 293, height: 1146, depthOrArrayLayers: 1}
*/
{
  source: videoFrame13,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture76,
  mipLevel: 0,
  origin: {x: 102, y: 346, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'smpteSt4281'} });
let bindGroup65 = device0.createBindGroup({
  label: '\u{1fb57}\ue5f2\ue458\u5ce4\u9c35\u9d11\u6a90\u0fbc\u01b7',
  layout: bindGroupLayout10,
  entries: [
    {binding: 314, resource: {buffer: buffer51, offset: 256, size: 1300}},
    {binding: 153, resource: textureView88},
    {binding: 327, resource: {buffer: buffer39, offset: 8960}},
    {binding: 64, resource: {buffer: buffer4, offset: 0, size: 2776}},
  ],
});
let textureView92 = texture112.createView({dimension: '2d-array', arrayLayerCount: 1});
try {
computePassEncoder60.setBindGroup(3, bindGroup4);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroupsIndirect(buffer14, 5_516); };
} catch {}
try {
renderPassEncoder30.endOcclusionQuery();
} catch {}
let bindGroup66 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView17}]});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: [undefined]});
try {
computePassEncoder56.setBindGroup(0, bindGroup34, new Uint32Array(593), 72, 0);
} catch {}
try {
computePassEncoder106.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.setBindGroup(1, bindGroup22);
} catch {}
try {
renderPassEncoder19.executeBundles([renderBundle5, renderBundle10, renderBundle5]);
} catch {}
let commandEncoder119 = device0.createCommandEncoder();
let computePassEncoder107 = commandEncoder119.beginComputePass({});
let renderBundle15 = renderBundleEncoder15.finish({});
try {
computePassEncoder107.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder22.setBindGroup(1, bindGroup48);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 22, y: 6, z: 0},
  aspect: 'all',
}, new Uint8Array(475).fill(137), /* required buffer size: 475 */
{offset: 475}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let shaderModule20 = device0.createShaderModule({
  label: '\u0426\u817e\u{1fc2e}',
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

@group(0) @binding(184) var tex20: texture_cube<i32>;

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

struct S5 {
  @location(6) @interpolate(flat) f0: vec2i,
  @builtin(vertex_index) f1: u32,
}

struct VertexOutput12 {
  @location(6) @interpolate(flat, center) f47: vec2u,
  @location(4) f48: i32,
  @location(7) @interpolate(linear, sample) f49: f32,
  @builtin(position) f50: vec4f,
  @location(10) f51: u32,
}

fn fn0() -> array<array<vec2u, 27>, 1> {
  var out: array<array<vec2u, 27>, 1>;
  out[u32(unconst_u32(480))][u32(unconst_u32(91))] = bitcast<vec2u>(unpack2x16unorm(u32(unconst_u32(309))));
  var vf415: u32 = pack4xU8Clamp(vec4u(unconst_u32(15), unconst_u32(184), unconst_u32(28), unconst_u32(33)));
  let vf416: vec2f = step(vec2f(unconst_f32(0.3043), unconst_f32(0.1036)), vec2f(unconst_f32(0.2057), unconst_f32(0.3382)));
  return out;
}

fn fn1() -> S5 {
  var out: S5;
  var vf417: u32 = pack2x16unorm(vec2f(unconst_f32(0.08181), unconst_f32(0.1711)));
  out = S5(vec2i(asinh(vec3h(unconst_f16(18557.0), unconst_f16(9536.8), unconst_f16(984.9))).bg), u32(asinh(vec3h(unconst_f16(18557.0), unconst_f16(9536.8), unconst_f16(984.9))).b));
  let vf418: vec3h = asinh(vec3h(unconst_f16(23062.3), unconst_f16(1766.8), unconst_f16(10667.4)));
  var vf419 = fn0();
  let ptr124: ptr<function, array<vec2u, 27>> = &vf419[0];
  out = S5(bitcast<vec2i>(vf419[0][26]), vf419[0][26][1]);
  fn0();
  var vf420: vec3i = clamp(vec3i(unconst_i32(125), unconst_i32(11), unconst_i32(181)), bitcast<vec3i>(vf419[vf419[u32(unconst_u32(33))][u32(unconst_u32(66))][u32(unconst_u32(572))]][26].rrr), vec3i(unconst_i32(49), unconst_i32(3), unconst_i32(22)));
  fn0();
  let ptr125: ptr<function, array<vec2u, 27>> = &vf419[0];
  let ptr126: ptr<function, array<vec2u, 27>> = &vf419[0];
  out.f1 -= (*ptr125)[vf419[0][26].x][u32(unconst_u32(84))];
  let ptr127: ptr<function, vec2u> = &vf419[0][u32(unconst_u32(161))];
  var vf421 = fn0();
  out.f0 = bitcast<vec2i>((*ptr126)[26]);
  vf420 = bitcast<vec3i>(vf419[u32(unconst_u32(325))][26].xyx);
  fn0();
  var vf422: f16 = fma(f16(unconst_f16(7718.3)), f16(unconst_f16(5755.6)), f16(unconst_f16(4298.3)));
  out.f1 |= vf419[u32(unconst_u32(30))][26][u32(unconst_u32(78))];
  var vf423 = fn0();
  var vf424 = fn0();
  return out;
}

fn fn2() {
  discard;
  var vf425 = fn0();
  var vf426 = fn0();
  var vf427: u32 = vf425[0][vf426[u32(unconst_u32(361))][26].x][u32(unconst_u32(292))];
  let ptr128: ptr<function, array<array<vec2u, 27>, 1>> = &vf425;
  vf425[0][26] = (*ptr128)[0][26];
  var vf428 = fn0();
  vf425[u32(unconst_u32(23))][u32(unconst_u32(551))] ^= vec2u(u32(length(vec3h(unconst_f16(5490.5), unconst_f16(1552.7), unconst_f16(15450.0)))));
  discard;
  var vf429 = fn0();
  let ptr129: ptr<function, array<vec2u, 27>> = &vf429[u32(unconst_u32(38))];
  var vf430 = fn0();
  vf429[u32(unconst_u32(500))][u32(unconst_u32(32))] &= vf428[u32(unconst_u32(238))][26];
  fn0();
  var vf431: vec2u = textureDimensions(tex20);
  fn0();
  var vf432 = fn0();
  fn0();
  fn0();
}

var<workgroup> vw65: atomic<i32>;

var<workgroup> vw66: atomic<u32>;

@vertex
fn vertex15(@location(7) @interpolate(perspective) a0: vec2h, @location(10) a1: vec4u, a2: S5) -> VertexOutput12 {
  var out: VertexOutput12;
  out.f47 ^= bitcast<vec2u>(a2.f0);
  out.f51 = bitcast<u32>(dot4I8Packed(u32(unconst_u32(82)), u32(round(f16(unconst_f16(2483.9))))));
  let vf433: u32 = a2.f1;
  out.f47 >>= vec2u(a2.f1);
  fn0();
  fn0();
  var vf434 = fn0();
  var vf435 = fn0();
  out.f51 &= vf434[u32(round(vec4h(unconst_f16(976.6), unconst_f16(3653.2), unconst_f16(7706.3), unconst_f16(5034.2))).r)][26].x;
  let ptr130: ptr<function, array<array<vec2u, 27>, 1>> = &vf434;
  fn1();
  vf434[u32(unconst_u32(267))][26] *= (*ptr130)[0][26];
  var vf436: u32 = (*ptr130)[0][u32(unconst_u32(178))][u32(unconst_u32(316))];
  var vf437: u32 = vf434[0][26][u32(unconst_u32(145))];
  out.f51 = vf435[u32(unconst_u32(120))][u32(unconst_u32(119))][u32(unconst_u32(69))];
  fn1();
  let ptr131: ptr<function, array<vec2u, 27>> = &(*ptr130)[u32(unconst_u32(43))];
  let vf438: u32 = vf435[u32(unconst_u32(83))][u32(unconst_u32(576))][u32(unconst_u32(15))];
  fn1();
  let ptr132: ptr<function, vec2u> = &(*ptr131)[u32(unconst_u32(100))];
  let vf439: u32 = vf435[u32(unconst_u32(16))][u32(unconst_u32(29))][u32(unconst_u32(102))];
  vf435[u32(unconst_u32(24))][u32(unconst_u32(141))] >>= (*ptr131)[26];
  fn0();
  return out;
}

@compute @workgroup_size(4, 1, 1)
fn compute17() {
  fn0();
  var vf440: vec2h = tan(tan(vec3h(unconst_f16(3440.3), unconst_f16(1924.6), unconst_f16(7027.8))).br);
  atomicCompareExchangeWeak(&vw66, unconst_u32(22), unconst_u32(30));
  let ptr133: ptr<workgroup, atomic<u32>> = &vw66;
  var vf441: i32 = atomicExchange(&(*&vw65), i32(unconst_i32(817)));
  let vf442: i32 = atomicExchange(&(*&vw65), i32(unconst_i32(121)));
  var vf443 = fn0();
  var vf444 = fn0();
  var vf445 = fn0();
  var vf446 = fn0();
  let ptr134: ptr<function, array<vec2u, 27>> = &vf446[vf445[u32(unconst_u32(1))][u32(unconst_u32(74))][1]];
  fn0();
  let ptr135: ptr<workgroup, atomic<u32>> = &vw66;
  vf446[u32(unconst_u32(140))][u32(unconst_u32(64))] ^= vec2u(vf445[u32(unconst_u32(111))][26][u32(unconst_u32(179))]);
  var vf447: i32 = atomicLoad(&(*&vw65));
  var vf448 = fn0();
  var vf449 = fn0();
  vf448[u32(unconst_u32(64))][atomicLoad(&(*ptr135))] |= vec2u(vf443[u32(unconst_u32(112))][u32(unconst_u32(87))][u32(unconst_u32(43))]);
  vf449[u32(unconst_u32(7))][26] *= vf446[0][26];
  vf440 = vec2h(vf445[u32(unconst_u32(8))][26]);
  vf440 -= vec2h(vf446[0][26]);
}`,
  sourceMap: {},
  hints: {},
});
let bindGroup67 = device0.createBindGroup({
  label: '\u683a\ub849\ue80f\u2feb\ue28c\u5396\u{1fc48}\u0372\ud0c4\u0548',
  layout: bindGroupLayout0,
  entries: [{binding: 184, resource: textureView64}],
});
let textureView93 = texture78.createView({dimension: '2d', format: 'rgba8unorm-srgb', baseArrayLayer: 3});
let sampler82 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 95.19,
});
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
try {
  await promise14;
} catch {}
let texture127 = device0.createTexture({size: [580, 48, 2], format: 'rg16uint', usage: GPUTextureUsage.COPY_SRC});
try {
computePassEncoder99.setBindGroup(2, bindGroup26, new Uint32Array(972), 572, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer33, 'uint32', 1_900, 10_142);
} catch {}
let buffer71 = device0.createBuffer({
  label: '\u0de7\ue704\ucc54\u701d\u0a2e\uce51\u434e\u4539\u{1f7dd}',
  size: 3442,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture128 = device0.createTexture({
  size: [145, 12, 127],
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderPassEncoder6.setBindGroup(0, bindGroup31);
} catch {}
await gc();
let texture129 = device0.createTexture({
  size: {width: 290, height: 24, depthOrArrayLayers: 31},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture130 = device0.createTexture({
  size: [580, 48, 2],
  mipLevelCount: 2,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler83 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMaxClamp: 87.17,
});
try {
computePassEncoder97.setBindGroup(1, bindGroup64);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer8, 8); };
} catch {}
try {
renderPassEncoder5.setVertexBuffer(2, undefined);
} catch {}
try {
buffer59.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 145, height: 12, depthOrArrayLayers: 127}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture128,
  mipLevel: 0,
  origin: {x: 9, y: 3, z: 9},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let bindGroup68 = device0.createBindGroup({
  label: '\u0c4d\u{1fa8c}\u1249\uadc8\u{1f817}\uce4a\u8d4d\u0357\u0145\u21a9',
  layout: bindGroupLayout1,
  entries: [
    {binding: 357, resource: {buffer: buffer22, offset: 768, size: 2592}},
    {binding: 37, resource: {buffer: buffer32, offset: 1280, size: 3012}},
    {binding: 39, resource: textureView1},
    {binding: 120, resource: {buffer: buffer22, offset: 256, size: 279}},
    {binding: 124, resource: {buffer: buffer69, offset: 512, size: 4844}},
  ],
});
let textureView94 = texture95.createView({dimension: '2d', baseMipLevel: 0});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder3.setBindGroup(3, bindGroup45);
} catch {}
try {
renderPassEncoder11.executeBundles([renderBundle8]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer67, 'uint16', 20, 1_908);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(7, buffer33, 0, 870);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup55);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(3, buffer47);
} catch {}
let arrayBuffer3 = buffer31.getMappedRange(32, 0);
try {
device0.queue.writeBuffer(buffer13, 6580, new DataView(new ArrayBuffer(6305)), 1928, 320);
} catch {}
let commandEncoder120 = device0.createCommandEncoder({label: '\u0de9\u{1fed9}\ud25f\u5b8e\u5acc\u0692\u{1f9ad}\u0544\u8e63\uc2fa\u0c0c'});
let sampler84 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 24.78,
  lodMaxClamp: 99.24,
});
let externalTexture16 = device0.importExternalTexture({source: videoFrame10});
try {
renderPassEncoder12.setBindGroup(0, bindGroup41, new Uint32Array(175), 6, 0);
} catch {}
try {
renderPassEncoder24.executeBundles([renderBundle14]);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer6, 'uint16', 3_152, 955);
} catch {}
try {
renderBundleEncoder16.setBindGroup(3, bindGroup28);
} catch {}
try {
renderBundleEncoder16.setBindGroup(0, bindGroup34, new Uint32Array(1056), 174, 0);
} catch {}
try {
commandEncoder120.copyTextureToTexture({
  texture: texture113,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 1},
  aspect: 'all',
},
{width: 24, height: 0, depthOrArrayLayers: 9});
} catch {}
try {
commandEncoder120.resolveQuerySet(querySet7, 2, 34, buffer26, 0);
} catch {}
let bindGroup69 = device0.createBindGroup({
  layout: bindGroupLayout1,
  entries: [
    {binding: 124, resource: {buffer: buffer53, offset: 768, size: 4524}},
    {binding: 39, resource: textureView1},
    {binding: 357, resource: {buffer: buffer26, offset: 0}},
    {binding: 37, resource: {buffer: buffer22, offset: 512, size: 527}},
    {binding: 120, resource: {buffer: buffer26, offset: 0}},
  ],
});
let computePassEncoder108 = commandEncoder120.beginComputePass({});
let renderBundle16 = renderBundleEncoder16.finish({});
try {
device0.queue.writeBuffer(buffer55, 216, new DataView(new ArrayBuffer(4697)), 202, 68);
} catch {}
let promise15 = device0.queue.onSubmittedWorkDone();
let textureView95 = texture129.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1});
let texture131 = gpuCanvasContext5.getCurrentTexture();
try {
computePassEncoder108.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder10.setViewport(260.1529058118581, 2.085155036847473, 13.56140416457577, 7.664399116052362, 0.6837927262016263, 0.8154161671263256);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(1, undefined);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture115,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 84,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 25,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
    {
      binding: 86,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 89, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
    {
      binding: 57,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 324,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {binding: 27, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }},
  ],
});
let texture132 = device0.createTexture({
  size: {width: 105},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder92.setBindGroup(3, bindGroup7, []);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer6, 'uint16', 940, 12_788);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer47);
} catch {}
let arrayBuffer4 = buffer31.getMappedRange(40, 4);
try {
  await buffer7.mapAsync(GPUMapMode.WRITE, 152, 396);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let promise16 = device0.queue.onSubmittedWorkDone();
try {
globalThis.someLabel = externalTexture4.label;
} catch {}
let bindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 4,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 28,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let texture133 = device0.createTexture({
  size: {width: 210, height: 1, depthOrArrayLayers: 1},
  format: 'rgba32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder26.setBindGroup(3, bindGroup39, new Uint32Array(1211), 145, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer62, 'uint16', 10_272, 1_708);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(1, buffer27, 88, 6);
} catch {}
let textureView96 = texture132.createView({});
let sampler85 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 6.477,
  maxAnisotropy: 13,
});
try {
renderPassEncoder22.setVertexBuffer(5, buffer59, 6_864);
} catch {}
try {
renderPassEncoder22.insertDebugMarker('\uba9c');
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let textureView97 = texture133.createView({dimension: '2d-array'});
let sampler86 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 41.14,
  lodMaxClamp: 89.80,
  maxAnisotropy: 17,
});
try {
computePassEncoder59.setBindGroup(2, bindGroup59, new Uint32Array(539), 279, 0);
} catch {}
try {
computePassEncoder74.end();
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer12, 'uint16', 128, 94);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(6, buffer57, 0);
} catch {}
try {
commandEncoder76.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 191, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1108 widthInBlocks: 277 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1316 */
  offset: 1316,
  bytesPerRow: 32768,
  rowsPerImage: 367,
  buffer: buffer35,
}, {width: 277, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 26, height: 1, depthOrArrayLayers: 4}
*/
{
  source: canvas1,
  origin: { x: 52, y: 12 },
  flipY: true,
}, {
  texture: texture0,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas1);
let bindGroup70 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView28}]});
let buffer72 = device0.createBuffer({size: 2895, usage: GPUBufferUsage.STORAGE});
let computePassEncoder109 = commandEncoder76.beginComputePass({});
try {
computePassEncoder25.setBindGroup(2, bindGroup50, new Uint32Array(3831), 422, 0);
} catch {}
try {
computePassEncoder109.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(5, buffer34, 892, 1_989);
} catch {}
let promise17 = shaderModule17.getCompilationInfo();
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
await gc();
let bindGroup71 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 184, resource: textureView64}]});
let textureView98 = texture30.createView({dimension: '2d'});
try {
renderPassEncoder3.setBindGroup(0, bindGroup43, new Uint32Array(1905), 8, 0);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.append(canvas0);
let buffer73 = device0.createBuffer({size: 2104, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder121 = device0.createCommandEncoder({});
let texture134 = gpuCanvasContext1.getCurrentTexture();
let computePassEncoder110 = commandEncoder121.beginComputePass({label: '\u08e8\u9e94\u0a67\u{1fcba}\u05d2\ub921\u0f84\ua43b\uefda'});
let sampler87 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 95.84,
  lodMaxClamp: 98.85,
  compare: 'not-equal',
});
try {
renderPassEncoder12.setBindGroup(0, bindGroup53, new Uint32Array(1854), 175, 0);
} catch {}
try {
renderPassEncoder14.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer67, 'uint32', 432, 567);
} catch {}
let commandEncoder122 = device0.createCommandEncoder({});
let computePassEncoder111 = commandEncoder122.beginComputePass({});
let sampler88 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.38,
  lodMaxClamp: 99.30,
  compare: 'never',
  maxAnisotropy: 2,
});
try {
computePassEncoder111.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle8, renderBundle14, renderBundle3]);
} catch {}
try {
renderPassEncoder30.setViewport(10.930250332259389, 0.7938687150140441, 11.962476978428569, 0.20516059286392296, 0.7916175760883822, 0.8738333020152702);
} catch {}
await gc();
let buffer74 = device0.createBuffer({
  label: '\u0fb0\u0668\ued40\ufc38\u{1fd4b}\ubd52\u3986',
  size: 8882,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture135 = device0.createTexture({
  size: [210, 1, 1],
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler89 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 11,
});
try {
renderPassEncoder27.setBindGroup(2, bindGroup2, new Uint32Array(2809), 246, 0);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(0, buffer47, 12_960);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 64, height: 64, depthOrArrayLayers: 18}
*/
{
  source: videoFrame18,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 0, y: 6, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer75 = device0.createBuffer({
  size: 5564,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
try {
computePassEncoder58.setBindGroup(3, bindGroup64, []);
} catch {}
try {
computePassEncoder96.setBindGroup(0, bindGroup54, new Uint32Array(920), 23, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup46);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer12, 'uint16', 18, 219);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let texture136 = device0.createTexture({
  label: '\uef70\u0c30\u3486',
  size: [290, 24, 2],
  mipLevelCount: 4,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder95.setBindGroup(0, bindGroup44);
} catch {}
try {
computePassEncoder110.setPipeline(pipeline0);
} catch {}
try {
  await buffer49.mapAsync(GPUMapMode.WRITE, 8368, 1076);
} catch {}
let bindGroup72 = device0.createBindGroup({
  label: '\u9ff3\u018d\u{1faad}',
  layout: bindGroupLayout5,
  entries: [{binding: 156, resource: textureView81}],
});
let buffer76 = device0.createBuffer({size: 3233, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX});
let textureView99 = texture103.createView({dimension: '2d', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder111.setBindGroup(1, bindGroup32);
} catch {}
try {
renderPassEncoder24.setBindGroup(0, bindGroup33, new Uint32Array(1876), 994, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer5, 20, new Float32Array(28068), 1853, 0);
} catch {}
try {
  await promise16;
} catch {}
let bindGroup73 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [
    {binding: 171, resource: sampler68},
    {binding: 435, resource: sampler27},
    {binding: 89, resource: sampler68},
  ],
});
let buffer77 = device0.createBuffer({
  size: 39849,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 79});
let textureView100 = texture6.createView({dimension: '2d', mipLevelCount: 1});
try {
renderPassEncoder9.beginOcclusionQuery(4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(206_047).fill(29), /* required buffer size: 206_047 */
{offset: 31, bytesPerRow: 37, rowsPerImage: 48}, {width: 13, height: 0, depthOrArrayLayers: 117});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 13, height: 1, depthOrArrayLayers: 64}
*/
{
  source: imageData1,
  origin: { x: 2, y: 0 },
  flipY: true,
}, {
  texture: texture92,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 9},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder123 = device0.createCommandEncoder({});
let computePassEncoder112 = commandEncoder123.beginComputePass({});
try {
computePassEncoder41.setBindGroup(0, bindGroup49, []);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder95); computePassEncoder95.dispatchWorkgroupsIndirect(buffer67, 672); };
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup52);
} catch {}
try {
buffer49.unmap();
} catch {}
let bindGroup74 = device0.createBindGroup({
  layout: bindGroupLayout12,
  entries: [
    {binding: 57, resource: textureView97},
    {binding: 324, resource: {buffer: buffer4, offset: 1024, size: 1248}},
    {binding: 84, resource: textureView96},
    {binding: 27, resource: {buffer: buffer74, offset: 4864, size: 1492}},
    {binding: 25, resource: {buffer: buffer67, offset: 0, size: 1928}},
    {binding: 86, resource: textureView80},
    {binding: 89, resource: {buffer: buffer65, offset: 2048}},
  ],
});
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder124 = device0.createCommandEncoder({});
let textureView101 = texture127.createView({dimension: '2d'});
try {
computePassEncoder108.setBindGroup(0, bindGroup66, new Uint32Array(325), 51, 0);
} catch {}
try {
computePassEncoder112.setPipeline(pipeline2);
} catch {}
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder125 = device0.createCommandEncoder({label: '\u3d96\u4367\u02dc'});
let texture137 = device0.createTexture({
  label: '\u3eb9\ubec3\u{1f626}\ufd99\u703d\u{1f6e9}\u{1ff4d}\u{1fd1d}',
  size: [64, 64, 18],
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView102 = texture37.createView({});
let computePassEncoder113 = commandEncoder124.beginComputePass({});
let renderPassEncoder32 = commandEncoder125.beginRenderPass({
  colorAttachments: [{
  view: textureView86,
  depthSlice: 5,
  clearValue: { r: 230.2, g: -555.8, b: 447.0, a: 36.00, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
computePassEncoder88.setBindGroup(3, bindGroup72);
} catch {}
try {
computePassEncoder47.setBindGroup(3, bindGroup51, new Uint32Array(643), 48, 0);
} catch {}
try {
computePassEncoder30.end();
} catch {}
try {
renderPassEncoder32.setBindGroup(2, bindGroup45, new Uint32Array(420), 7, 0);
} catch {}
try {
renderPassEncoder27.executeBundles([renderBundle8, renderBundle14]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer33, 'uint32', 648, 956);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING, colorSpace: 'srgb'});
} catch {}
let bindGroup75 = device0.createBindGroup({
  layout: bindGroupLayout13,
  entries: [
    {binding: 28, resource: {buffer: buffer22, offset: 256, size: 412}},
    {binding: 4, resource: textureView18},
  ],
});
let textureView103 = texture24.createView({dimension: '3d', mipLevelCount: 1});
let computePassEncoder114 = commandEncoder29.beginComputePass({});
try {
computePassEncoder114.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder29.setBindGroup(2, bindGroup43);
} catch {}
try {
renderPassEncoder23.setIndexBuffer(buffer32, 'uint32', 852, 3_865);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
videoFrame0.close();
videoFrame2.close();
videoFrame3.close();
videoFrame6.close();
videoFrame7.close();
videoFrame8.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
}
async function window2() {
let adapter0 = await navigator.gpu.requestAdapter();
let promise0 = adapter0.requestDevice({
  defaultQueue: {label: '\u9ca5\u09e0\u0632\u{1fbb1}\u{1f812}\u6137\u7023\u{1fa10}'},
  requiredLimits: {
    maxDynamicUniformBuffersPerPipelineLayout: 8,
    maxUniformBufferBindingSize: 60573204,
    maxStorageBufferBindingSize: 138967838,
    maxSampledTexturesPerShaderStage: 16,
  },
});
let promise1 = navigator.gpu.requestAdapter({powerPreference: 'low-power'});
let adapter1 = await promise1;
let device0 = await promise0;
let texture0 = device0.createTexture({
  size: [64, 10, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView0 = texture0.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1});
let sampler0 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 1.021,
  lodMaxClamp: 93.19,
  compare: 'greater-equal',
});
let sampler1 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 99.13,
  lodMaxClamp: 99.31,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder0 = device0.createCommandEncoder({});
let bindGroupLayout0 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 67,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let texture1 = device0.createTexture({
  size: [16, 2, 27],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder0 = commandEncoder0.beginComputePass();
let texture2 = device0.createTexture({
  size: [164, 1, 296],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], stencilReadOnly: true});
let bindGroupLayout1 = device0.createBindGroupLayout({
  label: '\u58ae\u7354\uf852\u0e5c\uf50d\u5ebc\u0ab1',
  entries: [{binding: 69, visibility: GPUShaderStage.VERTEX, externalTexture: {}}],
});
let pipelineLayout0 = device0.createPipelineLayout({
  label: '\u0182\uc60e\u579c\u{1f74b}\u089c\u0c4c\u0be2\u{1f94f}\u623b\ud98a\uaf5d',
  bindGroupLayouts: [],
});
let textureView1 = texture2.createView({aspect: 'all'});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthReadOnly: true, stencilReadOnly: true});
let renderBundle0 = renderBundleEncoder1.finish({});
let sampler2 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 0.7306,
  lodMaxClamp: 17.20,
  maxAnisotropy: 10,
});
let commandEncoder1 = device0.createCommandEncoder({});
let computePassEncoder1 = commandEncoder1.beginComputePass({});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({
  label: '\u409a\ubfbe\u4e32\ucf38\u182a\u00d5\u96bc\uab8c\u942d',
  colorFormats: ['rgba32sint'],
  depthReadOnly: true,
});
let renderBundle1 = renderBundleEncoder2.finish({});
let sampler3 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.97,
  lodMaxClamp: 99.98,
  compare: 'less',
});
let bindGroup0 = device0.createBindGroup({
  label: '\u0de6\u7996\u0ba4\u7c6a\u{1fcfc}\u9ac0\u{1fb63}\u0ee6\u005b\u6d31',
  layout: bindGroupLayout0,
  entries: [{binding: 67, resource: textureView1}],
});
let pipelineLayout1 = device0.createPipelineLayout({label: '\u02d6\u2172\u070e\ub77f\u0830\u{1f89a}\u055c\u4c32', bindGroupLayouts: [bindGroupLayout1]});
let commandEncoder2 = device0.createCommandEncoder({});
let textureView2 = texture0.createView({aspect: 'all', mipLevelCount: 1});
let computePassEncoder2 = commandEncoder2.beginComputePass();
try {
globalThis.someLabel = device0.queue.label;
} catch {}
let texture3 = device0.createTexture({
  size: [16, 2, 79],
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture4 = device0.createTexture({
  label: '\u0890\u{1fa73}\u{1fa96}\u{1f7c2}\u0533\u0d52\u0663\u{1fe20}\u4db4\u899d',
  size: [164, 1, 64],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let textureView3 = texture0.createView({mipLevelCount: 1});
let sampler4 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 15.03,
  lodMaxClamp: 62.93,
});
try {
renderBundleEncoder0.setVertexBuffer(1, undefined, 80_292_479);
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let commandEncoder3 = device0.createCommandEncoder({});
try {
renderBundleEncoder0.setBindGroup(3, bindGroup0);
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let bindGroupLayout2 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 68,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 227,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let texture5 = device0.createTexture({
  size: [129, 20, 62],
  format: 'rg32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture6 = device0.createTexture({
  size: {width: 64, height: 10, depthOrArrayLayers: 1},
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder3 = commandEncoder3.beginComputePass({});
let sampler5 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 3.695,
  maxAnisotropy: 4,
});
try {
computePassEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(1670), 118, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(5, undefined, 0);
} catch {}
let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470m', transfer: 'bt2020_10bit'} });
let commandEncoder4 = device0.createCommandEncoder({});
let textureView4 = texture5.createView({dimension: '2d', baseArrayLayer: 6});
let texture7 = device0.createTexture({size: [129, 20, 1], format: 'rgba32sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
let externalTexture0 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder2.setBindGroup(3, bindGroup0);
} catch {}
let canvas0 = document.createElement('canvas');
let imageData0 = new ImageData(32, 4);
let videoFrame1 = new VideoFrame(videoFrame0, {timestamp: 0});
let commandEncoder5 = device0.createCommandEncoder({});
let renderBundle2 = renderBundleEncoder0.finish();
try {
computePassEncoder1.setBindGroup(1, bindGroup0, new Uint32Array(886), 6, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let gpuCanvasContext0 = canvas0.getContext('webgpu');
let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder6 = device0.createCommandEncoder({});
let texture8 = device0.createTexture({
  label: '\u068e\u073a',
  size: {width: 656, height: 1, depthOrArrayLayers: 40},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32sint'],
});
let computePassEncoder4 = commandEncoder5.beginComputePass({label: '\u3038\uf844\u01d8\ua3f5\uc3bd\uc287\ud275\u{1f6c3}\u{1fcd5}\ud078'});
let externalTexture1 = device0.importExternalTexture({
  label: '\uff3a\u{1f687}\u{1fe8b}\u{1fb22}\u5c83\uae98\u00a5\u{1f967}\udbd8\u8b95\u{1fd15}',
  source: videoFrame1,
});
try {
computePassEncoder0.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder2.insertDebugMarker('\u80ae');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 13, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(43_685).fill(38), /* required buffer size: 43_685 */
{offset: 21, bytesPerRow: 62, rowsPerImage: 37}, {width: 2, height: 2, depthOrArrayLayers: 20});
} catch {}
let commandEncoder7 = device0.createCommandEncoder();
let computePassEncoder5 = commandEncoder6.beginComputePass({});
let sampler6 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 58.98,
  maxAnisotropy: 2,
});
try {
computePassEncoder3.setBindGroup(0, bindGroup0, []);
} catch {}
try {
computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(1835), 98, 0);
} catch {}
try {
commandEncoder4.insertDebugMarker('\u3138');
} catch {}
try {
  await promise2;
} catch {}
let texture9 = device0.createTexture({
  size: {width: 328, height: 1, depthOrArrayLayers: 56},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgba32sint'],
});
let textureView5 = texture5.createView({label: '\ubb87\u5a4d\u0e2b\u{1f602}', dimension: '2d', baseArrayLayer: 10});
try {
computePassEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(1334), 64, 0);
} catch {}
await gc();
let commandEncoder8 = device0.createCommandEncoder({});
let externalTexture2 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'});
let shaderModule0 = device0.createShaderModule({
  code: `
enable f16;

requires unrestricted_pointer_parameters;

diagnostic(info, xyz);

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

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

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

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

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

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

struct S0 {
  @location(9) @interpolate(flat, sample) f0: vec4f,
  @builtin(vertex_index) f1: u32,
  @location(3) @interpolate(flat, centroid) f2: vec2u,
}

struct VertexOutput0 {
  @location(3) f0: vec2h,
  @location(14) @interpolate(flat, sample) f1: vec4u,
  @builtin(position) f2: vec4f,
  @location(4) f3: i32,
}

struct FragmentOutput0 {
  @location(1) f0: vec2f,
  @location(0) @interpolate(flat) f1: vec4i,
}

fn fn0(a0: array<mat2x4f, 1>) -> mat4x4h {
  var out: mat4x4h;
  out -= mat4x4h(f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))), f16(pack4xI8(vec4i(unconst_i32(85), unconst_i32(51), unconst_i32(89), unconst_i32(386)))));
  let vf0: vec3f = step(vec3f(unconst_f32(0.08106), unconst_f32(0.2695), unconst_f32(0.03903)), vec3f(unconst_f32(0.06215), unconst_f32(0.3654), unconst_f32(0.05955)));
  vp1.fract = vf0.bb;
  vp1 = modf(vec2f(a0[0][u32(unconst_u32(1))][u32(unconst_u32(68))]));
  let vf1: vec4f = saturate(vec4f(vp0[u32(unconst_u32(253))][2][unconst_i32(1)].zzzx));
  out = mat4x4h(atanh(vec3h(unconst_f16(1640.7), unconst_f16(4587.8), unconst_f16(2505.2))).yxxx, atanh(vec3h(unconst_f16(1640.7), unconst_f16(4587.8), unconst_f16(2505.2))).rgbg, atanh(vec3h(unconst_f16(1640.7), unconst_f16(4587.8), unconst_f16(2505.2))).rbgg, atanh(vec3h(unconst_f16(1640.7), unconst_f16(4587.8), unconst_f16(2505.2))).bbrr);
  let ptr0: ptr<private, mat2x3h> = &vp0[0][2];
  out = mat4x4h(vec4h(extractBits(vec4u(unconst_u32(113), unconst_u32(100), unconst_u32(342), unconst_u32(227)), u32(unconst_u32(44)), u32(unconst_u32(53)))), vec4h(extractBits(vec4u(unconst_u32(113), unconst_u32(100), unconst_u32(342), unconst_u32(227)), u32(unconst_u32(44)), u32(unconst_u32(53)))), vec4h(extractBits(vec4u(unconst_u32(113), unconst_u32(100), unconst_u32(342), unconst_u32(227)), u32(unconst_u32(44)), u32(unconst_u32(53)))), vec4h(extractBits(vec4u(unconst_u32(113), unconst_u32(100), unconst_u32(342), unconst_u32(227)), u32(unconst_u32(44)), u32(unconst_u32(53)))));
  let ptr1: ptr<private, mat2x3h> = &(*ptr0);
  vp1.whole = vec2f((*ptr1)[unconst_i32(1)].xz);
  let ptr2: ptr<private, mat2x3h> = &(*ptr0);
  vp0[0][u32(unconst_u32(48))] = vp0[u32(unconst_u32(130))][2];
  let ptr3: ptr<private, array<mat2x3h, 3>> = &vp0[u32(unconst_u32(9))];
  var vf2: f32 = vf0[u32(unconst_u32(81))];
  let vf3: vec2h = asin(vec2h(unconst_f16(36583.5), unconst_f16(24399.3)));
  let ptr4: ptr<private, mat2x3h> = &vp0[0][vec3u((*ptr3)[u32(unconst_u32(117))][u32(unconst_u32(219))])[2]];
  let vf4: vec3h = (*ptr3)[2][u32(unconst_u32(72))];
  out -= mat4x4h(vp0[0][2][u32(unconst_u32(65))].xyyy, vp0[0][2][u32(unconst_u32(65))].xxzx, vp0[0][2][u32(unconst_u32(65))].xzxx, vp0[0][2][u32(unconst_u32(65))].grgr);
  var vf5: vec4h = reflect(vec4h(unconst_f16(683.1), unconst_f16(1904.2), unconst_f16(10967.2), unconst_f16(31281.9)), vec4h(unconst_f16(10577.2), unconst_f16(6914.8), unconst_f16(7936.6), unconst_f16(10301.0)));
  let ptr5: ptr<private, array<mat2x3h, 3>> = &vp0[0];
  let vf6: vec3h = (*ptr3)[2][u32(unconst_u32(269))];
  let ptr6: ptr<function, vec4h> = &vf5;
  let vf7: vec2h = ceil(vec2h(unconst_f16(6473.9), unconst_f16(-5131.2)));
  vp0[u32(unconst_u32(313))][u32(unconst_u32(581))] = vp0[u32(unconst_u32(71))][2];
  return out;
}

fn fn1(a0: S0) -> array<mat4x2f, 1> {
  var out: array<mat4x2f, 1>;
  vp0[u32(unconst_u32(21))][u32(unconst_u32(48))] -= mat2x3h(vec3h(a0.f0.abg), vec3h(a0.f0.zxz));
  out[u32(unconst_u32(152))] = mat4x2f(round(vec4f(unconst_f32(0.2046), unconst_f32(0.2168), unconst_f32(0.00213), unconst_f32(0.2065))).br, round(vec4f(unconst_f32(0.2046), unconst_f32(0.2168), unconst_f32(0.00213), unconst_f32(0.2065))).xz, round(vec4f(unconst_f32(0.2046), unconst_f32(0.2168), unconst_f32(0.00213), unconst_f32(0.2065))).bb, round(vec4f(unconst_f32(0.2046), unconst_f32(0.2168), unconst_f32(0.00213), unconst_f32(0.2065))).wz);
  let ptr7: ptr<private, mat2x3h> = &vp0[0][u32(unconst_u32(46))];
  out[u32(unconst_u32(323))] = mat4x2f(f32(vp0[u32(unconst_u32(85))][u32(unconst_u32(312))][u32(unconst_u32(26))][vec3u(vp0[0][2][unconst_i32(1)])[1]]), f32(vp0[u32(unconst_u32(85))][u32(unconst_u32(312))][u32(unconst_u32(26))][vec3u(vp0[0][2][unconst_i32(1)])[1]]), f32(vp0[u32(unconst_u32(85))][u32(unconst_u32(312))][u32(unconst_u32(26))][vec3u(vp0[0][2][unconst_i32(1)])[1]]), f32(vp0[u32(unconst_u32(85))][u32(unconst_u32(312))][u32(unconst_u32(26))][vec3u(vp0[0][2][unconst_i32(1)])[1]]), f32(vp0[u32(unconst_u32(85))][u32(unconst_u32(312))][u32(unconst_u32(26))][vec3u(vp0[0][2][unconst_i32(1)])[1]]), f32(vp0[u32(unconst_u32(85))][u32(unconst_u32(312))][u32(unconst_u32(26))][vec3u(vp0[0][2][unconst_i32(1)])[1]]), f32(vp0[u32(unconst_u32(85))][u32(unconst_u32(312))][u32(unconst_u32(26))][vec3u(vp0[0][2][unconst_i32(1)])[1]]), f32(vp0[u32(unconst_u32(85))][u32(unconst_u32(312))][u32(unconst_u32(26))][vec3u(vp0[0][2][unconst_i32(1)])[1]]));
  let vf8: vec4u = countLeadingZeros(vec4u(unconst_u32(479), unconst_u32(103), unconst_u32(127), unconst_u32(41)));
  vp0[u32(unconst_u32(273))][2] = mat2x3h(vec3h(vp1.whole.rgg), vec3h(vp1.whole.ggg));
  return out;
}

fn fn2() -> vec4i {
  var out: vec4i;
  out = vec4i(vp0[0][u32(unconst_u32(134))][u32(unconst_u32(7))].zxxz);
  var vf9: vec3h = vp0[0][u32(unconst_u32(81))][u32(unconst_u32(170))];
  let ptr8: ptr<private, vec2f> = &vp1.whole;
  vf9 = vp0[u32(vp0[u32(unconst_u32(236))][2][unconst_i32(1)][0])][u32(unconst_u32(728))][unconst_i32(0)];
  vf9 = vp0[0][2][u32(unconst_u32(455))];
  let vf10: vec3h = vp0[0][u32(unconst_u32(197))][u32(unconst_u32(491))];
  var vf11: vec4f = fract(vec4f(unconst_f32(0.4877), unconst_f32(0.00275), unconst_f32(0.3508), unconst_f32(0.04522)));
  let vf12: vec3u = countTrailingZeros(vec3u(unconst_u32(290), unconst_u32(287), unconst_u32(630)));
  let ptr9: ptr<private, mat2x3h> = &vp0[0][2];
  out -= vec4i(vf10.xyzz);
  let vf13: vec2u = countLeadingZeros(vec2u(vp1.fract));
  vp1.whole += vec2f((*ptr8)[u32(unconst_u32(67))]);
  vf9 = vec3h((*ptr9)[u32(unconst_u32(118))][u32(unconst_u32(19))]);
  vf9 = (*ptr9)[unconst_i32(0)];
  let vf14: f32 = (*ptr8)[u32(unconst_u32(17))];
  vf11 *= unpack4x8unorm(vf13[u32(unconst_u32(35))]);
  vf11 = vec4f((*ptr9)[unconst_i32(0)].yzxy);
  let ptr10: ptr<private, mat2x3h> = &vp0[0][2];
  var vf15: f16 = vp0[pack2x16snorm(vec2f(unconst_f32(0.3821), unconst_f32(0.00912)))][u32(unconst_u32(50))][u32(unconst_u32(150))][u32(unconst_u32(162))];
  return out;
}

var<workgroup> vw0: atomic<i32>;

var<private> vp0: array<array<mat2x3h, 3>, 1> = array(array(mat2x3h(1068.1, 1534.6, 18807.5, 1811.6, 19051.4, 1755.9), mat2x3h(6520.3, 80.13, 2748.1, 4701.8, 6598.7, 7524.9), mat2x3h()));

var<private> vp1 = modf(vec2f(0.05407, 0.1660));

@vertex
fn vertex0(a0: S0, @location(10) a1: vec2u) -> VertexOutput0 {
  var out: VertexOutput0;
  vp0[u32(unconst_u32(59))][u32(unconst_u32(184))] = mat2x3h(vec3h(insertBits(vec4i(unconst_i32(11), unconst_i32(58), unconst_i32(217), unconst_i32(50)), vec4i(unconst_i32(155), unconst_i32(12), unconst_i32(104), unconst_i32(41)), u32(unconst_u32(26)), u32(unconst_u32(403))).xzw), vec3h(insertBits(vec4i(unconst_i32(11), unconst_i32(58), unconst_i32(217), unconst_i32(50)), vec4i(unconst_i32(155), unconst_i32(12), unconst_i32(104), unconst_i32(41)), u32(unconst_u32(26)), u32(unconst_u32(403))).zxy));
  var vf16: u32 = pack2x16snorm(vec2f(unconst_f32(0.1811), unconst_f32(0.09334)));
  var vf17 = fn2();
  var vf18 = fn1(S0(bitcast<vec4f>(clamp(vec3i(unconst_i32(303), unconst_i32(134), unconst_i32(-153)), vec3i(unconst_i32(14), unconst_i32(193), unconst_i32(156)), vec3i(unconst_i32(-50), unconst_i32(241), unconst_i32(531))).yyxx), bitcast<u32>(clamp(vec3i(unconst_i32(303), unconst_i32(134), unconst_i32(-153)), vec3i(unconst_i32(14), unconst_i32(193), unconst_i32(156)), vec3i(unconst_i32(-50), unconst_i32(241), unconst_i32(531)))[0]), vec2u(clamp(vec3i(unconst_i32(303), unconst_i32(134), unconst_i32(-153)), vec3i(unconst_i32(14), unconst_i32(193), unconst_i32(156)), vec3i(unconst_i32(-50), unconst_i32(241), unconst_i32(531))).yy)));
  var vf19 = fn2();
  vp0[u32(unconst_u32(116))][u32(unconst_u32(142))] = mat2x3h(f16(sqrt(f32(unconst_f32(0.03039)))), f16(sqrt(f32(unconst_f32(0.03039)))), f16(sqrt(f32(unconst_f32(0.03039)))), f16(sqrt(f32(unconst_f32(0.03039)))), f16(sqrt(f32(unconst_f32(0.03039)))), f16(sqrt(f32(unconst_f32(0.03039)))));
  let vf20: u32 = a0.f1;
  var vf21 = fn2();
  out.f0 = bitcast<vec2h>(a0.f2[u32(vf18[0][unconst_i32(1)].r)]);
  vf19 = vec4i(i32(sqrt(f32(unconst_f32(0.4543)))));
  let ptr11: ptr<function, mat4x2f> = &vf18[0];
  out.f1 *= vec4u(vf20);
  let ptr12: ptr<private, mat2x3h> = &vp0[u32(unconst_u32(174))][u32(unconst_u32(123))];
  vp0[u32(unconst_u32(191))][u32(unconst_u32(173))] = vp0[u32(unconst_u32(3))][2];
  let vf22: f32 = vf18[u32(unconst_u32(115))][u32(unconst_u32(26))][u32(unconst_u32(300))];
  out.f3 = vec3i(vp0[u32(unconst_u32(406))][u32(unconst_u32(15))][u32(unconst_u32(34))]).y;
  var vf23: i32 = vf21[u32(unconst_u32(154))];
  var vf24 = fn0(array<mat2x4f, 1>(mat2x4f(unconst_f32(0.2543), unconst_f32(0.01854), unconst_f32(0.00575), unconst_f32(0.6090), unconst_f32(0.00878), unconst_f32(-0.3188), unconst_f32(0.3491), unconst_f32(0.2312))));
  out.f2 += vec4f(vp0[0][2][unconst_i32(1)].zzyx);
  let vf25: f32 = vf18[u32(unconst_u32(182))][u32(unconst_u32(20))][u32(unconst_u32(84))];
  out.f0 -= vec2h(vp1.whole);
  let ptr13: ptr<private, array<mat2x3h, 3>> = &vp0[0];
  fn2();
  let ptr14: ptr<private, mat2x3h> = &(*ptr13)[2];
  out.f0 *= vec2h(vp1.fract);
  return out;
}

@fragment
fn fragment0() -> FragmentOutput0 {
  var out: FragmentOutput0;
  out.f0 += unpack2x16float(u32(unconst_u32(104)));
  vp1.fract = unpack2x16float(u32(unconst_u32(53)));
  out.f1 *= bitcast<vec4i>(vp1.whole.grrr);
  vp1 = modf(vec2f(vp0[u32(unconst_u32(35))][2][unconst_i32(0)].yz));
  out.f1 *= vec4i(vp0[u32(unconst_u32(4))][2][unconst_i32(0)].bbgb);
  out.f0 += bitcast<vec2f>(reverseBits(vec2i(unconst_i32(373), unconst_i32(430))));
  out.f1 -= vec4i(i32(atan2(f16(unconst_f16(-4340.2)), f16(unconst_f16(-4697.5)))));
  out.f1 &= bitcast<vec4i>(vp1.fract.grrr);
  var vf26: u32 = pack4xI8Clamp(vec4i(unconst_i32(48), unconst_i32(799), unconst_i32(203), unconst_i32(41)));
  var vf27 = fn2();
  vf26 = u32(vp0[u32(unconst_u32(85))][u32(unconst_u32(325))][u32(unconst_u32(57))][u32(unconst_u32(137))]);
  let ptr15: ptr<private, mat2x3h> = &vp0[0][2];
  let ptr16: ptr<private, array<mat2x3h, 3>> = &vp0[u32(unconst_u32(609))];
  vp0[u32(unconst_u32(266))][u32(unconst_u32(217))] = mat2x3h(f16(dot4U8Packed(u32(unconst_u32(141)), u32(unconst_u32(167)))), f16(dot4U8Packed(u32(unconst_u32(141)), u32(unconst_u32(167)))), f16(dot4U8Packed(u32(unconst_u32(141)), u32(unconst_u32(167)))), f16(dot4U8Packed(u32(unconst_u32(141)), u32(unconst_u32(167)))), f16(dot4U8Packed(u32(unconst_u32(141)), u32(unconst_u32(167)))), f16(dot4U8Packed(u32(unconst_u32(141)), u32(unconst_u32(167)))));
  vp0[u32(unconst_u32(49))][2] -= mat2x3h(vec3h(unpack2x16unorm(u32(unconst_u32(65))).xxx), vec3h(unpack2x16unorm(u32(unconst_u32(65))).ggg));
  fn2();
  out.f0 *= vp1.whole;
  return out;
}

@compute @workgroup_size(1, 1, 2)
fn compute0() {
  var vf28: vec4h = min(vec4h(unconst_f16(18670.5), unconst_f16(12343.7), unconst_f16(953.1), unconst_f16(7387.0)), vec4h(unconst_f16(31343.7), unconst_f16(24748.3), unconst_f16(1819.4), unconst_f16(4136.1)));
  let vf29: i32 = atomicLoad(&(*&vw0));
  fn2();
  var vf30 = fn2();
  let vf31: vec4i = firstTrailingBit(vec4i(unconst_i32(177), unconst_i32(303), unconst_i32(-71), unconst_i32(61)));
  vp0[u32(unconst_u32(52))][u32(unconst_u32(122))] -= mat2x3h(cross(vec3h(unconst_f16(7459.2), unconst_f16(-16603.9), unconst_f16(2287.6)), vec3h(unconst_f16(26924.5), unconst_f16(3688.1), unconst_f16(8550.4))), cross(vec3h(unconst_f16(7459.2), unconst_f16(-16603.9), unconst_f16(2287.6)), vec3h(unconst_f16(26924.5), unconst_f16(3688.1), unconst_f16(8550.4))));
  vp1.whole = vec2f(vp0[u32(unconst_u32(139))][u32(unconst_u32(446))][unconst_i32(0)].yy);
  vf30 = vec4i(vp0[0][u32(unconst_u32(236))][u32(unconst_u32(48))].grbr);
  let vf32: i32 = atomicExchange(&vw0, i32(unconst_i32(405)));
  fn2();
  var vf33 = fn2();
  vp0[u32(unconst_u32(43))][u32(unconst_u32(83))] += mat2x3h(distance(vec2h(unconst_f16(5782.8), unconst_f16(3816.4)), vec2h(unconst_f16(13059.9), unconst_f16(7269.5))), distance(vec2h(unconst_f16(5782.8), unconst_f16(3816.4)), vec2h(unconst_f16(13059.9), unconst_f16(7269.5))), distance(vec2h(unconst_f16(5782.8), unconst_f16(3816.4)), vec2h(unconst_f16(13059.9), unconst_f16(7269.5))), distance(vec2h(unconst_f16(5782.8), unconst_f16(3816.4)), vec2h(unconst_f16(13059.9), unconst_f16(7269.5))), distance(vec2h(unconst_f16(5782.8), unconst_f16(3816.4)), vec2h(unconst_f16(13059.9), unconst_f16(7269.5))), distance(vec2h(unconst_f16(5782.8), unconst_f16(3816.4)), vec2h(unconst_f16(13059.9), unconst_f16(7269.5))));
  vp0[0][2] = mat2x3h(f16(vf33[u32(unconst_u32(135))]), f16(vf33[u32(unconst_u32(135))]), f16(vf33[u32(unconst_u32(135))]), f16(vf33[u32(unconst_u32(135))]), f16(vf33[u32(unconst_u32(135))]), f16(vf33[u32(unconst_u32(135))]));
  vp1 = modf(vec2f(bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.02919), unconst_f32(0.1801))))));
  vf30 *= vec4i(min(vec4h(unconst_f16(59003.0), unconst_f16(13623.8), unconst_f16(2679.7), unconst_f16(4784.8)), vec4h(unconst_f16(10727.7), unconst_f16(1818.2), unconst_f16(12058.5), unconst_f16(6476.7))));
  var vf34 = fn2();
  let vf35: i32 = vf33[u32(unconst_u32(167))];
  vf33 *= vec4i(atomicLoad(&(*&vw0)));
  let vf36: f16 = vp0[0][u32(unconst_u32(40))][u32(unconst_u32(151))][u32(unconst_u32(83))];
  var vf37 = fn2();
  vp1.fract -= tan(vec2f(unconst_f32(-0.1956), unconst_f32(0.00734)));
  var vf38: i32 = vf30[u32(unconst_u32(302))];
  let ptr17: ptr<workgroup, atomic<i32>> = &(*&vw0);
  atomicXor(&vw0, i32(distance(vec2h(unconst_f16(5927.6), unconst_f16(5067.9)), vec2h(unconst_f16(285.6), unconst_f16(10038.6)))));
  vf33 -= vec4i(i32(distance(vec2h(unconst_f16(12163.5), unconst_f16(-8723.8)), vec2h(unconst_f16(7037.1), unconst_f16(7208.6)))));
}`,
  sourceMap: {},
  hints: {},
});
let computePassEncoder6 = commandEncoder4.beginComputePass({});
let bindGroupLayout3 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 345,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer0 = device0.createBuffer({size: 1249, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder9 = device0.createCommandEncoder();
try {
buffer0.unmap();
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let texture10 = device0.createTexture({
  size: {width: 16},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder7 = commandEncoder7.beginComputePass({label: '\u2e29\u0243\u0b9b\u0cf1\u{1fec4}\u5a5b\uf079\u4ca1\u0dde'});
let externalTexture3 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'});
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(202_411).fill(20), /* required buffer size: 202_411 */
{offset: 15, bytesPerRow: 430, rowsPerImage: 41}, {width: 37, height: 20, depthOrArrayLayers: 12});
} catch {}
let buffer1 = device0.createBuffer({
  size: 23980,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder10 = device0.createCommandEncoder({});
let computePassEncoder8 = commandEncoder10.beginComputePass();
let commandEncoder11 = device0.createCommandEncoder({label: '\u0df0\ua64a\ubaac\u{1f6fd}\u228b\u{1fc18}\u0ab2\u3dff\ue97a'});
let texture11 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder9 = commandEncoder9.beginComputePass({label: '\u0f9b\u2326\ucb01\u21f7\uab4e\udcbd\u326c\u7591\u{1f7f6}\u6319\ucc47'});
try {
computePassEncoder9.setBindGroup(0, bindGroup0, new Uint32Array(944), 123, 0);
} catch {}
let bindGroup1 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 69, resource: externalTexture2}]});
let commandEncoder12 = device0.createCommandEncoder({});
try {
computePassEncoder9.setBindGroup(2, bindGroup0, new Uint32Array(1233), 74, 0);
} catch {}
try {
commandEncoder12.copyTextureToTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 4},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas1 = document.createElement('canvas');
let texture12 = device0.createTexture({
  size: {width: 16, height: 2, depthOrArrayLayers: 27},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder10 = commandEncoder12.beginComputePass({});
try {
computePassEncoder2.setBindGroup(1, bindGroup0);
} catch {}
try {
commandEncoder11.copyTextureToTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
document.body.append(canvas0);
let bindGroup2 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 67, resource: textureView1}]});
let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout0]});
let buffer2 = device0.createBuffer({label: '\u0a98\u037f', size: 3740, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let bindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 13,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let texture13 = device0.createTexture({
  size: {width: 64, height: 10, depthOrArrayLayers: 1},
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture14 = device0.createTexture({
  size: [82, 1, 1],
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder11 = commandEncoder11.beginComputePass({});
try {
commandEncoder8.copyTextureToTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 5, y: 3, z: 0},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
},
{width: 11, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule1 = device0.createShaderModule({
  label: '\u2c8a\ub91f\u0098\u08e2\u0af9\u{1f837}\u1491\u7af8',
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

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

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

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

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

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

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

struct T0 {
  @size(1008) f0: array<mat2x2f>,
}

struct VertexOutput1 {
  @location(1) @interpolate(flat, centroid) f4: i32,
  @location(3) f5: u32,
  @location(8) f6: f16,
  @location(15) f7: f32,
  @location(10) f8: vec4h,
  @builtin(position) f9: vec4f,
  @location(0) @interpolate(flat, sample) f10: u32,
  @location(5) @interpolate(flat, sample) f11: vec4i,
}

struct S1 {
  @location(15) f0: vec4f,
  @location(14) @interpolate(linear) f1: vec2h,
  @location(8) f2: vec4f,
  @location(3) f3: vec2h,
}

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

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

alias vec3b = vec3<bool>;

var<workgroup> vw1: S1;

var<workgroup> vw2: mat2x4h;

var<private> vp2 = modf(vec3f(0.2354, 0.03934, 0.02232));

var<private> vp3: VertexOutput2 = VertexOutput2(vec4f(0.1457, 0.1709, 0.2041, 0.1824));

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

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

var<private> vp6 = array(modf(vec2h(15867.3, 4084.0)));

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

@vertex
fn vertex1() -> VertexOutput1 {
  var out: VertexOutput1;
  let ptr18: ptr<private, vec4i> = &vp4[0][0][0].f11;
  out.f7 = f32(vp4[0][0][u32(unconst_u32(133))].f11.r);
  vp6[u32(unconst_u32(35))].whole += bitcast<vec2h>(vp4[u32(unconst_u32(588))][u32(unconst_u32(15))][u32(vp7.f6)].f4);
  vp6[u32(unconst_u32(293))].whole = vp4[u32(unconst_u32(171))][u32(unconst_u32(3))][u32(vp4[0][u32(unconst_u32(108))][u32(unconst_u32(349))].f7)].f8.ab;
  vp2 = modf(vp3.f12.aar);
  let ptr19: ptr<private, vec4i> = &vp4[u32(unconst_u32(66))][u32(unconst_u32(6))][0].f11;
  let ptr20: ptr<private, f16> = &vp4[bitcast<u32>(vp4[u32(unconst_u32(87))][0][u32(unconst_u32(51))].f7)][u32(unconst_u32(202))][0].f6;
  let ptr21: ptr<private, array<VertexOutput1, 1>> = &vp4[u32(unconst_u32(15))][u32(unconst_u32(49))];
  let ptr22: ptr<private, array<array<VertexOutput1, 1>, 1>> = &vp4[0];
  let vf39: f16 = (*ptr21)[u32(unconst_u32(518))].f8[u32(unconst_u32(172))];
  let ptr23: ptr<private, f16> = &vp4[0][u32(unconst_u32(57))][0].f6;
  var vf40: f16 = (*ptr22)[0][0].f8[u32(unconst_u32(437))];
  let vf41: i32 = vp4[0][0][u32(unconst_u32(269))].f11[u32(unconst_u32(160))];
  vp5 = mat3x4h(f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10), f16(vp4[0][0][0].f10));
  vp3.f12 = vec4f(bitcast<f32>(vp4[0][0][0].f4));
  return out;
}

@vertex
fn vertex2(a0: S1, @location(2) @interpolate(linear, center) a1: vec2f, @location(12) a2: vec2h) -> VertexOutput2 {
  var out: VertexOutput2;
  vp6[u32(unconst_u32(88))] = modf(bitcast<vec2h>(vp4[0][u32(unconst_u32(305))][0].f5));
  let ptr24: ptr<private, u32> = &vp4[pack4x8unorm(a0.f2)][u32(unconst_u32(154))][u32(unconst_u32(116))].f10;
  let ptr25: ptr<private, u32> = &vp4[u32(unconst_u32(11))][u32(unconst_u32(27))][u32(unconst_u32(74))].f5;
  return out;
}

@vertex @must_use
fn vertex3(@location(11) a0: vec4f, @location(9) a1: vec2h) -> @builtin(position) vec4f {
  var out: vec4f;
  vp5 = mat3x4h(f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))), f16(pack4xI8Clamp(vec4i(unconst_i32(176), unconst_i32(281), unconst_i32(507), unconst_i32(330)))));
  let vf42: f32 = a0[u32(unconst_u32(186))];
  var vf43: vec4h = log(vec4h(unconst_f16(-16546.1), unconst_f16(3291.7), unconst_f16(24748.3), unconst_f16(41419.1)));
  let vf44: f32 = vf42;
  let ptr26: ptr<private, f16> = &vp4[u32(unconst_u32(7))][u32(unconst_u32(52))][u32(unconst_u32(347))].f6;
  let vf45: f32 = vp4[u32(unconst_u32(18))][u32(unconst_u32(5))][0].f9[u32(unconst_u32(55))];
  vp3 = VertexOutput2(vec4f(f32(vp4[u32(unconst_u32(795))][u32(vp4[u32(unconst_u32(34))][0][0].f4)][0].f4)));
  let ptr27: ptr<private, VertexOutput1> = &vp4[0][0][0];
  let ptr28: ptr<private, vec4i> = &vp4[pack4xI8(vp4[0][0][0].f11)][0][u32(unconst_u32(60))].f11;
  let vf46: f32 = vp4[0][0][u32(unconst_u32(7))].f9[u32(unconst_u32(118))];
  vp2.whole *= vec3f(vp4[0][0][u32(unconst_u32(52))].f8.rrb);
  let ptr29: ptr<private, u32> = &vp4[u32(unconst_u32(113))][0][0].f10;
  let ptr30: ptr<private, vec4i> = &(*ptr27).f11;
  vp7 = VertexOutput1(i32(vp4[u32(unconst_u32(42))][u32(unconst_u32(294))][0].f6), u32(vp4[u32(unconst_u32(42))][u32(unconst_u32(294))][0].f6), vp4[u32(unconst_u32(42))][u32(unconst_u32(294))][0].f6, f32(vp4[u32(unconst_u32(42))][u32(unconst_u32(294))][0].f6), vec4h(vp4[u32(unconst_u32(42))][u32(unconst_u32(294))][0].f6), vec4f(f32(vp4[u32(unconst_u32(42))][u32(unconst_u32(294))][0].f6)), u32(vp4[u32(unconst_u32(42))][u32(unconst_u32(294))][0].f6), vec4i(i32(vp4[u32(unconst_u32(42))][u32(unconst_u32(294))][0].f6)));
  vp2 = modf(bitcast<vec3f>(vp4[0][0][u32(unconst_u32(391))].f11.bgr));
  vp6[u32((*ptr27).f6)] = modf(vec2h(vp7.f9.bg));
  return out;
}

@fragment
fn fragment1(@location(3) @interpolate(linear) a0: vec2h, @location(14) a1: vec4u) -> FragmentOutput1 {
  var out: FragmentOutput1;
  vp5 = mat3x4h(f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4), f16(vp7.f4));
  vp6[u32(unconst_u32(85))] = modf(bitcast<vec2h>(vp7.f10));
  let ptr31: ptr<private, VertexOutput1> = &vp4[0][0][0];
  vp5 += mat3x4h(vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6, vp4[0][0][0].f6);
  vp6[u32(unconst_u32(436))].fract = vec2h(vp4[0][0][0].f6);
  vp3.f12 = vec4f(f32(any(bool(unconst_bool(true)))));
  vp5 += mat3x4h(vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6, vp4[u32(unconst_u32(386))][u32(unconst_u32(127))][u32(unconst_u32(198))].f6);
  out.f0 = vp4[u32(unconst_u32(42))][u32(unconst_u32(1000))][u32(unconst_u32(9))].f11;
  return out;
}

@compute @workgroup_size(2, 1, 1)
fn compute1() {
  storageBarrier();
  vp4[u32(unconst_u32(85))][u32(unconst_u32(234))][u32(unconst_u32(155))] = VertexOutput1(i32(vp4[u32(unconst_u32(33))][u32(unconst_u32(5))][u32(unconst_u32(357))].f8[u32(unconst_u32(58))]), u32(vp4[u32(unconst_u32(33))][u32(unconst_u32(5))][u32(unconst_u32(357))].f8[u32(unconst_u32(58))]), vp4[u32(unconst_u32(33))][u32(unconst_u32(5))][u32(unconst_u32(357))].f8[u32(unconst_u32(58))], f32(vp4[u32(unconst_u32(33))][u32(unconst_u32(5))][u32(unconst_u32(357))].f8[u32(unconst_u32(58))]), vec4h(vp4[u32(unconst_u32(33))][u32(unconst_u32(5))][u32(unconst_u32(357))].f8[u32(unconst_u32(58))]), vec4f(f32(vp4[u32(unconst_u32(33))][u32(unconst_u32(5))][u32(unconst_u32(357))].f8[u32(unconst_u32(58))])), u32(vp4[u32(unconst_u32(33))][u32(unconst_u32(5))][u32(unconst_u32(357))].f8[u32(unconst_u32(58))]), vec4i(i32(vp4[u32(unconst_u32(33))][u32(unconst_u32(5))][u32(unconst_u32(357))].f8[u32(unconst_u32(58))])));
  let ptr32: ptr<private, vec2h> = &vp6[u32(unconst_u32(41))].whole;
}`,
  sourceMap: {},
  hints: {},
});
let buffer3 = device0.createBuffer({
  size: 8655,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder13 = device0.createCommandEncoder({label: '\u5263\u3c92\u5905\u2b76\u0df6\u0b98'});
let textureView6 = texture13.createView({label: '\u{1f8d5}\u0435'});
let computePassEncoder12 = commandEncoder13.beginComputePass({});
try {
commandEncoder8.copyBufferToBuffer(buffer3, 1004, buffer0, 16, 560);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture9,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 0,
  origin: {x: 17, y: 4, z: 0},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
let imageData1 = new ImageData(24, 20);
let bindGroup3 = device0.createBindGroup({
  label: '\u{1f6b5}\u0792\u9b3e\u0f3d\ue2a5\u{1f784}\u4a9f\u038a\u2b44\u0fcf\u{1ffac}',
  layout: bindGroupLayout2,
  entries: [
    {binding: 227, resource: {buffer: buffer3, offset: 256, size: 1713}},
    {binding: 68, resource: textureView4},
  ],
});
let computePassEncoder13 = commandEncoder8.beginComputePass({});
try {
device0.queue.writeBuffer(buffer1, 6428, new BigUint64Array(4061), 699, 380);
} catch {}
let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt470m', transfer: 'iec6196624'} });
let bindGroup4 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 345, resource: {buffer: buffer3, offset: 0, size: 924}}],
});
let texture15 = gpuCanvasContext0.getCurrentTexture();
let textureView7 = texture4.createView({baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder4.pushDebugGroup('\u64d6');
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer4 = device0.createBuffer({size: 3969, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let commandEncoder14 = device0.createCommandEncoder({label: '\ufa4e\u0c79\uf74a\u00b2\u01e4\u{1fe5b}\u9bf5\uc705\u0fa1'});
try {
computePassEncoder9.setBindGroup(3, bindGroup4, new Uint32Array(45), 1, 0);
} catch {}
let buffer5 = device0.createBuffer({
  size: 606,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture16 = device0.createTexture({
  size: [129, 20, 28],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder14 = commandEncoder14.beginComputePass({});
try {
computePassEncoder13.setBindGroup(3, bindGroup2);
} catch {}
try {
buffer1.unmap();
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext1 = canvas1.getContext('webgpu');
let imageBitmap0 = await createImageBitmap(videoFrame0);
let bindGroup5 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [
    {binding: 227, resource: {buffer: buffer3, offset: 3840, size: 599}},
    {binding: 68, resource: textureView4},
  ],
});
let texture17 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 1},
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture18 = device0.createTexture({
  size: [328, 1, 128],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView8 = texture18.createView({
  label: '\u0e8e\u{1f755}\u0103\ubbf9\u38db\u8a82\u{1ffc3}\uab40\u9a0f\u{1fd9a}\u{1f7e6}',
  dimension: '2d-array',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 26,
  arrayLayerCount: 74,
});
try {
computePassEncoder7.setBindGroup(3, bindGroup2, new Uint32Array(247), 24, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(10_116).fill(15), /* required buffer size: 10_116 */
{offset: 15, bytesPerRow: 37, rowsPerImage: 39}, {width: 0, height: 0, depthOrArrayLayers: 8});
} catch {}
let commandEncoder15 = device0.createCommandEncoder();
let textureView9 = texture0.createView({mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder15 = commandEncoder15.beginComputePass({label: '\ua681\uf1d8'});
try {
computePassEncoder5.setBindGroup(0, bindGroup1);
} catch {}
let textureView10 = texture1.createView({format: 'rgba8uint', mipLevelCount: 1});
let externalTexture4 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'});
try {
computePassEncoder8.setBindGroup(3, bindGroup4);
} catch {}
try {
computePassEncoder3.setBindGroup(1, bindGroup0, new Uint32Array(390), 22, 0);
} catch {}
try {
  await buffer2.mapAsync(GPUMapMode.READ, 408);
} catch {}
try {
globalThis.someLabel = renderBundleEncoder2.label;
} catch {}
let textureView11 = texture13.createView({label: '\u2190\uced1\u8d1a\u{1fe8c}\u0818', arrayLayerCount: 1});
let sampler7 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 29.85,
  lodMaxClamp: 89.24,
});
try {
computePassEncoder8.setBindGroup(2, bindGroup0);
} catch {}
try {
buffer0.unmap();
} catch {}
canvas0.width = 212;
let texture19 = device0.createTexture({
  label: '\u6bca\u9805\u{1f90c}\u{1f8bb}',
  size: {width: 16, height: 16, depthOrArrayLayers: 12},
  mipLevelCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let commandEncoder16 = device0.createCommandEncoder();
try {
computePassEncoder14.setBindGroup(1, bindGroup5, new Uint32Array(866), 52, 0);
} catch {}
try {
commandEncoder16.clearBuffer(buffer0, 32, 36);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 37, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(17).fill(162), /* required buffer size: 17 */
{offset: 17, bytesPerRow: 50, rowsPerImage: 36}, {width: 3, height: 2, depthOrArrayLayers: 0});
} catch {}
let querySet0 = device0.createQuerySet({type: 'occlusion', count: 1});
try {
computePassEncoder5.setBindGroup(3, bindGroup2);
} catch {}
try {
computePassEncoder13.setBindGroup(0, bindGroup2, new Uint32Array(131), 0, 0);
} catch {}
let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte170m', transfer: 'logSqrt'} });
let commandEncoder17 = device0.createCommandEncoder({});
let texture20 = device0.createTexture({
  size: {width: 328, height: 1, depthOrArrayLayers: 1},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView12 = texture0.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder14.setBindGroup(3, bindGroup0);
} catch {}
try {
commandEncoder17.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1940 */
  offset: 1940,
  bytesPerRow: 768,
  rowsPerImage: 320,
  buffer: buffer3,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(270).fill(222), /* required buffer size: 270 */
{offset: 270}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let texture21 = device0.createTexture({
  size: [328, 1, 16],
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler8 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 77.33,
  lodMaxClamp: 94.46,
  maxAnisotropy: 18,
});
try {
commandEncoder17.clearBuffer(buffer5, 152, 20);
} catch {}
let videoFrame4 = new VideoFrame(videoFrame2, {timestamp: 0});
try {
globalThis.someLabel = externalTexture4.label;
} catch {}
let buffer6 = device0.createBuffer({size: 15254, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture22 = device0.createTexture({
  label: '\uc076\u63ff\ue30a\u67fb\u{1fcf5}\uf734\u0cca\u{1fbc4}\u1792\uecb8\u0647',
  size: [16],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler9 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 13.47,
});
try {
computePassEncoder4.setBindGroup(0, bindGroup5);
} catch {}
try {
computePassEncoder5.setBindGroup(3, bindGroup2, new Uint32Array(317), 177, 0);
} catch {}
try {
  await promise3;
} catch {}
let commandEncoder18 = device0.createCommandEncoder();
let texture23 = device0.createTexture({size: [32, 5, 22], sampleCount: 1, format: 'rgba32sint', usage: GPUTextureUsage.TEXTURE_BINDING});
let textureView13 = texture20.createView({label: '\u11dc\u83a9\u0ca1\u0f24\u04a9\u0367\u{1fd00}', dimension: '2d-array', arrayLayerCount: 1});
let computePassEncoder16 = commandEncoder18.beginComputePass({});
let renderPassEncoder0 = commandEncoder16.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -12.58, g: -64.73, b: -395.4, a: 859.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder0.setIndexBuffer(buffer5, 'uint16', 68, 59);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, undefined, 0, 705_039_934);
} catch {}
try {
computePassEncoder4.popDebugGroup();
} catch {}
try {
renderPassEncoder0.insertDebugMarker('\u838f');
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let commandEncoder19 = device0.createCommandEncoder();
let textureView14 = texture13.createView({});
let computePassEncoder17 = commandEncoder17.beginComputePass({});
try {
renderPassEncoder0.setBindGroup(3, bindGroup2, new Uint32Array(1374), 142, 0);
} catch {}
try {
commandEncoder19.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 224 */
  offset: 224,
  bytesPerRow: 2816,
  rowsPerImage: 606,
  buffer: buffer5,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer0, 52, new DataView(new ArrayBuffer(810)), 18, 264);
} catch {}
let texture24 = device0.createTexture({
  label: '\ub2f2\u0e07\u7f74\u{1feb4}',
  size: [164, 1, 2],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder18 = commandEncoder19.beginComputePass({});
let sampler10 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 57.69,
  lodMaxClamp: 70.88,
  maxAnisotropy: 17,
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup1, new Uint32Array(6477), 16, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
await gc();
let imageData2 = new ImageData(16, 12);
try {
computePassEncoder18.label = '\ud8a5\u7046\u{1fb72}\u0877\u5a6c\u654d\u0539';
} catch {}
let buffer7 = device0.createBuffer({
  size: 8333,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
renderPassEncoder0.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer5, 'uint16', 28, 87);
} catch {}
let arrayBuffer0 = buffer2.getMappedRange(408, 4);
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
try {
  await promise5;
} catch {}
let querySet1 = device0.createQuerySet({type: 'occlusion', count: 775});
let textureView15 = texture8.createView({});
let sampler11 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.17,
  lodMaxClamp: 75.74,
  maxAnisotropy: 16,
});
try {
computePassEncoder15.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup1);
} catch {}
try {
computePassEncoder11.insertDebugMarker('\u0c1c');
} catch {}
try {
device0.queue.submit([]);
} catch {}
let bindGroup6 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [
    {binding: 68, resource: textureView5},
    {binding: 227, resource: {buffer: buffer7, offset: 2304, size: 1195}},
  ],
});
let textureView16 = texture14.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1});
try {
computePassEncoder14.setBindGroup(1, bindGroup4, new Uint32Array(781), 7, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup3, new Uint32Array(32), 1, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer5, 'uint16', 156, 46);
} catch {}
try {
buffer0.unmap();
} catch {}
await gc();
try {
renderPassEncoder0.executeBundles([renderBundle1, renderBundle0, renderBundle1, renderBundle1]);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer5, 'uint16', 160, 389);
} catch {}
try {
buffer4.unmap();
} catch {}
let commandEncoder20 = device0.createCommandEncoder({});
let computePassEncoder19 = commandEncoder20.beginComputePass({});
try {
renderPassEncoder0.setVertexBuffer(1, buffer3, 0, 2_465);
} catch {}
try {
buffer7.unmap();
} catch {}
document.body.append(canvas1);
await gc();
let bindGroup7 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 69, resource: externalTexture4}]});
let textureView17 = texture7.createView({dimension: '2d-array'});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], stencilReadOnly: true});
try {
computePassEncoder4.setBindGroup(1, bindGroup1, new Uint32Array(3405), 438, 0);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -421.4, g: -536.0, b: -727.8, a: 431.3, });
} catch {}
try {
renderBundleEncoder3.setBindGroup(3, bindGroup2);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer5, 'uint16', 130, 137);
} catch {}
document.body.append(canvas1);
let commandEncoder21 = device0.createCommandEncoder({});
let texture25 = device0.createTexture({
  size: [16, 2, 1],
  mipLevelCount: 4,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder1 = commandEncoder21.beginRenderPass({
  label: '\u013a\u{1fe27}\u{1f8b3}\u{1f88c}\uce8b\u013e\u{1fdcf}',
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: -459.3, g: -812.5, b: 70.50, a: -535.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
let sampler12 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 77.76,
  lodMaxClamp: 92.28,
});
try {
computePassEncoder18.setBindGroup(2, bindGroup3, new Uint32Array(824), 381, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup5, new Uint32Array(6719), 2_075, 0);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle2, renderBundle2]);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(6, buffer6, 0);
} catch {}
let pipeline0 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0}});
await gc();
let bindGroup8 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 69, resource: externalTexture0}]});
let buffer8 = device0.createBuffer({size: 14429, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture26 = device0.createTexture({size: [16, 16, 12], format: 'rgba32sint', usage: GPUTextureUsage.COPY_SRC});
let textureView18 = texture1.createView({dimension: '3d', mipLevelCount: 1});
try {
computePassEncoder4.setBindGroup(2, bindGroup7, new Uint32Array(2423), 70, 0);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup5, new Uint32Array(2402), 120, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup1);
} catch {}
let textureView19 = texture18.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 4});
let sampler13 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 36.06,
  lodMaxClamp: 91.25,
  maxAnisotropy: 13,
});
try {
computePassEncoder15.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder3.setBindGroup(1, bindGroup4, new Uint32Array(560), 29, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer5, 'uint32', 88, 103);
} catch {}
try {
renderBundleEncoder3.setBindGroup(0, bindGroup7);
} catch {}
try {
buffer3.unmap();
} catch {}
let shaderModule2 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

diagnostic(info, xyz);

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

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

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

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

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

@group(0) @binding(69) var et1: texture_external;

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

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

fn fn0() -> array<array<f32, 7>, 1> {
  var out: array<array<f32, 7>, 1>;
  var vf47: u32 = countOneBits(u32(unconst_u32(269)));
  vf47 &= u32(round(vec4h(unconst_f16(4822.0), unconst_f16(2949.7), unconst_f16(8176.6), unconst_f16(331.9)))[2]);
  var vf48: u32 = countOneBits(pack4xU8Clamp(vec4u(vp8[5])));
  let ptr33: ptr<function, u32> = &vf47;
  vp8[u32(unconst_u32(58))] -= vp8[5];
  let vf49: f16 = vp8[5][u32(unconst_u32(38))];
  let ptr34: ptr<private, vec4h> = &vp8[u32(unconst_u32(29))];
  let ptr35: ptr<function, u32> = &(*ptr33);
  var vf50: f16 = dot(vec2h(unconst_f16(6574.2), unconst_f16(4714.4)), vec2h(unconst_f16(14493.9), unconst_f16(9293.2)));
  let ptr36: ptr<private, array<vec4h, 6>> = &vp8;
  let ptr37: ptr<private, array<vec4h, 6>> = &vp8;
  let ptr38: ptr<private, vec4h> = &(*ptr37)[5];
  vf47 &= vf47;
  out[u32(unconst_u32(26))][6] -= vec4f(vp8[5]).b;
  return out;
}

var<workgroup> vw3: array<atomic<i32>, 9>;

var<workgroup> vw4: atomic<u32>;

var<workgroup> vw5: i32;

var<workgroup> vw6: array<f32, 1>;

var<workgroup> vw7: atomic<i32>;

var<private> vp8: array<vec4h, 6> = array(vec4h(7668.0, 6862.0, -22659.9, 14141.7), vec4h(179.3, 26863.7, 1668.2, 13998.1), vec4h(3662.0, 8237.0, 3551.3, 9451.7), vec4h(31402.5, 10107.1, 12375.8, 18054.4), vec4h(14277.4, 8676.9, 986.9, 36458.0), vec4h(12184.8, 11663.7, 4126.2, 1762.8));

@vertex @must_use
fn vertex4() -> @builtin(position) vec4f {
  var out: vec4f;
  vp8[u32(unconst_u32(545))] = vec4h(insertBits(vec4i(unconst_i32(206), unconst_i32(524), unconst_i32(410), unconst_i32(376)), vec4i(unconst_i32(68), unconst_i32(8), unconst_i32(69), unconst_i32(640)), u32(unconst_u32(181)), u32(unconst_u32(129))));
  vp8[5] -= acosh(vec4h(unconst_f16(21618.1), unconst_f16(-265.8), unconst_f16(10060.2), unconst_f16(12987.3)));
  out = unpack4x8unorm(pack4xI8Clamp(vec4i(unconst_i32(291), unconst_i32(-62), unconst_i32(406), unconst_i32(626))));
  let vf51: vec4f = textureLoad(et1, vec2u(unconst_u32(304), unconst_u32(114)));
  out += vec4f(normalize(vec2h(unconst_f16(15916.3), unconst_f16(11744.3))).xxyx);
  let vf52: vec4i = insertBits(vec4i(unconst_i32(14), unconst_i32(25), unconst_i32(82), unconst_i32(236)), vec4i(exp(vec3f(unconst_f32(0.01540), unconst_f32(0.04431), unconst_f32(0.1332))).xxxz), u32(unconst_u32(96)), bitcast<u32>(unpack4xI8(u32(unconst_u32(62))).r));
  let vf53: vec4i = vf52;
  out = vec4f(textureDimensions(et1).gggg);
  let ptr39: ptr<private, vec4h> = &vp8[u32(unconst_u32(4))];
  var vf54: vec4h = acos(vec4h(unconst_f16(1189.9), unconst_f16(-16534.2), unconst_f16(11744.6), unconst_f16(7387.3)));
  vf54 = vec4h(vf52);
  vp8[u32(unconst_u32(48))] = vec4h(vf53);
  let vf55: vec2h = normalize(vec2h(unconst_f16(18871.6), unconst_f16(32237.0)));
  var vf56: f16 = vf55[u32(unconst_u32(26))];
  vf54 += vec4h(vf51);
  var vf57: vec4f = floor(vec4f(unconst_f32(0.02974), unconst_f32(0.06314), unconst_f32(0.4021), unconst_f32(0.06026)));
  var vf58: i32 = vf52[u32(unconst_u32(214))];
  vf54 = faceForward(vec2h(unconst_f16(79.10), unconst_f16(14174.3)), vec2h(unconst_f16(376.6), unconst_f16(21013.7)), vec2h(unconst_f16(7601.8), unconst_f16(31517.0))).rrgr;
  let vf59: vec3f = exp(vec3f(unconst_f32(0.01978), unconst_f32(-0.1227), unconst_f32(0.2813)));
  out = unpack4x8snorm(pack2x16unorm(vec2f(bitcast<f32>(vf52[u32(unconst_u32(1))]))));
  var vf60: vec4i = vf53;
  return out;
}

@fragment
fn fragment2() -> @location(200) vec4i {
  var out: vec4i;
  vp8[u32(unconst_u32(38))] -= vec4h(f16(pack4xU8Clamp(vec4u(unconst_u32(54), unconst_u32(112), unconst_u32(258), unconst_u32(87)))));
  out = unpack4xI8(pack4xU8Clamp(vec4u(unconst_u32(21), unconst_u32(88), unconst_u32(23), unconst_u32(105))));
  vp8[u32(unconst_u32(5))] = vp8[5];
  out |= vec4i(bitcast<i32>(pack4xI8(vec4i(unconst_i32(80), unconst_i32(106), unconst_i32(726), unconst_i32(161)))));
  var vf61: f32 = atan(f32(unconst_f32(0.1297)));
  fn0();
  out += vec4i(i32(vp8[5][u32(fract(vp8[5].a))]));
  var vf62 = fn0();
  let ptr40: ptr<function, f32> = &vf62[u32(unconst_u32(246))][u32(unconst_u32(67))];
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute2() {
  vp8[u32(unconst_u32(63))] += vec4h(f16(any(bool(unconst_bool(true)))));
  var vf63: bool = any(bool(unconst_bool(true)));
  atomicStore(&vw4, u32(unconst_u32(439)));
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder22 = device0.createCommandEncoder({});
let renderPassEncoder2 = commandEncoder22.beginRenderPass({
  colorAttachments: [{
  view: textureView15,
  depthSlice: 36,
  clearValue: { r: -981.7, g: 585.4, b: -503.8, a: -260.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], stencilReadOnly: true});
let sampler14 = device0.createSampler({
  label: '\uc05f\u5695\u{1f730}\ufb59\u107a',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 74.44,
  lodMaxClamp: 95.59,
  maxAnisotropy: 8,
});
try {
computePassEncoder6.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup6, new Uint32Array(1796), 46, 0);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -361.1, g: 169.3, b: 386.5, a: -155.7, });
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup5);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
  await promise4;
} catch {}
canvas1.width = 939;
let querySet2 = device0.createQuerySet({type: 'occlusion', count: 23});
let texture27 = device0.createTexture({
  size: {width: 328, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
try {
computePassEncoder9.setBindGroup(3, bindGroup0, new Uint32Array(480), 191, 0);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup4, new Uint32Array(38), 2, 0);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle0]);
} catch {}
try {
renderBundleEncoder4.setIndexBuffer(buffer5, 'uint16', 64, 83);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let buffer9 = device0.createBuffer({
  size: 10486,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder23 = device0.createCommandEncoder({});
let texture28 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 31},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView20 = texture1.createView({mipLevelCount: 1});
let renderPassEncoder3 = commandEncoder23.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: 675.9, g: -402.7, b: -739.4, a: 372.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup2);
} catch {}
try {
computePassEncoder12.setBindGroup(0, bindGroup8, new Uint32Array(231), 53, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(1, bindGroup6, new Uint32Array(2202), 260, 0);
} catch {}
let buffer10 = device0.createBuffer({
  label: '\u688c\uaff4\uf664\u7cfe\ueb00\u{1fe06}',
  size: 1083,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let commandEncoder24 = device0.createCommandEncoder();
let texture29 = device0.createTexture({
  size: {width: 328, height: 1, depthOrArrayLayers: 43},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle3 = renderBundleEncoder4.finish({});
let externalTexture5 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder15.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup0, new Uint32Array(1930), 67, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer5, 'uint16', 150, 38);
} catch {}
let computePassEncoder20 = commandEncoder24.beginComputePass({label: '\u09ea\u{1fbee}\u587c\u{1f70a}\u{1ff5e}\u764b\u6db2'});
let renderBundle4 = renderBundleEncoder3.finish({});
try {
computePassEncoder3.setBindGroup(2, bindGroup8, new Uint32Array(3066), 810, 0);
} catch {}
try {
renderPassEncoder0.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer9, 'uint32', 2_572, 439);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder25 = device0.createCommandEncoder();
let textureView21 = texture6.createView({dimension: '2d-array', baseMipLevel: 0});
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer1, 5_096); };
} catch {}
try {
computePassEncoder20.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(1, buffer7, 1_600, 3_481);
} catch {}
let buffer11 = device0.createBuffer({size: 13782, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX});
let texture30 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView22 = texture26.createView({dimension: 'cube', format: 'rgba32sint'});
let computePassEncoder21 = commandEncoder25.beginComputePass({label: '\u0c9c\uada7\uf3d7'});
try {
computePassEncoder16.setBindGroup(0, bindGroup1);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder19.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(3, bindGroup7);
} catch {}
let arrayBuffer1 = buffer2.getMappedRange(416, 0);
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let texture31 = device0.createTexture({
  size: {width: 656, height: 1, depthOrArrayLayers: 1},
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder19.setBindGroup(0, bindGroup1, new Uint32Array(1125), 31, 0);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, buffer4, 0, 1_080);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer11, 148, new Float32Array(179), 15, 0);
} catch {}
let commandEncoder26 = device0.createCommandEncoder({});
let textureView23 = texture23.createView({label: '\u{1fc79}\u0edc\ucd65\u0dc1\ue9b8\u7f03\u9d9a\ubd8c\uc994', dimension: '2d'});
let texture32 = device0.createTexture({
  label: '\u{1fd98}\u668e\u8ea2\u7b74\u4d0e\u3c32\u0b21\u0061\u{1ff20}\u9b71',
  size: {width: 32},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let texture33 = gpuCanvasContext1.getCurrentTexture();
let computePassEncoder22 = commandEncoder26.beginComputePass({});
let sampler15 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 89.18,
  lodMaxClamp: 93.38,
  compare: 'not-equal',
  maxAnisotropy: 16,
});
try {
computePassEncoder11.setBindGroup(3, bindGroup7);
} catch {}
try {
computePassEncoder17.setBindGroup(2, bindGroup0, new Uint32Array(1873), 42, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer9, 1_324); };
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup8, new Uint32Array(3963), 360, 0);
} catch {}
try {
renderPassEncoder2.setViewport(84.54663852273936, 0.8880433224450016, 330.25208875840747, 0.015043029533070884, 0.3156784534959387, 0.36861682216300545);
} catch {}
try {
  await buffer0.mapAsync(GPUMapMode.READ, 1248, 0);
} catch {}
let texture34 = device0.createTexture({
  size: {width: 82},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView24 = texture5.createView({label: '\u474a\ua013\u89e9\uf06b\u0fc2\u{1fcd6}', dimension: '2d', baseArrayLayer: 9});
try {
computePassEncoder7.setBindGroup(3, bindGroup5, new Uint32Array(1711), 241, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer3, 708); };
} catch {}
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
let textureView25 = texture17.createView({baseArrayLayer: 0});
try {
computePassEncoder13.setBindGroup(3, bindGroup0, new Uint32Array(706), 226, 0);
} catch {}
try {
computePassEncoder5.end();
} catch {}
try {
computePassEncoder16.setPipeline(pipeline0);
} catch {}
let bindGroup9 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 67, resource: textureView10}]});
let computePassEncoder23 = commandEncoder6.beginComputePass({});
try {
device0.queue.submit([]);
} catch {}
let bindGroup10 = device0.createBindGroup({
  label: '\u9f04\u1362\u09c5\udcdb\u4174\u7976\ue243\u0f24\u828c\uc93c\u890e',
  layout: bindGroupLayout0,
  entries: [{binding: 67, resource: textureView18}],
});
let sampler16 = device0.createSampler({
  label: '\ued0b\u6e3f\u{1f818}\ucd77\ua979\u2319\u7d39\u1aee\u{1fa7c}\ufa04\u314a',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  lodMaxClamp: 79.00,
});
try {
renderPassEncoder2.setBindGroup(0, bindGroup10, new Uint32Array(825), 29, 0);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: 163.1, g: -735.6, b: 790.5, a: 871.9, });
} catch {}
try {
device0.queue.writeBuffer(buffer3, 820, new Int16Array(10037), 613, 140);
} catch {}
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 484});
let texture35 = device0.createTexture({
  size: [129],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView26 = texture27.createView({mipLevelCount: 1, arrayLayerCount: 1});
let externalTexture6 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder23.setBindGroup(3, bindGroup5);
} catch {}
try {
computePassEncoder15.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder14.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup2, new Uint32Array(391), 57, 0);
} catch {}
try {
renderPassEncoder1.setScissorRect(165, 0, 140, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer5, 'uint16', 46, 54);
} catch {}
document.body.append(canvas1);
await gc();
let commandEncoder27 = device0.createCommandEncoder({});
let textureView27 = texture5.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2});
let sampler17 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 29.45,
});
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
let buffer12 = device0.createBuffer({
  size: 7376,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder28 = device0.createCommandEncoder({label: '\uf6d1\u5db5\u75c6\u457a\u4c9b\ube44\u0d3d'});
let textureView28 = texture5.createView({baseArrayLayer: 2, arrayLayerCount: 7});
let computePassEncoder24 = commandEncoder27.beginComputePass({});
try {
computePassEncoder9.setBindGroup(2, bindGroup3);
} catch {}
try {
computePassEncoder0.setBindGroup(1, bindGroup4, new Uint32Array(1259), 313, 0);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint32', 456, 380);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(145).fill(92), /* required buffer size: 145 */
{offset: 145}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas0);
let textureView29 = texture5.createView({aspect: 'all', baseArrayLayer: 9, arrayLayerCount: 12});
let renderPassEncoder4 = commandEncoder28.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  clearValue: { r: -329.1, g: -119.6, b: 291.8, a: -483.9, },
  loadOp: 'load',
  storeOp: 'store',
}],
});
try {
computePassEncoder19.setBindGroup(0, bindGroup1, new Uint32Array(1626), 175, 0);
} catch {}
try {
computePassEncoder24.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle3]);
} catch {}
let textureView30 = texture8.createView({});
let sampler18 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 35.48,
  lodMaxClamp: 70.25,
  compare: 'never',
});
try {
computePassEncoder22.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer5, 'uint16', 16, 19);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
globalThis.someLabel = device0.label;
} catch {}
let texture36 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 21},
  mipLevelCount: 5,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder12.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder8.setBindGroup(3, bindGroup3, new Uint32Array(395), 60, 0);
} catch {}
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
let textureView31 = texture24.createView({aspect: 'all', baseArrayLayer: 0});
let sampler19 = device0.createSampler({
  label: '\u095c\u503b\u0c93\uf430\u3494\u0c65\u3d04\u8e61\u280b',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 74.92,
  lodMaxClamp: 96.82,
});
try {
computePassEncoder11.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder17.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.setBindGroup(0, bindGroup5);
} catch {}
let arrayBuffer2 = buffer2.getMappedRange(424, 0);
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
let bindGroup11 = device0.createBindGroup({
  label: '\u{1fdd8}\u41f8\u07e9\u1f22\u0e42\ua027\u1efc\u0c15\u856a',
  layout: bindGroupLayout1,
  entries: [{binding: 69, resource: externalTexture6}],
});
let texture37 = device0.createTexture({
  size: [16, 16, 446],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder21.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup10);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(1, buffer5, 0);
} catch {}
try {
buffer11.unmap();
} catch {}
let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'bt2020_10bit'} });
try {
{ clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(4); };
} catch {}
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
buffer9.unmap();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let texture38 = device0.createTexture({
  size: [16, 16, 12],
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler20 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 35.03,
  lodMaxClamp: 91.94,
  maxAnisotropy: 19,
});
try {
computePassEncoder19.end();
} catch {}
try {
commandEncoder20.copyBufferToTexture({
  /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 416 */
  offset: 416,
  bytesPerRow: 20736,
  buffer: buffer3,
}, {
  texture: texture10,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let buffer13 = device0.createBuffer({size: 303, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX});
let commandEncoder29 = device0.createCommandEncoder({});
let textureView32 = texture6.createView({
  label: '\u237b\u09e4\uc140\u90af\u0320\u0e6c\u{1f99f}\u0349\u08ce',
  dimension: '2d-array',
  arrayLayerCount: 1,
});
let computePassEncoder25 = commandEncoder29.beginComputePass({});
let renderPassEncoder5 = commandEncoder20.beginRenderPass({
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: 228.6, g: 633.8, b: 808.7, a: 716.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
computePassEncoder3.setBindGroup(3, bindGroup0, new Uint32Array(2335), 38, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1, 2); };
} catch {}
try {
computePassEncoder16.end();
} catch {}
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer13, 'uint16', 6, 5);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 12, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(589).fill(44), /* required buffer size: 589 */
{offset: 49, bytesPerRow: 5, rowsPerImage: 27}, {width: 0, height: 0, depthOrArrayLayers: 5});
} catch {}
let commandEncoder30 = device0.createCommandEncoder({});
let computePassEncoder26 = commandEncoder18.beginComputePass({label: '\u{1fb65}\ufdd1\u{1f91a}\u{1f88f}\u0708\u1ecb\u1f90\u95c6\u0833\u6cee\u3be5'});
let renderPassEncoder6 = commandEncoder30.beginRenderPass({
  colorAttachments: [{
  view: textureView16,
  clearValue: { r: -255.6, g: 642.6, b: -25.53, a: -497.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let sampler21 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 63.56,
});
try {
computePassEncoder6.setBindGroup(0, bindGroup1);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer1, 2_196); };
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer4, 104, 300);
} catch {}
try {
computePassEncoder13.insertDebugMarker('\u0384');
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
await gc();
try {
externalTexture0.label = '\u0be6\ua9da\u{1f6da}\ua26c\uf776\u{1f6c6}\u0263\u{1ffc7}\u4d19\u4ce7\uc2ce';
} catch {}
let bindGroup12 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 69, resource: externalTexture3}]});
let texture39 = device0.createTexture({
  label: '\u1e38\ubaac\u053d\u{1ff05}\u7352\uf5b3\u41d0',
  size: [32, 5, 55],
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder26.setBindGroup(3, bindGroup2, new Uint32Array(81), 17, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder4.setVertexBuffer(0, buffer12, 112);
} catch {}
document.body.append(canvas1);
let textureView33 = texture5.createView({label: '\ubdb1\u407f', baseArrayLayer: 1, arrayLayerCount: 6});
try {
renderPassEncoder4.setBindGroup(3, bindGroup11);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let bindGroup13 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView11}]});
let commandEncoder31 = device0.createCommandEncoder({});
let textureView34 = texture26.createView({label: '\u{1fa5e}\ucc52\uaf44', dimension: 'cube-array', format: 'rgba32sint', arrayLayerCount: 6});
let computePassEncoder27 = commandEncoder31.beginComputePass({});
try {
computePassEncoder9.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder7.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(3, bindGroup8, new Uint32Array(326), 12, 0);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle0]);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer5, 'uint16', 138, 190);
} catch {}
try {
computePassEncoder20.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder4.setBindGroup(1, bindGroup10);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer9, 'uint16', 1_124, 175);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
let bindGroup14 = device0.createBindGroup({
  layout: bindGroupLayout3,
  entries: [{binding: 345, resource: {buffer: buffer3, offset: 0, size: 2660}}],
});
let commandEncoder32 = device0.createCommandEncoder({});
let textureView35 = texture24.createView({baseArrayLayer: 0});
let computePassEncoder28 = commandEncoder32.beginComputePass();
let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthReadOnly: true});
let sampler22 = device0.createSampler({
  label: '\u{1fbec}\uc15e\u{1faea}\u0a4b\u04d4',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 81.32,
  lodMaxClamp: 90.44,
  compare: 'always',
});
try {
computePassEncoder8.setBindGroup(1, bindGroup13);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer9, 'uint32', 1_644, 1_929);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(2, buffer11, 0);
} catch {}
try {
renderBundleEncoder5.setIndexBuffer(buffer13, 'uint32', 8, 4);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let buffer14 = device0.createBuffer({
  size: 3440,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder33 = device0.createCommandEncoder({label: '\udd9a\u04c4'});
let texture40 = device0.createTexture({
  size: {width: 32},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder29 = commandEncoder33.beginComputePass({});
try {
computePassEncoder24.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(1059), 257, 0);
} catch {}
let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470m', transfer: 'bt1361ExtendedColourGamut'} });
let bindGroup15 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 67, resource: textureView18}]});
let texture41 = device0.createTexture({
  size: [328, 1, 1],
  mipLevelCount: 4,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle5 = renderBundleEncoder5.finish({});
try {
computePassEncoder26.setBindGroup(1, bindGroup2);
} catch {}
try {
computePassEncoder13.setBindGroup(2, bindGroup13, new Uint32Array(673), 41, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(1, bindGroup4, new Uint32Array(295), 137, 0);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer9, 'uint32', 108, 1_000);
} catch {}
let imageData3 = new ImageData(108, 8);
let buffer15 = device0.createBuffer({size: 1419, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC});
let textureView36 = texture9.createView({aspect: 'all', format: 'rgba32sint', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 0});
let sampler23 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 46.28,
  lodMaxClamp: 88.78,
  maxAnisotropy: 12,
});
let externalTexture7 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
computePassEncoder12.setBindGroup(3, bindGroup5, new Uint32Array(1636), 230, 0);
} catch {}
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(6, buffer12, 44, 363);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 101, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(2_468_314).fill(13), /* required buffer size: 2_468_314 */
{offset: 118, bytesPerRow: 3706, rowsPerImage: 74}, {width: 230, height: 0, depthOrArrayLayers: 10});
} catch {}
let canvas2 = document.createElement('canvas');
let bindGroupLayout5 = device0.createBindGroupLayout({
  label: '\ufdb6\u0b0f\u0881',
  entries: [
    {binding: 179, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 104,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 73, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 112, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }},
    {
      binding: 25,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 462, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {
      binding: 216,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 277,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 42,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {
      binding: 58,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 10,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 5,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {binding: 14, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }},
    {
      binding: 89,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 9,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 81,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
  ],
});
let buffer16 = device0.createBuffer({
  size: 16946,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder34 = device0.createCommandEncoder();
let texture42 = device0.createTexture({
  label: '\ub946\u{1f8c7}\u5f42\u882f\udfac\u74a9\u096f\u{1f604}\u{1fff0}',
  size: [16, 16, 12],
  format: 'depth24plus',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture43 = device0.createTexture({
  size: {width: 16, height: 16, depthOrArrayLayers: 12},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView37 = texture3.createView({dimension: '2d', baseArrayLayer: 5});
let sampler24 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 82.48,
  lodMaxClamp: 84.14,
});
try {
computePassEncoder29.setBindGroup(0, bindGroup2, new Uint32Array(1748), 297, 0);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle5, renderBundle4, renderBundle2, renderBundle1, renderBundle2, renderBundle4, renderBundle0, renderBundle4, renderBundle0]);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture1,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture18,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(140_773).fill(127), /* required buffer size: 140_773 */
{offset: 325, bytesPerRow: 336, rowsPerImage: 19}, {width: 13, height: 0, depthOrArrayLayers: 23});
} catch {}
let texture44 = device0.createTexture({
  size: [328, 1, 44],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture45 = device0.createTexture({size: [656, 1, 16], format: 'rgba32sint', usage: GPUTextureUsage.STORAGE_BINDING});
let texture46 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder30 = commandEncoder34.beginComputePass({});
try {
computePassEncoder3.setBindGroup(0, bindGroup4, new Uint32Array(1828), 169, 0);
} catch {}
try {
computePassEncoder12.end();
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder5.setBindGroup(2, bindGroup12, new Uint32Array(77), 6, 0);
} catch {}
try {
commandEncoder13.clearBuffer(buffer3, 688, 680);
} catch {}
let buffer17 = device0.createBuffer({
  size: 10386,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let texture47 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 55},
  dimension: '3d',
  format: 'rg8snorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture48 = device0.createTexture({size: [64, 10, 44], format: 'rgba32sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
let computePassEncoder31 = commandEncoder13.beginComputePass({label: '\u0d04\ue5eb\u78d4\u961d\ub18f\ufbe7'});
try {
computePassEncoder29.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup13);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setViewport(142.9740124281637, 0.23574448253440206, 15.687178279120284, 0.5475140266115464, 0.6738748490420505, 0.6920583114811474);
} catch {}
let commandEncoder35 = device0.createCommandEncoder({});
let textureView38 = texture44.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder20.setBindGroup(3, bindGroup5);
} catch {}
try {
computePassEncoder30.setBindGroup(1, bindGroup15, new Uint32Array(1510), 163, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(2); };
} catch {}
try {
renderPassEncoder5.setBindGroup(1, bindGroup3);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup15, new Uint32Array(534), 42, 0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer9, 'uint16', 412, 1_713);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(4, buffer8);
} catch {}
let arrayBuffer3 = buffer2.getMappedRange(432, 0);
try {
commandEncoder35.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 8, y: 1, z: 9},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 1,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
},
{width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView39 = texture44.createView({dimension: '3d', format: 'r8unorm', mipLevelCount: 1, arrayLayerCount: 1});
let computePassEncoder32 = commandEncoder35.beginComputePass({});
try {
computePassEncoder10.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder30.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setViewport(252.2140761191765, 0.39186969253081994, 51.867498098610234, 0.08874672973891719, 0.6356371295076012, 0.9954607779986109);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer13, 'uint16', 36, 42);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer6, 1_268);
} catch {}
let promise6 = shaderModule2.getCompilationInfo();
document.body.append(canvas2);
let bindGroup16 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView11}]});
let buffer18 = device0.createBuffer({
  size: 24613,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let texture49 = device0.createTexture({
  size: {width: 656, height: 1, depthOrArrayLayers: 39},
  sampleCount: 1,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture50 = device0.createTexture({
  size: [328, 1, 364],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler25 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 36.17,
  lodMaxClamp: 89.59,
  compare: 'less',
});
try {
computePassEncoder25.setBindGroup(1, bindGroup6, new Uint32Array(3510), 481, 0);
} catch {}
try {
renderPassEncoder4.setBindGroup(3, bindGroup0);
} catch {}
let pipeline1 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  multisample: {count: 1, mask: 0x7f5a8fb},
  fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rgba32sint', writeMask: 0}]},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 348,
        attributes: [
          {format: 'uint16x2', offset: 0, shaderLocation: 10},
          {format: 'uint16x2', offset: 0, shaderLocation: 3},
          {format: 'float32x2', offset: 28, shaderLocation: 9},
        ],
      },
    ],
  },
});
let buffer19 = device0.createBuffer({size: 4333, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView40 = texture42.createView({dimension: '2d'});
let texture51 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 55},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView41 = texture14.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1});
let sampler26 = device0.createSampler({addressModeU: 'clamp-to-edge', magFilter: 'nearest', lodMinClamp: 68.61, lodMaxClamp: 83.74});
try {
computePassEncoder2.setBindGroup(0, bindGroup12, new Uint32Array(398), 172, 0);
} catch {}
try {
computePassEncoder29.setPipeline(pipeline0);
} catch {}
let shaderModule3 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

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

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

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

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

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

@group(0) @binding(67) var tex0: texture_3d<u32>;

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

struct FragmentOutput2 {
  @location(7) f0: vec2u,
  @builtin(sample_mask) f1: u32,
  @location(0) f2: vec4i,
}

@id(25683) override override0: f16;

fn fn0() -> f16 {
  var out: f16;
  vp11.whole = unpack4x8unorm(atomicLoad(&vw8[6]));
  vp9 = FragmentOutput2(vec2u(pack4x8unorm(vec4f(unconst_f32(0.1359), unconst_f32(0.3432), unconst_f32(0.1620), unconst_f32(0.1080)))), pack4x8unorm(vec4f(unconst_f32(0.1359), unconst_f32(0.3432), unconst_f32(0.1620), unconst_f32(0.1080))), vec4i(i32(pack4x8unorm(vec4f(unconst_f32(0.1359), unconst_f32(0.3432), unconst_f32(0.1620), unconst_f32(0.1080))))));
  atomicAdd(&vw8[u32(unconst_u32(115))], u32(unconst_u32(458)));
  let ptr41: ptr<private, vec2u> = &vp10.f0;
  var vf64: vec4i = select(vec4i(unconst_i32(-414), unconst_i32(78), unconst_i32(14), unconst_i32(4)), vec4i(unconst_i32(140), unconst_i32(452), unconst_i32(110), unconst_i32(268)), bool(unconst_bool(false)));
  var vf65: u32 = atomicLoad(&(*&vw8)[6]);
  vp9 = FragmentOutput2(textureDimensions(tex0, i32(unconst_i32(30))).yy, textureDimensions(tex0, i32(unconst_i32(30)))[1], bitcast<vec4i>(textureDimensions(tex0, i32(unconst_i32(30))).rrbr));
  let vf66: u32 = atomicLoad(&vw8[6]);
  let ptr42: ptr<private, vec2u> = &(*ptr41);
  vp10.f2 *= vec4i(i32(atomicLoad(&(*&vw8)[atomicExchange(&vw8[u32(unconst_u32(87))], pack4xI8(unpack4xI8(u32(unconst_u32(106)))))])));
  vf65 &= bitcast<u32>(vp11.whole.y);
  var vf67: f16 = override0;
  let ptr43: ptr<private, vec4i> = &vp10.f2;
  out = f16(step(vec3f(unconst_f32(0.04473), unconst_f32(0.09003), unconst_f32(0.2499)), vec3f(unconst_f32(0.00142), unconst_f32(0.3987), unconst_f32(0.4694)))[1]);
  var vf68: i32 = (*ptr43)[vp10.f0.x];
  vp10.f2 ^= vec4i(i32(vf67));
  let vf69: vec3f = step(vec3f(unconst_f32(-0.08152), unconst_f32(0.3474), unconst_f32(0.2691)), vec3f(unconst_f32(0.1467), unconst_f32(0.05976), unconst_f32(0.01787)));
  vf67 -= f16(pack4x8unorm(vec4f(unconst_f32(0.2960), unconst_f32(0.05721), unconst_f32(0.4261), unconst_f32(0.06994))));
  let ptr44: ptr<private, vec2u> = &vp10.f0;
  let ptr45: ptr<function, vec4i> = &vf64;
  return out;
  _ = override0;
}

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

var<private> vp9: FragmentOutput2 = FragmentOutput2(vec2u(34, 21), u32(270), vec4i(49, 219, 527, 61));

var<private> vp10: FragmentOutput2 = FragmentOutput2(vec2u(95, 41), u32(308), vec4i(28, 158, 69, 110));

var<private> vp11 = modf(vec4f(-0.2461, 0.05935, 0.4486, 0.02088));

@fragment
fn fragment3(@builtin(front_facing) a0: bool) -> FragmentOutput2 {
  var out: FragmentOutput2;
  var vf70: u32 = insertBits(u32(unconst_u32(291)), u32(unconst_u32(147)), u32(unconst_u32(289)), u32(unconst_u32(71)));
  out.f0 = vp9.f0;
  vp11.fract *= inverseSqrt(vec2f(unconst_f32(0.06635), unconst_f32(0.1842))).grgr;
  let ptr46: ptr<private, vec2u> = &vp10.f0;
  vp10 = FragmentOutput2(vec2u(insertBits(u32(unconst_u32(163)), u32(unconst_u32(165)), u32(unconst_u32(172)), u32(unconst_u32(32)))), insertBits(u32(unconst_u32(163)), u32(unconst_u32(165)), u32(unconst_u32(172)), u32(unconst_u32(32))), vec4i(i32(insertBits(u32(unconst_u32(163)), u32(unconst_u32(165)), u32(unconst_u32(172)), u32(unconst_u32(32))))));
  out.f1 <<= bitcast<u32>(unpack4x8unorm(u32(unconst_u32(45))).x);
  out.f0 = vec2u(vp10.f0[u32(unconst_u32(78))]);
  vf70 &= vp10.f0[0];
  vf70 = u32(max(f16(unconst_f16(10935.0)), f16(unconst_f16(6056.9))));
  var vf71: vec2f = inverseSqrt(vec2f(unconst_f32(0.00063), unconst_f32(0.2078)));
  let ptr47: ptr<private, FragmentOutput2> = &vp10;
  let ptr48: ptr<private, vec4i> = &vp9.f2;
  var vf72: i32 = vp9.f2[u32(unconst_u32(148))];
  var vf73: vec4u = textureLoad(tex0, vec3i(unconst_i32(33), unconst_i32(229), unconst_i32(51)), (*ptr47).f2[3]);
  return out;
}

@compute @workgroup_size(1, 1, 1)
fn compute3() {
  fn0();
  let vf74: i32 = dot(unpack4xI8(atomicLoad(&vw8[6])), vec4i(unconst_i32(109), unconst_i32(52), unconst_i32(-18), unconst_i32(165)));
  let ptr49: ptr<private, FragmentOutput2> = &vp10;
  var vf75: u32 = max(u32(unconst_u32(408)), u32(unconst_u32(134)));
  let ptr50: ptr<private, vec4f> = &vp11.whole;
  let ptr51: ptr<workgroup, atomic<u32>> = &vw8[u32(unconst_u32(530))];
  let vf76: vec4f = asinh(vec4f(unconst_f32(0.00912), unconst_f32(0.3023), unconst_f32(0.08638), unconst_f32(0.09661)));
  var vf77 = fn0();
  let ptr52: ptr<private, vec4i> = &vp9.f2;
  vf77 *= tan(vec4h(unconst_f16(20930.6), unconst_f16(4160.9), unconst_f16(7895.3), unconst_f16(9837.5))).z;
  vf77 += f16(vf75);
  let ptr53: ptr<workgroup, atomic<u32>> = &vw8[6];
  vp10.f0 = vec2u(atomicLoad(&(*ptr51)));
  let ptr54: ptr<private, u32> = &(*ptr49).f1;
  vp9 = FragmentOutput2(vec2u(vp10.f0[u32(unconst_u32(81))]), vp10.f0[u32(unconst_u32(81))], vec4i(bitcast<i32>(vp10.f0[u32(unconst_u32(81))])));
  var vf78: i32 = vf74;
  let ptr55: ptr<private, vec2u> = &vp10.f0;
  vf77 = f16(textureDimensions(tex0)[0]);
  vp10.f2 = vp9.f2;
  atomicExchange(&vw8[u32(unconst_u32(146))], u32(unconst_u32(338)));
  _ = override0;
}`,
  sourceMap: {},
});
let buffer20 = device0.createBuffer({
  size: 9469,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder36 = device0.createCommandEncoder({});
let texture52 = device0.createTexture({
  size: [328, 1, 134],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView42 = texture13.createView({mipLevelCount: 1});
let computePassEncoder33 = commandEncoder36.beginComputePass({label: '\u{1fea8}\u4ac5\u0206\ub06b\u09fe\u{1fb84}\u3d83\u5cce\ubfe4'});
try {
computePassEncoder6.end();
} catch {}
try {
commandEncoder4.copyBufferToBuffer(buffer3, 516, buffer18, 4928, 3688);
} catch {}
document.body.append(canvas0);
try {
adapter0.label = '\uc589\ub99f\u0936\u0a53';
} catch {}
let bindGroup17 = device0.createBindGroup({
  label: '\u0b5e\udeeb\u6794\u0d2a\u09b9\u93ff',
  layout: bindGroupLayout4,
  entries: [{binding: 13, resource: textureView14}],
});
let buffer21 = device0.createBuffer({size: 14206, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView43 = texture52.createView({});
let texture53 = device0.createTexture({
  size: [64, 10, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView44 = texture45.createView({label: '\u037d\u0f63\u{1f8e6}', aspect: 'all', baseArrayLayer: 4, arrayLayerCount: 2});
let renderPassEncoder7 = commandEncoder4.beginRenderPass({
  colorAttachments: [{
  view: textureView41,
  clearValue: { r: -540.3, g: -117.7, b: 595.4, a: -335.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
let sampler27 = device0.createSampler({addressModeV: 'mirror-repeat', lodMinClamp: 22.93, lodMaxClamp: 87.31});
let gpuCanvasContext2 = canvas2.getContext('webgpu');
try {
  await promise6;
} catch {}
let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder37 = device0.createCommandEncoder({});
try {
computePassEncoder18.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer16, 0);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
commandEncoder37.copyBufferToBuffer(buffer15, 28, buffer14, 132, 60);
} catch {}
try {
commandEncoder37.resolveQuerySet(querySet2, 2, 4, buffer17, 1280);
} catch {}
try {
globalThis.someLabel = sampler1.label;
} catch {}
let bindGroupLayout6 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 226,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' },
    },
  ],
});
let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: []});
let textureView45 = texture22.createView({label: '\u0f63\u0d2d\ua670\u2986\u{1fbcd}\u3456\u3c6e\u5e37\ud505'});
let computePassEncoder34 = commandEncoder37.beginComputePass({label: '\u{1fc70}\u0d93\u25b7\u0c90\u{1f808}\ud20b'});
try {
renderPassEncoder2.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder2.setViewport(71.0137320727024, 0.38893156355213465, 512.3736077038933, 0.06021828120915055, 0.5252071466493626, 0.7102355594128401);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer5, 'uint32', 52, 85);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer5, 52); };
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer7, 0, 680);
} catch {}
let imageData4 = new ImageData(20, 4);
let commandEncoder38 = device0.createCommandEncoder({});
let querySet4 = device0.createQuerySet({label: '\uf75b\u{1fe75}\uac68\u5f6b\u{1fc3b}\u0748\u{1f82e}\u{1fcf4}', type: 'occlusion', count: 888});
let textureView46 = texture17.createView({});
let computePassEncoder35 = commandEncoder38.beginComputePass();
try {
renderPassEncoder6.setBindGroup(0, bindGroup7, new Uint32Array(579), 148, 0);
} catch {}
try {
computePassEncoder23.insertDebugMarker('\u1ec5');
} catch {}
try {
device0.queue.writeBuffer(buffer13, 4, new Int16Array(9369), 635, 4);
} catch {}
let commandEncoder39 = device0.createCommandEncoder({});
let texture54 = device0.createTexture({
  size: {width: 64},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder8 = commandEncoder39.beginRenderPass({
  label: '\uebf7\u000c\u0088\u{1fa0e}\ua1ff',
  colorAttachments: [{view: textureView26, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet3,
});
try {
computePassEncoder35.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline1);
} catch {}
try {
adapter1.label = '\ucfcd\u05d6\u04eb\u0175\u0668';
} catch {}
let buffer22 = device0.createBuffer({size: 10580, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let textureView47 = texture53.createView({label: '\u06cc\udd3f\u0efe\ue8bf', dimension: '2d-array'});
try {
computePassEncoder1.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup13, new Uint32Array(151), 21, 0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer11, 0);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer23 = device0.createBuffer({size: 3434, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder40 = device0.createCommandEncoder({});
let renderPassEncoder9 = commandEncoder40.beginRenderPass({
  colorAttachments: [{
  view: textureView19,
  clearValue: { r: 15.83, g: -107.2, b: 887.6, a: 772.4, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet3,
  maxDrawCount: 160485605,
});
try {
computePassEncoder9.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer9, 'uint16', 2_404, 2_588);
} catch {}
document.body.append(canvas1);
let commandEncoder41 = device0.createCommandEncoder({label: '\u60ba\u000f'});
let textureView48 = texture48.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 19});
let computePassEncoder36 = commandEncoder41.beginComputePass({});
try {
computePassEncoder4.setPipeline(pipeline0);
} catch {}
try {
buffer21.unmap();
} catch {}
try {
renderPassEncoder8.pushDebugGroup('\u0a10');
} catch {}
let bindGroup18 = device0.createBindGroup({
  label: '\udf0b\u{1fda7}\u660e\u0346\u0645\ue16c\u{1fdbe}\ueaf6\u{1fdfe}',
  layout: bindGroupLayout1,
  entries: [{binding: 69, resource: externalTexture0}],
});
let buffer24 = device0.createBuffer({
  size: 1448,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
try {
computePassEncoder26.setBindGroup(1, bindGroup11);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
device0.queue.writeBuffer(buffer11, 420, new DataView(new ArrayBuffer(5484)), 2689, 256);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(107).fill(32), /* required buffer size: 107 */
{offset: 107}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let buffer25 = device0.createBuffer({
  size: 588,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder42 = device0.createCommandEncoder({});
let renderPassEncoder10 = commandEncoder42.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  clearValue: { r: 914.3, g: 98.89, b: 233.6, a: 752.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 77529942,
});
try {
computePassEncoder13.setBindGroup(2, bindGroup9, new Uint32Array(99), 2, 0);
} catch {}
try {
renderPassEncoder2.setBindGroup(3, bindGroup0, []);
} catch {}
let buffer26 = device0.createBuffer({
  size: 13471,
  usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture55 = device0.createTexture({
  label: '\u0ac4\u0577\u006a',
  size: [129, 20, 32],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let sampler28 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 98.31,
  maxAnisotropy: 12,
});
try {
renderPassEncoder9.setIndexBuffer(buffer13, 'uint16', 18, 93);
} catch {}
let commandEncoder43 = device0.createCommandEncoder({label: '\uf1a1\u{1f6d6}\u0f7c\u{1fa98}\u{1f8f7}\u0a22\u{1f6dd}\ue8b2'});
let textureView49 = texture22.createView({format: 'rgba32sint'});
let computePassEncoder37 = commandEncoder43.beginComputePass({});
try {
computePassEncoder34.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(40);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer12, 244);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
}, new Uint8Array(200).fill(119), /* required buffer size: 200 */
{offset: 200}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let buffer27 = device0.createBuffer({size: 5094, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 190});
let texture56 = gpuCanvasContext2.getCurrentTexture();
try {
computePassEncoder29.setBindGroup(0, bindGroup12);
} catch {}
try {
computePassEncoder31.setBindGroup(2, bindGroup1, new Uint32Array(466), 125, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder2.end();
} catch {}
try {
computePassEncoder9.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setViewport(2.168568189654941, 0.34656117916888474, 254.52622282565503, 0.4035280406045447, 0.7645017313849903, 0.922165338974239);
} catch {}
document.body.append(canvas1);
let texture57 = device0.createTexture({
  size: {width: 82, height: 1, depthOrArrayLayers: 20},
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView50 = texture22.createView({mipLevelCount: 1});
let computePassEncoder38 = commandEncoder2.beginComputePass({});
let sampler29 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 86.03,
  maxAnisotropy: 3,
});
try {
computePassEncoder23.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup0, new Uint32Array(2565), 385, 0);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle2, renderBundle5]);
} catch {}
try {
renderPassEncoder1.setScissorRect(38, 0, 102, 0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer5, 'uint32', 192, 5);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let texture58 = device0.createTexture({
  label: '\u{1f619}\u{1fa6e}',
  size: [32, 5, 1],
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let sampler30 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 68.46,
  lodMaxClamp: 96.85,
  maxAnisotropy: 2,
});
let externalTexture8 = device0.importExternalTexture({source: videoFrame2});
try {
renderPassEncoder8.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 14, y: 1, z: 0},
  aspect: 'all',
}, new Uint8Array(256).fill(110), /* required buffer size: 256 */
{offset: 256, bytesPerRow: 309}, {width: 11, height: 2, depthOrArrayLayers: 0});
} catch {}
let commandEncoder44 = device0.createCommandEncoder({label: '\u{1f837}\u{1fa84}\u01ca\u{1fa68}\u4012\ud84e'});
let renderPassEncoder11 = commandEncoder44.beginRenderPass({
  colorAttachments: [{view: textureView15, depthSlice: 14, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet1,
});
try {
renderPassEncoder11.setIndexBuffer(buffer9, 'uint16', 4_580, 704);
} catch {}
try {
buffer23.unmap();
} catch {}
let bindGroup19 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 277, resource: textureView25},
    {binding: 5, resource: textureView12},
    {binding: 216, resource: {buffer: buffer3, offset: 0, size: 5045}},
    {binding: 179, resource: externalTexture8},
    {binding: 14, resource: {buffer: buffer26, offset: 512, size: 443}},
    {binding: 42, resource: textureView0},
    {binding: 81, resource: textureView40},
    {binding: 10, resource: textureView43},
    {binding: 104, resource: textureView39},
    {binding: 89, resource: sampler12},
    {binding: 58, resource: {buffer: buffer26, offset: 768, size: 1066}},
    {binding: 25, resource: textureView42},
    {binding: 9, resource: textureView42},
    {binding: 73, resource: sampler1},
    {binding: 462, resource: sampler7},
    {binding: 112, resource: sampler16},
  ],
});
let commandEncoder45 = device0.createCommandEncoder({});
let texture59 = device0.createTexture({
  size: [32, 5, 55],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView51 = texture17.createView({dimension: '2d'});
let renderPassEncoder12 = commandEncoder45.beginRenderPass({
  colorAttachments: [{
  view: textureView16,
  clearValue: { r: 399.8, g: 202.4, b: 997.4, a: 908.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 337137033,
});
try {
computePassEncoder38.setPipeline(pipeline0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
let textureView52 = texture19.createView({dimension: '2d', baseArrayLayer: 1, arrayLayerCount: 1});
let sampler31 = device0.createSampler({
  label: '\uac8f\u155d\u{1fbc2}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  lodMinClamp: 50.47,
  lodMaxClamp: 78.25,
  compare: 'greater-equal',
});
try {
computePassEncoder21.setBindGroup(1, bindGroup3, new Uint32Array(4359), 573, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle3, renderBundle3]);
} catch {}
try {
renderPassEncoder5.setVertexBuffer(4, buffer8, 52, 841);
} catch {}
let buffer28 = device0.createBuffer({
  size: 2860,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder46 = device0.createCommandEncoder();
let computePassEncoder39 = commandEncoder46.beginComputePass({});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({label: '\u{1fd06}\u1f85\u5874\u{1f969}\u0083\u008a', colorFormats: ['rgba32sint']});
try {
renderPassEncoder0.setBindGroup(3, bindGroup11, new Uint32Array(1727), 620, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer28, 'uint16', 358, 6);
} catch {}
let bindGroupLayout7 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 14,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 42,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer29 = device0.createBuffer({size: 5421, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder47 = device0.createCommandEncoder({});
let textureView53 = texture42.createView({dimension: 'cube'});
let computePassEncoder40 = commandEncoder47.beginComputePass({});
let sampler32 = device0.createSampler({
  addressModeV: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 13.82,
  lodMaxClamp: 41.31,
  compare: 'always',
});
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(743), 28, 0);
} catch {}
try {
renderPassEncoder6.setViewport(71.48685477801068, 0.6338159804843755, 7.438352622042565, 0.19715562834938963, 0.924956173680011, 0.9455770359780951);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer5, 'uint16', 34, 64);
} catch {}
let promise7 = shaderModule3.getCompilationInfo();
let texture60 = device0.createTexture({
  label: '\u0f21\ub2ea\u2496\ub6c5\u76fc\u{1f7e2}\u0e89\u{1f81d}\u0279',
  size: [32, 5, 55],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder40.setBindGroup(2, bindGroup10);
} catch {}
try {
computePassEncoder38.setBindGroup(0, bindGroup0, new Uint32Array(88), 9, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer1, 3_472); };
} catch {}
try {
computePassEncoder40.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let imageData5 = new ImageData(24, 100);
let bindGroup20 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 67, resource: textureView43}]});
let renderBundle6 = renderBundleEncoder6.finish({});
try {
computePassEncoder39.setPipeline(pipeline0);
} catch {}
let bindGroup21 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView42}]});
let buffer30 = device0.createBuffer({size: 44229, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let texture61 = device0.createTexture({
  size: [328, 1, 134],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler33 = device0.createSampler({
  label: '\u{1fe38}\u{1fad7}',
  addressModeU: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 84.09,
  lodMaxClamp: 94.30,
  compare: 'never',
  maxAnisotropy: 6,
});
try {
computePassEncoder35.setBindGroup(3, bindGroup14, new Uint32Array(3224), 66, 0);
} catch {}
try {
computePassEncoder31.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer13, 'uint16', 14, 33);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'iec6196624'} });
let commandEncoder48 = device0.createCommandEncoder({});
let renderPassEncoder13 = commandEncoder48.beginRenderPass({
  colorAttachments: [{
  view: textureView30,
  depthSlice: 19,
  clearValue: { r: -620.4, g: 980.3, b: 297.6, a: 110.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
renderPassEncoder2.executeBundles([renderBundle0, renderBundle5, renderBundle4]);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer3, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let buffer31 = device0.createBuffer({size: 9195, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE});
let commandEncoder49 = device0.createCommandEncoder({});
let texture62 = device0.createTexture({
  size: [164, 1, 1],
  mipLevelCount: 6,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView54 = texture42.createView({dimension: 'cube-array', aspect: 'depth-only', baseMipLevel: 0, baseArrayLayer: 4, arrayLayerCount: 6});
let computePassEncoder41 = commandEncoder49.beginComputePass({});
let sampler34 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 45.35,
  lodMaxClamp: 54.33,
});
let externalTexture9 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder0.setBindGroup(2, bindGroup20);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder33.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup16);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup7, new Uint32Array(1499), 370, 0);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer18, 'uint32', 3_292, 639);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let bindGroup22 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 67, resource: textureView43}]});
let texture63 = device0.createTexture({
  size: [16, 16, 12],
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthStencilFormat: 'depth32float'});
try {
renderPassEncoder11.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer5, 'uint32', 304, 38);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture61,
  mipLevel: 0,
  origin: {x: 64, y: 0, z: 5},
  aspect: 'all',
}, new Uint8Array(69_970).fill(141), /* required buffer size: 69_970 */
{offset: 40, bytesPerRow: 90, rowsPerImage: 37}, {width: 3, height: 0, depthOrArrayLayers: 22});
} catch {}
let promise8 = device0.queue.onSubmittedWorkDone();
let imageData6 = new ImageData(20, 24);
let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'film', transfer: 'logSqrt'} });
try {
computePassEncoder9.setBindGroup(1, bindGroup13, new Uint32Array(1732), 209, 0);
} catch {}
try {
computePassEncoder28.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(7, undefined);
} catch {}
let sampler35 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 87.48});
try {
computePassEncoder37.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(2, buffer3, 0, 366);
} catch {}
try {
renderPassEncoder8.popDebugGroup();
} catch {}
let buffer32 = device0.createBuffer({size: 2104, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView55 = texture22.createView({aspect: 'all', baseMipLevel: 0});
try {
{ clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer3, 2_060); };
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup11);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer5, 8);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup8, new Uint32Array(692), 79, 0);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer30, 'uint32', 16_616, 813);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture41,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(52).fill(224), /* required buffer size: 52 */
{offset: 52}, {width: 78, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); };
} catch {}
try {
computePassEncoder30.setBindGroup(1, bindGroup20);
} catch {}
try {
computePassEncoder41.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer3, 924);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup7);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder50 = device0.createCommandEncoder({});
try {
computePassEncoder32.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup3, new Uint32Array(780), 301, 0);
} catch {}
try {
renderPassEncoder5.setIndexBuffer(buffer13, 'uint16', 26, 40);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, buffer5, 0, 338);
} catch {}
let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt2020', transfer: 'smpte240m'} });
let bindGroup23 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView6}]});
let computePassEncoder42 = commandEncoder50.beginComputePass({});
let sampler36 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 51.33,
});
try {
renderPassEncoder6.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup5);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(1, buffer5, 0, 189);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(213).fill(83), /* required buffer size: 213 */
{offset: 213}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u83ae\u0bc8\u{1fb4a}\u3de1\u130b\u53e6\ue75f\u03e2\ud6b7';
} catch {}
let commandEncoder51 = device0.createCommandEncoder({});
try {
computePassEncoder34.setBindGroup(0, bindGroup12);
} catch {}
try {
computePassEncoder26.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder7.setBindGroup(2, bindGroup16, new Uint32Array(1578), 128, 0);
} catch {}
try {
commandEncoder51.copyBufferToBuffer(buffer29, 5420, buffer12, 548, 0);
} catch {}
try {
commandEncoder51.copyBufferToTexture({
  /* bytesInLastRow: 384 widthInBlocks: 24 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 944 */
  offset: 944,
  bytesPerRow: 28416,
  buffer: buffer10,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 24, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder43 = commandEncoder51.beginComputePass({});
let renderBundle7 = renderBundleEncoder7.finish({});
try {
computePassEncoder0.setBindGroup(0, bindGroup12);
} catch {}
try {
computePassEncoder34.setBindGroup(0, bindGroup1, new Uint32Array(501), 58, 0);
} catch {}
try {
computePassEncoder42.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer15, 300, new Float32Array(1232), 299, 92);
} catch {}
let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt2020', transfer: 'hlg'} });
let textureView56 = texture5.createView({baseArrayLayer: 12, arrayLayerCount: 4});
try {
computePassEncoder41.setBindGroup(3, bindGroup16);
} catch {}
try {
computePassEncoder43.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setBindGroup(0, bindGroup12);
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup8, new Uint32Array(1551), 209, 0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle2, renderBundle1, renderBundle3, renderBundle1, renderBundle4, renderBundle3, renderBundle2]);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer13, 'uint16', 188, 1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 82},
  aspect: 'all',
}, new Uint8Array(467_078).fill(125), /* required buffer size: 467_078 */
{offset: 38, bytesPerRow: 1668, rowsPerImage: 28}, {width: 98, height: 0, depthOrArrayLayers: 11});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470m', transfer: 'smpteSt4281'} });
let textureView57 = texture49.createView({label: '\u08e6\u{1f666}\u{1f600}\u{1f984}\u0fe0\u8455\u419d\uafe4\u{1fe81}\u0e65', mipLevelCount: 1});
let texture64 = device0.createTexture({
  size: [16, 2, 62],
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let sampler37 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.28,
  lodMaxClamp: 73.59,
  maxAnisotropy: 6,
});
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup6, new Uint32Array(510), 85, 0);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle0, renderBundle6, renderBundle2]);
} catch {}
try {
renderPassEncoder13.setViewport(603.4892507230335, 0.9980405294606203, 32.17444076830055, 0.00037013179760170663, 0.7853922373853613, 0.9656280480227903);
} catch {}
try {
buffer1.unmap();
} catch {}
let bindGroupLayout8 = device0.createBindGroupLayout({
  entries: [
    {binding: 191, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
    {binding: 50, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {
      binding: 128,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
  ],
});
let bindGroup24 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView11}]});
let buffer33 = device0.createBuffer({
  size: 2259,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
});
let commandEncoder52 = device0.createCommandEncoder({});
let textureView58 = texture42.createView({dimension: 'cube-array', aspect: 'depth-only', baseArrayLayer: 4, arrayLayerCount: 6});
try {
computePassEncoder33.setBindGroup(1, bindGroup3, new Uint32Array(1035), 38, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup10);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer18, 'uint32', 920, 3_595);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT});
} catch {}
try {
device0.queue.writeBuffer(buffer12, 100, new Float32Array(4035), 114, 200);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture62,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(51).fill(39), /* required buffer size: 51 */
{offset: 51, bytesPerRow: 680, rowsPerImage: 56}, {width: 41, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder53 = device0.createCommandEncoder();
let texture65 = device0.createTexture({
  size: {width: 129, height: 20, depthOrArrayLayers: 1},
  dimension: '2d',
  format: 'r8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView59 = texture20.createView({label: '\u700b\u07e4\u9ec9\u53f6\u{1fff1}\u{1f819}', dimension: '2d-array', baseArrayLayer: 0});
let computePassEncoder44 = commandEncoder52.beginComputePass({label: '\u{1fa2c}\u0ad5\u{1fc7a}\u08ba\u04a2\u072d\u{1f62d}\u0c43\u{1ffa9}\u5d99\u4f3c'});
try {
computePassEncoder10.end();
} catch {}
try {
computePassEncoder44.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup3);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -996.3, g: 581.9, b: 470.4, a: 629.3, });
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline1);
} catch {}
let texture66 = device0.createTexture({
  size: {width: 129},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder45 = commandEncoder53.beginComputePass({});
try {
computePassEncoder45.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup21, new Uint32Array(1672), 257, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(6, buffer12, 0, 683);
} catch {}
let buffer34 = device0.createBuffer({
  size: 2419,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let computePassEncoder46 = commandEncoder12.beginComputePass({});
try {
computePassEncoder9.setBindGroup(0, bindGroup12, new Uint32Array(3997), 30, 0);
} catch {}
try {
computePassEncoder8.setPipeline(pipeline0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(55).fill(163), /* required buffer size: 55 */
{offset: 55}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt2020', transfer: 'unspecified'} });
let bindGroupLayout9 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 44,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
try {
computePassEncoder37.setBindGroup(0, bindGroup7, new Uint32Array(1043), 513, 0);
} catch {}
try {
renderPassEncoder11.setBindGroup(1, bindGroup0);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle5, renderBundle5]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer5);
} catch {}
try {
buffer24.unmap();
} catch {}
let buffer35 = device0.createBuffer({size: 3746, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder54 = device0.createCommandEncoder({});
let texture67 = device0.createTexture({
  size: {width: 129, height: 20, depthOrArrayLayers: 39},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder47 = commandEncoder54.beginComputePass({});
let sampler38 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 88.90,
  lodMaxClamp: 92.78,
  maxAnisotropy: 9,
});
try {
computePassEncoder41.setBindGroup(0, bindGroup15, new Uint32Array(1118), 100, 0);
} catch {}
let promise9 = shaderModule3.getCompilationInfo();
try {
device0.queue.writeTexture({
  texture: texture18,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 4},
  aspect: 'all',
}, new Uint8Array(2_294_931).fill(169), /* required buffer size: 2_294_931 */
{offset: 91, bytesPerRow: 2785, rowsPerImage: 103}, {width: 165, height: 0, depthOrArrayLayers: 9});
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
  await promise9;
} catch {}
let commandEncoder55 = device0.createCommandEncoder({});
let textureView60 = texture42.createView({dimension: '2d'});
let texture68 = device0.createTexture({
  size: {width: 328, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder48 = commandEncoder55.beginComputePass({});
let sampler39 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 67.27,
  lodMaxClamp: 80.32,
});
try {
computePassEncoder46.setPipeline(pipeline0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
let commandEncoder56 = device0.createCommandEncoder();
let renderPassEncoder14 = commandEncoder56.beginRenderPass({colorAttachments: [{view: textureView36, depthSlice: 16, loadOp: 'load', storeOp: 'store'}]});
try {
computePassEncoder27.setBindGroup(3, bindGroup20, new Uint32Array(1044), 5, 0);
} catch {}
try {
renderPassEncoder1.setViewport(257.0886318279025, 0.9301256161375717, 64.31326346445601, 0.03181135453266887, 0.05497030790159141, 0.09948142519700989);
} catch {}
try {
buffer25.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer3, 844, new BigUint64Array(12271), 5614, 96);
} catch {}
let commandEncoder57 = device0.createCommandEncoder();
let computePassEncoder49 = commandEncoder57.beginComputePass({});
try {
computePassEncoder32.setBindGroup(2, bindGroup17, new Uint32Array(1003), 6, 0);
} catch {}
try {
computePassEncoder24.end();
} catch {}
let bindGroup25 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 58, resource: {buffer: buffer10, offset: 0, size: 573}},
    {binding: 216, resource: {buffer: buffer26, offset: 3584, size: 1044}},
    {binding: 42, resource: textureView0},
    {binding: 9, resource: textureView14},
    {binding: 89, resource: sampler17},
    {binding: 25, resource: textureView14},
    {binding: 112, resource: sampler26},
    {binding: 277, resource: textureView25},
    {binding: 81, resource: textureView40},
    {binding: 10, resource: textureView43},
    {binding: 73, resource: sampler16},
    {binding: 104, resource: textureView38},
    {binding: 179, resource: externalTexture2},
    {binding: 5, resource: textureView0},
    {binding: 14, resource: {buffer: buffer9, offset: 3328, size: 515}},
    {binding: 462, resource: sampler38},
  ],
});
let buffer36 = device0.createBuffer({size: 6952, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let computePassEncoder50 = commandEncoder27.beginComputePass({});
let sampler40 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 36.42,
  lodMaxClamp: 61.93,
  maxAnisotropy: 1,
});
let externalTexture10 = device0.importExternalTexture({label: '\u{1f9f8}\u528e\ucb6d', source: videoFrame12, colorSpace: 'display-p3'});
try {
computePassEncoder46.setBindGroup(1, bindGroup2);
} catch {}
try {
computePassEncoder8.setBindGroup(2, bindGroup0, new Uint32Array(2141), 167, 0);
} catch {}
try {
computePassEncoder48.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.executeBundles([renderBundle4]);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer13, 'uint16', 86, 28);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture49,
  mipLevel: 0,
  origin: {x: 48, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(210_287).fill(143), /* required buffer size: 210_287 */
{offset: 135, bytesPerRow: 241, rowsPerImage: 109}, {width: 52, height: 0, depthOrArrayLayers: 9});
} catch {}
let commandEncoder58 = device0.createCommandEncoder({});
let computePassEncoder51 = commandEncoder58.beginComputePass({});
try {
computePassEncoder50.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup1, new Uint32Array(710), 15, 0);
} catch {}
try {
renderPassEncoder13.beginOcclusionQuery(0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer34, 'uint16', 138, 521);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 196, new Int16Array(7574), 1531, 404);
} catch {}
let bindGroup26 = device0.createBindGroup({
  label: '\u0a20\u0f6e\ua10f\uc196\u096c\u334c\u{1f61a}\u0e77',
  layout: bindGroupLayout7,
  entries: [
    {binding: 14, resource: textureView53},
    {binding: 42, resource: {buffer: buffer34, offset: 768, size: 308}},
  ],
});
let buffer37 = device0.createBuffer({size: 24352, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder59 = device0.createCommandEncoder({});
let computePassEncoder52 = commandEncoder59.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder29.end();
} catch {}
try {
computePassEncoder51.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(0, bindGroup25);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup6, new Uint32Array(83), 43, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(6, buffer11, 3_316, 1_349);
} catch {}
try {
commandEncoder33.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 9328 */
  offset: 544,
  bytesPerRow: 4352,
  buffer: buffer9,
}, {
  texture: texture38,
  mipLevel: 0,
  origin: {x: 3, y: 3, z: 7},
  aspect: 'all',
}, {width: 5, height: 3, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(13).fill(223), /* required buffer size: 13 */
{offset: 13}, {width: 42, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let texture69 = device0.createTexture({
  label: '\u{1f60d}\u019f\u6b5a\u99c4\u1070\u6c22\u85f6\u9dd8\uf3e8',
  size: [129, 20, 221],
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder52.setPipeline(pipeline0);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
document.body.prepend(canvas1);
await gc();
let commandEncoder60 = device0.createCommandEncoder();
let texture70 = device0.createTexture({
  size: [656, 1, 60],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder8.setBindGroup(2, bindGroup6);
} catch {}
try {
computePassEncoder50.setBindGroup(1, bindGroup9, new Uint32Array(31), 2, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer9, 1_696); };
} catch {}
try {
computePassEncoder49.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder14.setBindGroup(0, bindGroup2);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup26, new Uint32Array(321), 56, 0);
} catch {}
try {
commandEncoder33.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1888 */
  offset: 1888,
  bytesPerRow: 1280,
  buffer: buffer36,
}, {
  texture: texture40,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 1},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let buffer38 = device0.createBuffer({size: 3056, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX});
let texture71 = device0.createTexture({
  size: [129, 20, 30],
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder53 = commandEncoder33.beginComputePass({});
try {
computePassEncoder28.setBindGroup(0, bindGroup3, new Uint32Array(2311), 880, 0);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
document.body.append(canvas0);
let canvas3 = document.createElement('canvas');
let computePassEncoder54 = commandEncoder60.beginComputePass({});
try {
renderPassEncoder13.executeBundles([renderBundle2, renderBundle1, renderBundle0, renderBundle6]);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(0, buffer14, 244, 82);
} catch {}
document.body.prepend(canvas1);
let sampler41 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 78.23,
  lodMaxClamp: 90.98,
  compare: 'never',
  maxAnisotropy: 5,
});
try {
buffer9.unmap();
} catch {}
try {
  await promise8;
} catch {}
let textureView61 = texture47.createView({});
let sampler42 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 66.62,
  compare: 'less',
});
try {
computePassEncoder7.setBindGroup(0, bindGroup22);
} catch {}
try {
computePassEncoder53.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup2, new Uint32Array(3671), 308, 0);
} catch {}
try {
globalThis.someLabel = commandEncoder1.label;
} catch {}
let shaderModule4 = device0.createShaderModule({
  code: `
enable f16;

requires packed_4x8_integer_dot_product;

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

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

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

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

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

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

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

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

struct FragmentOutput3 {
  @location(4) f0: vec4u,
  @location(0) f1: vec4i,
  @location(3) f2: vec2u,
}

alias vec3b = vec3<bool>;

override override1: i32 = 6;

fn fn0() -> array<i32, 10> {
  var out: array<i32, 10>;
  out[u32(unconst_u32(23))] = min(bitcast<vec2i>(textureDimensions(et2)), vec2i(unconst_i32(17), unconst_i32(512))).r;
  vp12[u32(unconst_u32(27))] = bitcast<vec2f>(min(vec2i(unconst_i32(76), unconst_i32(287)), vec2i(unconst_i32(222), unconst_i32(244)))).x;
  var vf79: bool = any(bool(unconst_bool(false)));
  let ptr56: ptr<private, array<f32, 8>> = &vp12;
  let ptr57: ptr<private, f32> = &vp12[7];
  let ptr58: ptr<private, f32> = &(*ptr56)[u32(unconst_u32(16))];
  var vf80: f32 = determinant(mat4x4f(unconst_f32(0.3197), unconst_f32(0.02538), unconst_f32(-0.2983), unconst_f32(0.02009), unconst_f32(0.3205), unconst_f32(0.08498), unconst_f32(0.01056), unconst_f32(0.06292), unconst_f32(0.07726), unconst_f32(0.03247), unconst_f32(0.1557), unconst_f32(0.3404), unconst_f32(0.4768), unconst_f32(-0.06079), unconst_f32(0.05856), unconst_f32(0.01372)));
  var vf81: i32 = override1;
  return out;
  _ = override1;
}

fn fn1() -> mat2x2f {
  var out: mat2x2f;
  vp12[u32(unconst_u32(109))] = vp12[7];
  var vf82: vec3f = cosh(vec3f(unconst_f32(0.3657), unconst_f32(0.00850), unconst_f32(0.08065)));
  var vf83: vec3f = cosh(vec3f(unconst_f32(0.6460), unconst_f32(0.3657), unconst_f32(0.00383)));
  let ptr59: ptr<private, array<f32, 8>> = &vp12;
  out = mat2x2f(vec2f(saturate(vec3h(unconst_f16(2214.7), unconst_f16(6466.3), unconst_f16(1309.7))).gg), vec2f(saturate(vec3h(unconst_f16(2214.7), unconst_f16(6466.3), unconst_f16(1309.7))).rr));
  vf82 *= vec3f((*ptr59)[7]);
  let vf84: i32 = override1;
  return out;
  _ = override1;
}

fn fn2() -> array<mat3x4f, 1> {
  var out: array<mat3x4f, 1>;
  fn1();
  let ptr60: ptr<private, f32> = &vp12[7];
  fn1();
  vp12[u32(unconst_u32(2))] = (*ptr60);
  fn1();
  out[u32(unconst_u32(180))] = mat3x4f(bitcast<f32>(abs(u32(unconst_u32(13)))), f32(abs(u32(unconst_u32(13)))), f32(abs(u32(unconst_u32(13)))), f32(abs(u32(unconst_u32(13)))), bitcast<f32>(abs(u32(unconst_u32(13)))), bitcast<f32>(abs(u32(unconst_u32(13)))), f32(abs(u32(unconst_u32(13)))), f32(abs(u32(unconst_u32(13)))), f32(abs(u32(unconst_u32(13)))), bitcast<f32>(abs(u32(unconst_u32(13)))), f32(abs(u32(unconst_u32(13)))), f32(abs(u32(unconst_u32(13)))));
  return out;
  _ = override1;
}

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

var<workgroup> vw10: mat3x2h;

var<private> vp12: array<f32, 8> = array<f32, 8>(f32(0.09874), f32(0.03338), f32(0.4418), f32(0.2038), f32(-0.02786), f32(0.5935), f32(0.3821), f32(0.05248));

@vertex
fn vertex5(@location(14) @interpolate(linear, sample) a0: f16, @location(11) @interpolate(flat, center) a1: vec2h) -> VertexOutput3 {
  var out: VertexOutput3;
  let vf85: i32 = override1;
  out.f13 = vec4f(a1.grrg);
  var vf86 = fn2();
  return out;
  _ = override1;
}

@fragment
fn fragment4() -> FragmentOutput3 {
  var out: FragmentOutput3;
  discard;
  fn1();
  return out;
  _ = override1;
}

@compute @workgroup_size(2, 1, 1)
fn compute4() {
  fn1();
  vw10 = mat3x2h(vec2h(extractBits(vec3i(unconst_i32(51), unconst_i32(578), unconst_i32(21)), u32(unconst_u32(214)), u32(unconst_u32(421))).xx), vec2h(extractBits(vec3i(unconst_i32(51), unconst_i32(578), unconst_i32(21)), u32(unconst_u32(214)), u32(unconst_u32(421))).yz), vec2h(extractBits(vec3i(unconst_i32(51), unconst_i32(578), unconst_i32(21)), u32(unconst_u32(214)), u32(unconst_u32(421))).zz));
  var vf87 = fn1();
  fn1();
  let vf88: vec2h = vw10[pack2x16snorm(vf87[unconst_i32(0)])];
  atomicCompareExchangeWeak(&vw9[u32(unconst_u32(50))], unconst_i32(22), unconst_i32(44));
  vw10 -= mat3x2h(f16(atomicLoad(&(*&vw9)[u32(unconst_u32(309))])), f16(atomicLoad(&(*&vw9)[u32(unconst_u32(309))])), f16(atomicLoad(&(*&vw9)[u32(unconst_u32(309))])), f16(atomicLoad(&(*&vw9)[u32(unconst_u32(309))])), f16(atomicLoad(&(*&vw9)[u32(unconst_u32(309))])), f16(atomicLoad(&(*&vw9)[u32(unconst_u32(309))])));
  var vf89 = fn1();
  _ = override1;
}

@compute @workgroup_size(2, 1, 1)
fn compute5(@builtin(workgroup_id) a0: vec3u) {
  let vf90: i32 = atomicLoad(&vw9[0]);
  vp12[u32(unconst_u32(150))] += bitcast<f32>(a0[u32(unconst_u32(193))]);
  atomicXor(&vw9[u32(unconst_u32(126))], i32(unconst_i32(171)));
  let ptr61: ptr<workgroup, array<atomic<i32>, 1>> = &vw9;
  var vf91: vec2h = (*&vw10)[u32(unconst_u32(136))];
  vp12[u32(unconst_u32(225))] *= bitcast<f32>(workgroupUniformLoad(&vw10)[unconst_i32(1)]);
  atomicAnd(&vw9[u32(unconst_u32(30))], i32(unconst_i32(220)));
  vf91 = bitcast<vec2h>(vp12[7]);
  vf91 = bitcast<vec2h>(atomicLoad(&vw9[u32(unconst_u32(195))]));
  var vf92: f32 = round(f32(unconst_f32(0.2972)));
  var vf93 = fn1();
  var vf94 = fn1();
  vw10 = mat3x2h(f16(atomicExchange(&(*ptr61)[u32(unconst_u32(109))], i32(unconst_i32(16)))), f16(atomicExchange(&(*ptr61)[u32(unconst_u32(109))], i32(unconst_i32(16)))), f16(atomicExchange(&(*ptr61)[u32(unconst_u32(109))], i32(unconst_i32(16)))), f16(atomicExchange(&(*ptr61)[u32(unconst_u32(109))], i32(unconst_i32(16)))), f16(atomicExchange(&(*ptr61)[u32(unconst_u32(109))], i32(unconst_i32(16)))), f16(atomicExchange(&(*ptr61)[u32(unconst_u32(109))], i32(unconst_i32(16)))));
  let vf95: i32 = atomicExchange(&(*ptr61)[0], i32(unconst_i32(-8)));
  vf93 = mat2x2f(f32(atomicLoad(&vw9[u32(unconst_u32(39))])), bitcast<f32>(atomicLoad(&vw9[u32(unconst_u32(39))])), f32(atomicLoad(&vw9[u32(unconst_u32(39))])), bitcast<f32>(atomicLoad(&vw9[u32(unconst_u32(39))])));
  vf92 -= bitcast<f32>(vf95);
  vw10 = mat3x2h(ldexp(vec2h(unconst_f16(5331.9), unconst_f16(10828.9)), vec2i(unconst_i32(-12), unconst_i32(29))), ldexp(vec2h(unconst_f16(5331.9), unconst_f16(10828.9)), vec2i(unconst_i32(-12), unconst_i32(29))), ldexp(vec2h(unconst_f16(5331.9), unconst_f16(10828.9)), vec2i(unconst_i32(-12), unconst_i32(29))));
  let ptr62: ptr<function, f32> = &vf92;
  _ = override1;
}`,
  sourceMap: {},
  hints: {},
});
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(3, buffer8);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 113, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(346).fill(42), /* required buffer size: 346 */
{offset: 346, bytesPerRow: 29, rowsPerImage: 0}, {width: 1, height: 0, depthOrArrayLayers: 6});
} catch {}
let buffer39 = device0.createBuffer({
  size: 23096,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let commandEncoder61 = device0.createCommandEncoder({});
let texture72 = device0.createTexture({size: [16, 16, 12], mipLevelCount: 2, format: 'depth32float', usage: GPUTextureUsage.COPY_DST});
try {
computePassEncoder44.setBindGroup(0, bindGroup1, new Uint32Array(881), 162, 0);
} catch {}
try {
computePassEncoder47.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.setBindGroup(2, bindGroup25);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer39, 'uint16', 12_546, 3_058);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer11, 0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let buffer40 = device0.createBuffer({
  label: '\u5d1c\u03dd\u{1fd34}\u{1fe90}\uf015\u{1fca5}\u03a6\ud14c\u0e05\u68a8',
  size: 7354,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let computePassEncoder55 = commandEncoder61.beginComputePass({});
try {
computePassEncoder55.setPipeline(pipeline0);
} catch {}
document.body.append(canvas0);
let bindGroup27 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 10, resource: textureView57},
    {binding: 42, resource: textureView0},
    {binding: 25, resource: textureView40},
    {binding: 89, resource: sampler11},
    {binding: 81, resource: textureView60},
    {binding: 462, resource: sampler21},
    {binding: 9, resource: textureView6},
    {binding: 14, resource: {buffer: buffer20, offset: 256, size: 4981}},
    {binding: 112, resource: sampler40},
    {binding: 73, resource: sampler21},
    {binding: 216, resource: {buffer: buffer33, offset: 512, size: 833}},
    {binding: 179, resource: externalTexture6},
    {binding: 5, resource: textureView0},
    {binding: 277, resource: textureView4},
    {binding: 104, resource: textureView39},
    {binding: 58, resource: {buffer: buffer24, offset: 0}},
  ],
});
let buffer41 = device0.createBuffer({
  label: '\u{1f67a}\u7fb1\u{1f867}\u0af9\ua8df\u06cb\u60d9',
  size: 14595,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder62 = device0.createCommandEncoder({});
let computePassEncoder56 = commandEncoder62.beginComputePass({});
try {
computePassEncoder55.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup10, new Uint32Array(4012), 123, 0);
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer30, 'uint16', 2_222, 495);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
await gc();
let textureView62 = texture20.createView({});
try {
computePassEncoder15.setBindGroup(0, bindGroup11, new Uint32Array(643), 535, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroups(1); };
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(7, buffer39, 0);
} catch {}
let textureView63 = texture16.createView({baseMipLevel: 0, baseArrayLayer: 8, arrayLayerCount: 3});
let sampler43 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 1.477,
  lodMaxClamp: 43.73,
  compare: 'less',
  maxAnisotropy: 17,
});
try {
computePassEncoder53.setBindGroup(0, bindGroup15, new Uint32Array(1402), 74, 0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle0, renderBundle3, renderBundle6, renderBundle4, renderBundle1]);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer28, 'uint16', 132, 278);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
try {
  await promise7;
} catch {}
let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'iec6196624'} });
try {
adapter1.label = '\u{1fd0b}\u{1fb32}\u077d\u{1fd0a}\u8e93';
} catch {}
let buffer42 = device0.createBuffer({
  size: 3437,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let texture73 = device0.createTexture({
  label: '\u2c4f\u{1f8de}\u0cdf\u06f2\u{1fce0}\u{1fe6a}\u81a8\u7b66\u8f2d',
  size: [82],
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder22.setBindGroup(2, bindGroup20, new Uint32Array(1782), 597, 0);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle0, renderBundle3, renderBundle6, renderBundle3, renderBundle4, renderBundle4, renderBundle2]);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(3, buffer38, 480, 38);
} catch {}
try {
renderBundleEncoder8.setBindGroup(2, bindGroup9);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
} catch {}
let texture74 = device0.createTexture({
  size: [82, 1, 194],
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle8 = renderBundleEncoder8.finish({});
try {
computePassEncoder37.setBindGroup(1, bindGroup6, new Uint32Array(873), 278, 0);
} catch {}
try {
renderPassEncoder5.setBindGroup(0, bindGroup13);
} catch {}
try {
renderPassEncoder2.setBindGroup(0, bindGroup23, new Uint32Array(1036), 37, 0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(3, buffer14, 0, 644);
} catch {}
try {
buffer40.label = '\u{1fa94}\uec53\u009b\u2292\u060a\u{1fd06}\u2c0f\u2f81';
} catch {}
let bindGroup28 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 226, resource: textureView43}]});
let querySet6 = device0.createQuerySet({type: 'occlusion', count: 415});
let textureView64 = texture40.createView({aspect: 'all'});
try {
renderPassEncoder4.setBindGroup(2, bindGroup1);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(0, buffer28, 1_908);
} catch {}
try {
computePassEncoder36.insertDebugMarker('\u5a32');
} catch {}
try {
gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST});
} catch {}
try {
device0.queue.writeBuffer(buffer42, 716, new BigUint64Array(30744), 12721, 316);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture73,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(205).fill(65), /* required buffer size: 205 */
{offset: 205}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
await gc();
let commandEncoder63 = device0.createCommandEncoder({});
let texture75 = device0.createTexture({
  size: [82],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView65 = texture63.createView({aspect: 'all', arrayLayerCount: 1});
let computePassEncoder57 = commandEncoder63.beginComputePass({});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint']});
try {
computePassEncoder57.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.beginOcclusionQuery(136);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline1);
} catch {}
let bindGroup29 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 216, resource: {buffer: buffer3, offset: 768, size: 2841}},
    {binding: 462, resource: sampler19},
    {binding: 25, resource: textureView11},
    {binding: 73, resource: sampler4},
    {binding: 89, resource: sampler30},
    {binding: 277, resource: textureView4},
    {binding: 81, resource: textureView60},
    {binding: 10, resource: textureView43},
    {binding: 179, resource: externalTexture7},
    {binding: 112, resource: sampler1},
    {binding: 5, resource: textureView0},
    {binding: 14, resource: {buffer: buffer25, offset: 0}},
    {binding: 9, resource: textureView40},
    {binding: 104, resource: textureView61},
    {binding: 42, resource: textureView12},
    {binding: 58, resource: {buffer: buffer26, offset: 2560, size: 2839}},
  ],
});
try {
computePassEncoder51.setBindGroup(0, bindGroup11, new Uint32Array(5537), 1_049, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder51); computePassEncoder51.dispatchWorkgroupsIndirect(buffer34, 240); };
} catch {}
try {
computePassEncoder51.end();
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup28, []);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6, buffer36, 152, 91);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup29, new Uint32Array(515), 24, 0);
} catch {}
try {
  await shaderModule1.getCompilationInfo();
} catch {}
let commandEncoder64 = device0.createCommandEncoder({});
let querySet7 = device0.createQuerySet({label: '\u2a5e\u{1fa25}\u{1f79b}\ua820\ua44d\u00bc', type: 'occlusion', count: 550});
let sampler44 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 16.81,
  lodMaxClamp: 51.93,
  maxAnisotropy: 5,
});
try {
computePassEncoder36.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder53.setBindGroup(2, bindGroup24, new Uint32Array(4679), 2_341, 0);
} catch {}
try {
computePassEncoder54.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(4, undefined, 3_348_191_885);
} catch {}
try {
renderBundleEncoder9.setBindGroup(0, bindGroup19, new Uint32Array(4633), 1_003, 0);
} catch {}
try {
commandEncoder58.clearBuffer(buffer37);
} catch {}
try {
gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST});
} catch {}
let gpuCanvasContext3 = canvas3.getContext('webgpu');
let bindGroup30 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 14, resource: textureView53},
    {binding: 42, resource: {buffer: buffer20, offset: 4096, size: 400}},
  ],
});
let commandEncoder65 = device0.createCommandEncoder({});
let renderPassEncoder15 = commandEncoder58.beginRenderPass({
  colorAttachments: [{
  view: textureView41,
  clearValue: { r: 32.69, g: -968.2, b: -939.0, a: 739.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 114282263,
});
let sampler45 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 74.46,
  compare: 'not-equal',
});
try {
computePassEncoder56.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
let canvas4 = document.createElement('canvas');
let renderPassEncoder16 = commandEncoder64.beginRenderPass({
  colorAttachments: [{
  view: textureView26,
  clearValue: { r: -560.5, g: -661.3, b: -219.2, a: 571.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
});
try {
computePassEncoder38.setBindGroup(1, bindGroup25);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer28, 520, 18);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer28, 'uint32', 1_108, 567);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(192_979).fill(31), /* required buffer size: 192_979 */
{offset: 59, bytesPerRow: 4823, rowsPerImage: 10}, {width: 301, height: 0, depthOrArrayLayers: 5});
} catch {}
let buffer43 = device0.createBuffer({
  label: '\u5b54\u09a2\ub0c6\u6272\u0a99\u046d\u{1f9c3}',
  size: 11121,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView66 = texture42.createView({label: '\u494f\u{1fc2b}\u74fd\ud8fd\u1052', dimension: '2d', baseArrayLayer: 1});
let computePassEncoder58 = commandEncoder65.beginComputePass({});
let sampler46 = device0.createSampler({
  label: '\uccad\u0315\ucb6c\u{1f932}\u0e41\u078c\ua5a0',
  addressModeU: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 87.28,
  lodMaxClamp: 94.78,
});
try {
computePassEncoder58.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(3, bindGroup27, new Uint32Array(635), 7, 0);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
let bindGroup31 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView6}]});
let commandEncoder66 = device0.createCommandEncoder();
let computePassEncoder59 = commandEncoder66.beginComputePass({});
let renderBundle9 = renderBundleEncoder9.finish({});
try {
{ clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder55); computePassEncoder55.dispatchWorkgroupsIndirect(buffer16, 11_376); };
} catch {}
try {
computePassEncoder59.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setBindGroup(2, bindGroup28);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(133).fill(8), /* required buffer size: 133 */
{offset: 133, bytesPerRow: 33}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
let buffer44 = device0.createBuffer({
  label: '\u06e0\u0d65\u{1fa89}\u{1fd4f}\ub467\udcfc\u8023',
  size: 7590,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder67 = device0.createCommandEncoder({label: '\u0019\u{1fe99}\u0858\u2631\u{1f802}\u80e0\u4630\u4052\u0439\u5e95\u9aa3'});
let texture76 = gpuCanvasContext1.getCurrentTexture();
let computePassEncoder60 = commandEncoder67.beginComputePass({});
let sampler47 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 72.04,
  lodMaxClamp: 86.11,
});
try {
renderPassEncoder4.executeBundles([renderBundle2, renderBundle5, renderBundle0]);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
try {
adapter0.label = '\ua63b\uc41b\u{1f6df}\u101d\u3961\u{1f8ea}\ue19b\u3972';
} catch {}
let texture77 = device0.createTexture({
  size: {width: 82, height: 1, depthOrArrayLayers: 18},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthReadOnly: true, stencilReadOnly: true});
let sampler48 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 16.72,
  maxAnisotropy: 14,
});
try {
computePassEncoder3.setBindGroup(1, bindGroup24, new Uint32Array(336), 41, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer17, 696); };
} catch {}
try {
computePassEncoder60.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle5, renderBundle1, renderBundle0]);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer36, 'uint16', 2_582, 2_703);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(7, buffer44, 588, 334);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 2020, new Int16Array(20468), 908, 740);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas0);
let commandEncoder68 = device0.createCommandEncoder({});
let externalTexture11 = device0.importExternalTexture({source: videoFrame13, colorSpace: 'srgb'});
try {
renderPassEncoder11.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer40, 0);
} catch {}
try {
buffer7.unmap();
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1360 */
  offset: 1360,
  buffer: buffer43,
}, {
  texture: texture53,
  mipLevel: 0,
  origin: {x: 11, y: 4, z: 0},
  aspect: 'all',
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder69 = device0.createCommandEncoder({label: '\u4182\udde6\u{1f6a7}\u4e56\u4b26'});
let renderPassEncoder17 = commandEncoder69.beginRenderPass({
  label: '\ud941\u2be8\u{1fe8d}\u74c1\u0954\u0052\u{1f755}',
  colorAttachments: [{
  view: textureView19,
  clearValue: { r: 785.4, g: -848.3, b: 876.5, a: -457.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet4,
});
let renderBundle10 = renderBundleEncoder10.finish({label: '\u00da\u0850\u67ff\uc0a5\u{1ff0f}\u020a\u0e62\u{1f826}\u057a\u066a\u947c'});
try {
computePassEncoder59.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup27);
} catch {}
try {
renderPassEncoder17.end();
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle8, renderBundle8, renderBundle4, renderBundle2]);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer34, 'uint32', 340, 57);
} catch {}
try {
buffer44.unmap();
} catch {}
let buffer45 = device0.createBuffer({size: 10410, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});
let querySet8 = device0.createQuerySet({type: 'occlusion', count: 535});
let computePassEncoder61 = commandEncoder68.beginComputePass({});
let renderPassEncoder18 = commandEncoder69.beginRenderPass({
  label: '\ue16f\u01ed',
  colorAttachments: [{view: textureView65, loadOp: 'clear', storeOp: 'discard'}],
  maxDrawCount: 543280926,
});
let sampler49 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 45.10,
  lodMaxClamp: 67.72,
});
try {
renderPassEncoder11.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(4, buffer7);
} catch {}
try {
computePassEncoder20.pushDebugGroup('\u0883');
} catch {}
let textureView67 = texture6.createView({});
try {
computePassEncoder55.setBindGroup(3, bindGroup29);
} catch {}
try {
computePassEncoder41.setBindGroup(0, bindGroup24, new Uint32Array(2961), 94, 0);
} catch {}
try {
computePassEncoder61.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: 416.1, g: -524.7, b: -20.08, a: 481.3, });
} catch {}
let buffer46 = device0.createBuffer({
  size: 7232,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture78 = device0.createTexture({size: [32, 5, 23], format: 'r8sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC});
let sampler50 = device0.createSampler({addressModeV: 'repeat', minFilter: 'nearest', lodMinClamp: 44.23, lodMaxClamp: 75.33, maxAnisotropy: 1});
try {
computePassEncoder47.setBindGroup(1, bindGroup5, new Uint32Array(431), 94, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer16, 952); };
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(18);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer13, 'uint16', 36, 71);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(1, buffer20);
} catch {}
let bindGroup32 = device0.createBindGroup({
  label: '\u0a14\ub98a\u0c86\u0207\u0dc8\u3f8f\uc7f0\u{1f8ba}\u0bc6\u3b3c\ufe4d',
  layout: bindGroupLayout8,
  entries: [
    {binding: 128, resource: {buffer: buffer3, offset: 256, size: 1612}},
    {binding: 191, resource: sampler16},
    {binding: 50, resource: sampler13},
  ],
});
let sampler51 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'nearest',
  lodMinClamp: 32.09,
  lodMaxClamp: 50.88,
});
try {
computePassEncoder9.end();
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup2, new Uint32Array(2401), 687, 0);
} catch {}
try {
renderPassEncoder11.beginOcclusionQuery(151);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline1);
} catch {}
try {
commandEncoder9.copyBufferToBuffer(buffer5, 28, buffer34, 432, 280);
} catch {}
try {
commandEncoder9.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 2,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2960 */
  offset: 2960,
  rowsPerImage: 810,
  buffer: buffer20,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas1);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
try {
bindGroup27.label = '\u416b\u{1fe49}\uab14';
} catch {}
let texture79 = gpuCanvasContext0.getCurrentTexture();
try {
renderPassEncoder13.setViewport(61.5820139719227, 0.9634071632102204, 258.66674699133574, 0.018363789965162882, 0.37766820799815626, 0.7571231255847322);
} catch {}
try {
renderPassEncoder11.setIndexBuffer(buffer42, 'uint16', 246, 312);
} catch {}
let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpte432', transfer: 'logSqrt'} });
let buffer47 = device0.createBuffer({size: 5776, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder70 = device0.createCommandEncoder();
let textureView68 = texture42.createView({dimension: 'cube'});
let texture80 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 95},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroups(2, 2); };
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
commandEncoder70.copyBufferToBuffer(buffer3, 1276, buffer7, 696, 280);
} catch {}
let commandEncoder71 = device0.createCommandEncoder({label: '\ud9bb\u0c5f\u0001\uc077\ua22e\u04f4\u52cd'});
let commandBuffer0 = commandEncoder9.finish({});
let textureView69 = texture58.createView({dimension: '2d-array', format: 'rgba32sint'});
let computePassEncoder62 = commandEncoder71.beginComputePass({});
try {
computePassEncoder37.end();
} catch {}
try {
computePassEncoder62.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder11.setBindGroup(0, bindGroup18);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline1);
} catch {}
let promise11 = shaderModule4.getCompilationInfo();
try {
commandEncoder70.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
},
{
  texture: texture3,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext4 = canvas4.getContext('webgpu');
try {
adapter1.label = '\u30ce\u0d49\u754c\u0388\u10f4';
} catch {}
let commandEncoder72 = device0.createCommandEncoder({label: '\u28fa\u4231\u{1f901}\u611e\u8c3d\uc938\u6181'});
let computePassEncoder63 = commandEncoder70.beginComputePass({});
let renderPassEncoder19 = commandEncoder43.beginRenderPass({
  label: '\ube51\u{1fe17}\u0b12\u{1f6a0}\u70a8\ua89d\u750a\u{1fe2f}\u0b84',
  colorAttachments: [{view: textureView16, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet4,
  maxDrawCount: 217102466,
});
try {
renderPassEncoder18.setPipeline(pipeline1);
} catch {}
try {
  await shaderModule0.getCompilationInfo();
} catch {}
document.body.prepend(canvas3);
let computePassEncoder64 = commandEncoder72.beginComputePass();
try {
computePassEncoder57.setBindGroup(0, bindGroup1, new Uint32Array(1585), 6, 0);
} catch {}
try {
computePassEncoder63.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.beginOcclusionQuery(18);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder18.setVertexBuffer(7, buffer24, 268, 126);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(34).fill(152), /* required buffer size: 34 */
{offset: 34}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView70 = texture6.createView({label: '\u907b\u02fd\u9ad5\u{1fc76}\u0555\u0a1d\u388f', dimension: '2d-array'});
try {
computePassEncoder64.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer5, 'uint16', 56, 91);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, undefined, 1_502_482_734, 885_748);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(40).fill(168), /* required buffer size: 40 */
{offset: 40}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup33 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView60}]});
let commandEncoder73 = device0.createCommandEncoder({});
let sampler52 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 98.73,
  lodMaxClamp: 98.77,
  maxAnisotropy: 12,
});
try {
computePassEncoder8.setBindGroup(0, bindGroup6, new Uint32Array(2675), 171, 0);
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(9);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle5, renderBundle8]);
} catch {}
try {
commandEncoder73.copyBufferToTexture({
  /* bytesInLastRow: 352 widthInBlocks: 88 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1444 */
  offset: 1444,
  buffer: buffer19,
}, {
  texture: texture49,
  mipLevel: 0,
  origin: {x: 126, y: 0, z: 4},
  aspect: 'all',
}, {width: 88, height: 0, depthOrArrayLayers: 1});
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
let bindGroup34 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 69, resource: externalTexture6}]});
let buffer48 = device0.createBuffer({
  label: '\u{1fa81}\u9d63\u78d7\u{1fedb}\ub4ce\u0fa6\u{1f803}\u{1f6d2}',
  size: 3311,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder74 = device0.createCommandEncoder();
try {
computePassEncoder23.setBindGroup(3, bindGroup32, []);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(1, buffer17, 688, 4_195);
} catch {}
try {
buffer17.unmap();
} catch {}
try {
commandEncoder74.copyBufferToTexture({
  /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 3248 */
  offset: 3248,
  bytesPerRow: 17664,
  rowsPerImage: 28,
  buffer: buffer16,
}, {
  texture: texture30,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
} catch {}
let texture81 = device0.createTexture({
  size: [328, 1, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler53 = device0.createSampler({
  label: '\u1950\u635e\ud723\u0a93\u3538\u4440',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 49.54,
  lodMaxClamp: 93.64,
});
try {
computePassEncoder63.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder36.setBindGroup(1, bindGroup29, new Uint32Array(1536), 103, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder48.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setBindGroup(2, bindGroup22, new Uint32Array(534), 463, 0);
} catch {}
try {
renderPassEncoder5.setViewport(45.46761160692095, 0.31990988384083474, 79.90766683125071, 0.31849062569153525, 0.4765638741463546, 0.9670340606416759);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline1);
} catch {}
try {
commandEncoder73.clearBuffer(buffer32);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.submit([]);
} catch {}
let commandEncoder75 = device0.createCommandEncoder();
let texture82 = device0.createTexture({size: {width: 32}, dimension: '1d', format: 'r8sint', usage: GPUTextureUsage.COPY_DST});
let renderPassEncoder20 = commandEncoder73.beginRenderPass({
  label: '\ube32\u{1f7b5}',
  colorAttachments: [{
  view: textureView65,
  clearValue: { r: -856.2, g: -218.1, b: 306.9, a: -775.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder20.setIndexBuffer(buffer36, 'uint32', 44, 1_076);
} catch {}
try {
commandEncoder75.insertDebugMarker('\u4902');
} catch {}
try {
device0.queue.writeBuffer(buffer21, 2660, new Float32Array(9972), 9048, 16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture55,
  mipLevel: 0,
  origin: {x: 7, y: 1, z: 1},
  aspect: 'all',
}, new Uint8Array(631_531).fill(22), /* required buffer size: 631_531 */
{offset: 20, bytesPerRow: 1511, rowsPerImage: 52}, {width: 89, height: 2, depthOrArrayLayers: 9});
} catch {}
document.body.append(canvas4);
await gc();
let bindGroupLayout10 = device0.createBindGroupLayout({
  label: '\u06cb\ua6e3\uabed\u9b3f\u8299',
  entries: [
    {
      binding: 120,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' },
    },
    {
      binding: 45,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d-array' },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let bindGroup35 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView14}]});
let commandEncoder76 = device0.createCommandEncoder({});
let texture83 = device0.createTexture({
  size: [16, 2, 56],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView71 = texture21.createView({});
let computePassEncoder65 = commandEncoder75.beginComputePass({});
let sampler54 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 13.57,
  maxAnisotropy: 6,
});
try {
renderPassEncoder14.setBindGroup(0, bindGroup34);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(17);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(3, buffer17);
} catch {}
try {
buffer29.unmap();
} catch {}
try {
commandEncoder74.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2000 */
  offset: 2000,
  buffer: buffer33,
}, {
  texture: texture25,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder74.resolveQuerySet(querySet6, 130, 10, buffer24, 768);
} catch {}
await gc();
let commandEncoder77 = device0.createCommandEncoder();
let texture84 = device0.createTexture({
  label: '\u793a\u{1f6f8}\u{1faf8}\u0b0a\u58d9\u0481\u{1fc10}\ud42a',
  size: {width: 64},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder66 = commandEncoder74.beginComputePass({});
try {
computePassEncoder20.setBindGroup(0, bindGroup1);
} catch {}
try {
computePassEncoder52.setBindGroup(0, bindGroup26, new Uint32Array(6830), 2_129, 0);
} catch {}
try {
computePassEncoder66.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup15);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle6, renderBundle6, renderBundle1, renderBundle8]);
} catch {}
try {
renderPassEncoder18.setVertexBuffer(4, buffer11, 0, 3_500);
} catch {}
try {
  await promise12;
} catch {}
let texture85 = device0.createTexture({
  size: {width: 656, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder67 = commandEncoder76.beginComputePass({});
try {
computePassEncoder57.setBindGroup(2, bindGroup19, new Uint32Array(146), 7, 0);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder16.setIndexBuffer(buffer28, 'uint32', 720, 260);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
commandEncoder77.copyBufferToBuffer(buffer19, 800, buffer32, 312, 152);
} catch {}
try {
commandEncoder77.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 0 */
  offset: 0,
  bytesPerRow: 1024,
  buffer: buffer48,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder20.popDebugGroup();
} catch {}
try {
computePassEncoder42.insertDebugMarker('\u{1f707}');
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
let bindGroupLayout11 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 96,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let bindGroup36 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [
    {binding: 227, resource: {buffer: buffer20, offset: 1024, size: 4288}},
    {binding: 68, resource: textureView51},
  ],
});
let buffer49 = device0.createBuffer({
  size: 1623,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView72 = texture83.createView({mipLevelCount: 1, arrayLayerCount: 15});
let textureView73 = texture59.createView({});
try {
computePassEncoder67.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup12, []);
} catch {}
try {
renderPassEncoder11.endOcclusionQuery();
} catch {}
try {
commandEncoder77.copyBufferToTexture({
  /* bytesInLastRow: 256 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2160 */
  offset: 2160,
  bytesPerRow: 12800,
  buffer: buffer12,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 16, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder77.resolveQuerySet(querySet7, 5, 14, buffer16, 768);
} catch {}
canvas4.height = 612;
let buffer50 = device0.createBuffer({
  size: 37107,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let commandEncoder78 = device0.createCommandEncoder({label: '\u{1ffbc}\u1d11'});
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 844});
let textureView74 = texture84.createView({});
let textureView75 = texture77.createView({label: '\u6e2e\u6cf3\u0e8e\ucff2\u7107\u0a34\ud20d\u9431', dimension: '2d', baseArrayLayer: 2});
try {
computePassEncoder52.setBindGroup(2, bindGroup13, new Uint32Array(2914), 587, 0);
} catch {}
try {
computePassEncoder60.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup12, new Uint32Array(1224), 104, 0);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle10]);
} catch {}
try {
commandEncoder78.copyBufferToTexture({
  /* bytesInLastRow: 272 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 128 */
  offset: 128,
  buffer: buffer15,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
}, {width: 17, height: 1, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas1);
let querySet10 = device0.createQuerySet({label: '\u09f3\u8ce8\u381d\u65b8', type: 'occlusion', count: 1171});
let texture86 = device0.createTexture({
  label: '\uc00a\u6c6d',
  size: {width: 164, height: 1, depthOrArrayLayers: 98},
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture87 = device0.createTexture({
  size: [129, 20, 28],
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
try {
computePassEncoder61.setBindGroup(0, bindGroup24);
} catch {}
try {
computePassEncoder25.setBindGroup(3, bindGroup22, new Uint32Array(287), 66, 0);
} catch {}
try {
computePassEncoder65.setPipeline(pipeline0);
} catch {}
document.body.prepend(canvas2);
let buffer51 = device0.createBuffer({size: 25100, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let textureView76 = texture86.createView({dimension: '2d', baseArrayLayer: 13});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], stencilReadOnly: true});
try {
computePassEncoder36.setBindGroup(2, bindGroup3, new Uint32Array(1616), 234, 0);
} catch {}
try {
computePassEncoder33.end();
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView77 = texture84.createView({});
let textureView78 = texture55.createView({dimension: '2d', format: 'rgba32sint', mipLevelCount: 1});
let renderBundle11 = renderBundleEncoder11.finish({label: '\ub519\u{1f675}\ubd27\ud0db\u013a\u6109\u47c7'});
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder14.setVertexBuffer(2, buffer25, 4, 11);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandEncoder79 = device0.createCommandEncoder({label: '\ud8d4\u2f18\uce1f\ud0f1\u9668\u49ac\uba9e'});
let texture88 = device0.createTexture({
  label: '\u0bf5\u{1fb77}\u{1f777}',
  size: {width: 328, height: 1, depthOrArrayLayers: 28},
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let renderPassEncoder21 = commandEncoder79.beginRenderPass({
  colorAttachments: [{
  view: textureView41,
  clearValue: { r: 124.5, g: 819.5, b: 90.21, a: 46.38, },
  loadOp: 'load',
  storeOp: 'store',
}],
  maxDrawCount: 23415014,
});
try {
{ clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer49, 'uint16', 474, 462);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(6, buffer5, 0, 151);
} catch {}
try {
commandEncoder78.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2048 */
  offset: 2048,
  bytesPerRow: 15872,
  buffer: buffer7,
}, {
  texture: texture38,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 656, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 69, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer52 = device0.createBuffer({label: '\u0a6e\u0dd1', size: 3609, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder80 = device0.createCommandEncoder();
let texture89 = device0.createTexture({
  size: {width: 656, height: 1, depthOrArrayLayers: 3},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView79 = texture78.createView({dimension: '2d', baseArrayLayer: 5});
let computePassEncoder68 = commandEncoder80.beginComputePass({});
try {
computePassEncoder39.setBindGroup(3, bindGroup3);
} catch {}
try {
computePassEncoder34.end();
} catch {}
try {
computePassEncoder68.setPipeline(pipeline0);
} catch {}
await gc();
let commandEncoder81 = device0.createCommandEncoder({});
let computePassEncoder69 = commandEncoder37.beginComputePass();
let sampler55 = device0.createSampler({
  label: '\u{1fefb}\u0b1f\uee5a\u{1ffc3}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 56.78,
  lodMaxClamp: 62.13,
  maxAnisotropy: 17,
});
try {
renderPassEncoder8.setBindGroup(3, bindGroup19);
} catch {}
try {
renderPassEncoder12.insertDebugMarker('\u{1fe97}');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
let imageData7 = new ImageData(56, 12);
let bindGroup37 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 226, resource: textureView73}]});
let texture90 = device0.createTexture({size: [82, 1, 34], dimension: '3d', format: 'r8sint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let textureView80 = texture1.createView({mipLevelCount: 1});
let computePassEncoder70 = commandEncoder78.beginComputePass();
let renderPassEncoder22 = commandEncoder36.beginRenderPass({
  colorAttachments: [{
  view: textureView36,
  depthSlice: 20,
  clearValue: { r: -637.0, g: -672.2, b: 781.5, a: -413.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 194192262,
});
try {
computePassEncoder69.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer5, 68, 61);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture82,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(7).fill(7), /* required buffer size: 7 */
{offset: 7, bytesPerRow: 22, rowsPerImage: 8}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup38 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 226, resource: textureView43}]});
let commandEncoder82 = device0.createCommandEncoder({});
let texture91 = device0.createTexture({
  size: {width: 164, height: 1, depthOrArrayLayers: 1},
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let computePassEncoder71 = commandEncoder77.beginComputePass({label: '\u2fca\ua287\u0cf1\u8a44\ue38d\u{1fbeb}'});
try {
computePassEncoder69.setBindGroup(0, bindGroup23);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder63); computePassEncoder63.dispatchWorkgroupsIndirect(buffer20, 560); };
} catch {}
try {
computePassEncoder70.setPipeline(pipeline0);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder82.clearBuffer(buffer14);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
try {
  await promise10;
} catch {}
let bindGroup39 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [
    {binding: 128, resource: {buffer: buffer42, offset: 0, size: 57}},
    {binding: 50, resource: sampler8},
    {binding: 191, resource: sampler20},
  ],
});
let textureView81 = texture5.createView({aspect: 'all', baseArrayLayer: 16, arrayLayerCount: 16});
let texture92 = device0.createTexture({
  size: [82],
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let renderPassEncoder23 = commandEncoder81.beginRenderPass({
  colorAttachments: [{
  view: textureView78,
  clearValue: { r: -337.7, g: 510.5, b: -113.0, a: -61.45, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet2,
  maxDrawCount: 323818156,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup37, new Uint32Array(1172), 21, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle5, renderBundle8, renderBundle4, renderBundle0]);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer28, 'uint16', 142, 318);
} catch {}
try {
commandEncoder82.resolveQuerySet(querySet6, 38, 9, buffer43, 2304);
} catch {}
try {
device0.queue.writeBuffer(buffer42, 432, new Float32Array(4847), 226, 412);
} catch {}
try {
  await promise11;
} catch {}
let bindGroup40 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 226, resource: textureView73}]});
let commandEncoder83 = device0.createCommandEncoder({label: '\u0455\u1b94\u054f\u0f9d\u06b8\u{1fa13}'});
let texture93 = device0.createTexture({size: [32, 5, 1], format: 'r8snorm', usage: GPUTextureUsage.COPY_DST, viewFormats: []});
let computePassEncoder72 = commandEncoder83.beginComputePass({label: '\u{1fbfc}\u{1fac0}\u{1f730}\ue6dd\u{1ff96}\u1675\u41b6\ud693'});
try {
computePassEncoder45.setBindGroup(1, bindGroup39, new Uint32Array(3821), 436, 0);
} catch {}
try {
computePassEncoder63.end();
} catch {}
try {
commandEncoder82.clearBuffer(buffer14);
} catch {}
try {
globalThis.someLabel = commandEncoder31.label;
} catch {}
let commandEncoder84 = device0.createCommandEncoder({});
let computePassEncoder73 = commandEncoder84.beginComputePass({});
try {
computePassEncoder64.setBindGroup(1, bindGroup5);
} catch {}
try {
computePassEncoder40.setBindGroup(0, bindGroup1, new Uint32Array(185), 82, 0);
} catch {}
try {
renderPassEncoder13.setBindGroup(0, bindGroup33);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(2, buffer44, 0);
} catch {}
let imageData8 = new ImageData(64, 88);
let buffer53 = device0.createBuffer({size: 11487, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let texture94 = device0.createTexture({
  size: [656, 1, 1],
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView82 = texture5.createView({baseArrayLayer: 1, arrayLayerCount: 2});
let computePassEncoder74 = commandEncoder70.beginComputePass({label: '\uc535\u{1fa7b}\ua517\u09a3'});
try {
commandEncoder82.insertDebugMarker('\u0797');
} catch {}
await gc();
let bindGroup41 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 42, resource: {buffer: buffer18, offset: 256, size: 10124}},
    {binding: 14, resource: textureView68},
  ],
});
let commandEncoder85 = device0.createCommandEncoder({label: '\u{1f823}\u0b82\u{1f8d8}'});
let querySet11 = device0.createQuerySet({type: 'occlusion', count: 359});
let texture95 = device0.createTexture({
  label: '\u0ab5\u197e\u0a11\u7e9f\u037a\u{1f871}\u07c2\ub298\u{1ff2e}\u017e\u5e77',
  size: [82],
  dimension: '1d',
  format: 'r8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroupsIndirect(buffer20, 52); };
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
commandEncoder85.copyTextureToBuffer({
  texture: texture20,
  mipLevel: 0,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1856 widthInBlocks: 116 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2032 */
  offset: 2032,
  bytesPerRow: 28672,
  buffer: buffer40,
}, {width: 116, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas5 = document.createElement('canvas');
let textureView83 = texture45.createView({
  label: '\u5694\u{1f702}\ufeb8\ucc88\ub733\u54a1\u0a40',
  format: 'rgba32sint',
  baseArrayLayer: 1,
  arrayLayerCount: 1,
});
let sampler56 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 90.88,
});
try {
computePassEncoder22.setBindGroup(2, bindGroup21);
} catch {}
try {
computePassEncoder23.setBindGroup(0, bindGroup41, new Uint32Array(2685), 1_129, 0);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup24);
} catch {}
try {
renderPassEncoder7.setBlendConstant({ r: -923.0, g: 459.6, b: 238.0, a: -346.6, });
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline1);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeBuffer(buffer5, 604, new Float32Array(4213), 62, 0);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext5 = canvas5.getContext('webgpu');
try {
  await promise13;
} catch {}
let bindGroup42 = device0.createBindGroup({
  layout: bindGroupLayout7,
  entries: [
    {binding: 42, resource: {buffer: buffer9, offset: 1536, size: 2548}},
    {binding: 14, resource: textureView68},
  ],
});
let buffer54 = device0.createBuffer({
  size: 1776,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({
  label: '\u16fe\u02ab\u02f5\u{1f623}\u424c\u{1f9fc}\u2638\u{1ffac}\u0d06\u{1fe48}\u0f0d',
  colorFormats: ['rgba32sint'],
  depthReadOnly: true,
});
try {
renderPassEncoder2.setBindGroup(3, bindGroup24, new Uint32Array(515), 140, 0);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer49, 'uint16', 820, 31);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
document.body.prepend(canvas5);
canvas1.height = 133;
let bindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 167,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 323,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }},
  ],
});
let buffer55 = device0.createBuffer({size: 3556, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let texture96 = device0.createTexture({
  label: '\u01f8\u0050\u0722\u0d96\u54ae\u0149\ub472\u0415\u277a',
  size: [164, 1, 148],
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture97 = device0.createTexture({
  label: '\u{1fb91}\u3ff8\u2af7\u76c7\uafb1',
  size: [328, 1, 1],
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder75 = commandEncoder85.beginComputePass({});
try {
computePassEncoder43.setBindGroup(1, bindGroup35);
} catch {}
try {
computePassEncoder73.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup2, new Uint32Array(2307), 51, 0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer12);
} catch {}
try {
commandEncoder82.copyBufferToBuffer(buffer53, 1744, buffer16, 4564, 4580);
} catch {}
let bindGroup43 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 69, resource: externalTexture9}]});
let textureView84 = texture63.createView({dimension: 'cube', baseArrayLayer: 2});
try {
computePassEncoder69.setBindGroup(2, bindGroup5);
} catch {}
try {
computePassEncoder74.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer13, 'uint32', 16, 7);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer28, 'uint16', 82, 136);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(4, buffer38, 0, 659);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 656, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData7,
  origin: { x: 8, y: 0 },
  flipY: false,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 110, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer56 = device0.createBuffer({size: 46133, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM});
let querySet12 = device0.createQuerySet({type: 'occlusion', count: 55});
let texture98 = gpuCanvasContext2.getCurrentTexture();
let textureView85 = texture61.createView({mipLevelCount: 1});
let computePassEncoder76 = commandEncoder82.beginComputePass({});
try {
computePassEncoder76.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'opaque',
});
} catch {}
let canvas6 = document.createElement('canvas');
let bindGroup44 = device0.createBindGroup({
  label: '\u2e12\u090f\u1c5e\u049a\ub0a1',
  layout: bindGroupLayout12,
  entries: [
    {binding: 167, resource: textureView84},
    {binding: 323, resource: textureView23},
    {binding: 1, resource: {buffer: buffer33, offset: 256, size: 371}},
  ],
});
let texture99 = device0.createTexture({
  size: [16, 16, 12],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'depth32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let sampler57 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 28.35,
});
try {
computePassEncoder15.setBindGroup(2, bindGroup36);
} catch {}
try {
computePassEncoder18.setBindGroup(0, bindGroup15, new Uint32Array(427), 5, 0);
} catch {}
try {
computePassEncoder75.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle5]);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer34, 'uint16', 248, 52);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer41, 2172, new BigUint64Array(8139), 424, 68);
} catch {}
let gpuCanvasContext6 = canvas6.getContext('webgpu');
document.body.append(canvas3);
let bindGroup45 = device0.createBindGroup({
  label: '\ub751\u6e28\u2dcb\u565d\u8090\u4f1c\u0fb6\u0d2d\ub46f',
  layout: bindGroupLayout5,
  entries: [
    {binding: 9, resource: textureView60},
    {binding: 73, resource: sampler37},
    {binding: 179, resource: externalTexture6},
    {binding: 5, resource: textureView12},
    {binding: 89, resource: sampler38},
    {binding: 216, resource: {buffer: buffer40, offset: 512, size: 720}},
    {binding: 25, resource: textureView40},
    {binding: 14, resource: {buffer: buffer5, offset: 0, size: 141}},
    {binding: 58, resource: {buffer: buffer54, offset: 0}},
    {binding: 277, resource: textureView51},
    {binding: 112, resource: sampler17},
    {binding: 42, resource: textureView12},
    {binding: 81, resource: textureView75},
    {binding: 10, resource: textureView57},
    {binding: 104, resource: textureView38},
    {binding: 462, resource: sampler20},
  ],
});
let buffer57 = device0.createBuffer({
  size: 19347,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let texture100 = device0.createTexture({
  size: [16, 16, 12],
  mipLevelCount: 2,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder1.setBindGroup(3, bindGroup26, new Uint32Array(577), 75, 0);
} catch {}
try {
computePassEncoder56.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle8, renderBundle3, renderBundle10]);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer40, 'uint16', 394, 81);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer9, 'uint32', 476, 1_297);
} catch {}
let buffer58 = device0.createBuffer({
  label: '\u8dc0\uf9a3\u03aa\u083a',
  size: 6472,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let renderBundle12 = renderBundleEncoder12.finish({label: '\u9095\u09e2\u{1f9c2}\u30d5'});
try {
renderPassEncoder7.setBindGroup(0, bindGroup18, []);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture86,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 23},
  aspect: 'all',
}, new Uint8Array(195_357).fill(66), /* required buffer size: 195_357 */
{offset: 669, bytesPerRow: 208, rowsPerImage: 78}, {width: 51, height: 0, depthOrArrayLayers: 13});
} catch {}
let texture101 = device0.createTexture({
  size: {width: 129},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder27.setBindGroup(0, bindGroup12, new Uint32Array(554), 78, 0);
} catch {}
try {
computePassEncoder71.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer9, 'uint32', 12, 1_586);
} catch {}
document.body.append(canvas2);
let commandEncoder86 = device0.createCommandEncoder({});
let querySet13 = device0.createQuerySet({label: '\u{1ffa5}\u{1f8c9}\ubc23\u297d\u1a08\u{1fca0}\u007b\ud0c4', type: 'occlusion', count: 917});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({
  label: '\ua014\u02a1\u96de\u0a8a\u5984\ub06e\u0fd0\ubca0',
  colorFormats: ['rgba32sint'],
  stencilReadOnly: true,
});
let sampler58 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 59.38,
  lodMaxClamp: 83.25,
});
try {
computePassEncoder72.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup29, []);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(4, buffer28, 0, 1_058);
} catch {}
try {
commandEncoder86.copyTextureToTexture({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 103, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture52,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 4},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
adapter0.label = '\uef9a\u05f2\u5955\u{1fbb2}\u07d4\u7e41';
} catch {}
let renderBundle13 = renderBundleEncoder13.finish({label: '\ue566\u{1f741}\u79c6\u78e2\u0e2b\u6a64\ub60b'});
try {
computePassEncoder73.setBindGroup(3, bindGroup20, new Uint32Array(201), 5, 0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle13]);
} catch {}
let bindGroup46 = device0.createBindGroup({label: '\u051b\uff5c', layout: bindGroupLayout6, entries: [{binding: 226, resource: textureView57}]});
let textureView86 = texture86.createView({dimension: '2d', baseArrayLayer: 83});
let computePassEncoder77 = commandEncoder86.beginComputePass({label: '\u0327\u7081\u8d2c\u2df4\u0027\u01bf\uf424\u0874\u045f'});
try {
computePassEncoder77.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup6, new Uint32Array(2645), 157, 0);
} catch {}
try {
renderPassEncoder23.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer20, 528, 264);
} catch {}
try {
buffer17.unmap();
} catch {}
try {
device0.queue.writeBuffer(buffer52, 352, new Int16Array(7303), 56, 540);
} catch {}
let buffer59 = device0.createBuffer({size: 4824, usage: GPUBufferUsage.INDEX});
let textureView87 = texture72.createView({dimension: 'cube', format: 'depth32float', mipLevelCount: 1});
let sampler59 = device0.createSampler({
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 54.72,
  lodMaxClamp: 88.53,
});
try {
renderPassEncoder0.setIndexBuffer(buffer9, 'uint32', 1_428, 1_196);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
} catch {}
let textureView88 = texture4.createView({mipLevelCount: 1, baseArrayLayer: 0});
try {
renderPassEncoder20.setScissorRect(0, 0, 0, 0);
} catch {}
let canvas7 = document.createElement('canvas');
let textureView89 = texture38.createView({format: 'rgba32sint', mipLevelCount: 1, arrayLayerCount: 1});
let sampler60 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 69.00,
  lodMaxClamp: 72.85,
  maxAnisotropy: 2,
});
try {
computePassEncoder35.setBindGroup(0, bindGroup11, new Uint32Array(6324), 347, 0);
} catch {}
try {
renderPassEncoder10.executeBundles([renderBundle5]);
} catch {}
let commandEncoder87 = device0.createCommandEncoder({});
let texture102 = device0.createTexture({
  size: [16, 2, 1],
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder15.end();
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer49, 'uint32', 1_408, 84);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(4, buffer4, 96);
} catch {}
try {
commandEncoder87.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 4064 */
  offset: 4064,
  rowsPerImage: 57,
  buffer: buffer44,
}, {
  texture: texture30,
  mipLevel: 1,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder55.end();
} catch {}
try {
commandEncoder61.copyTextureToTexture({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture38,
  mipLevel: 1,
  origin: {x: 0, y: 8, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder87.insertDebugMarker('\u0693');
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
try {
commandEncoder84.label = '\u5b58\ub865\ue18c\uf3ce\u5337\u2053\u0c84\u70e7\u9d99\u0ac7\u0490';
} catch {}
let computePassEncoder78 = commandEncoder61.beginComputePass();
let renderPassEncoder24 = commandEncoder87.beginRenderPass({
  colorAttachments: [{
  view: textureView62,
  clearValue: { r: -140.0, g: -620.4, b: -545.1, a: -820.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 263769288,
});
let sampler61 = device0.createSampler({
  label: '\u0be1\u{1fcce}\u024a\u0445\u62e3\u09ad\u{1fed3}\u0ebe\u{1f67e}\u0a0a',
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 84.34,
  lodMaxClamp: 97.81,
  compare: 'less',
  maxAnisotropy: 16,
});
try {
renderPassEncoder24.executeBundles([renderBundle8, renderBundle0]);
} catch {}
try {
renderPassEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(1, buffer16, 0, 1_865);
} catch {}
document.body.append(canvas4);
let buffer60 = device0.createBuffer({size: 8459, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let querySet14 = device0.createQuerySet({type: 'occlusion', count: 319});
let computePassEncoder79 = commandEncoder15.beginComputePass({});
try {
computePassEncoder46.setBindGroup(1, bindGroup13);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder78.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder15.setBindGroup(0, bindGroup16, new Uint32Array(66), 35, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 656, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 143, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer61 = device0.createBuffer({
  size: 1831,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder88 = device0.createCommandEncoder({label: '\u0173\u7848\u0bae\u{1fcda}\ud7f6\u005c\u252b\u5454\uf0b7\u02c3\u0dd8'});
let querySet15 = device0.createQuerySet({type: 'occlusion', count: 1855});
let computePassEncoder80 = commandEncoder88.beginComputePass({});
try {
computePassEncoder11.setBindGroup(1, bindGroup46, new Uint32Array(109), 8, 0);
} catch {}
try {
computePassEncoder80.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer9, 'uint32', 2_664, 697);
} catch {}
let commandEncoder89 = device0.createCommandEncoder();
let computePassEncoder81 = commandEncoder89.beginComputePass({});
try {
renderPassEncoder20.executeBundles([renderBundle2]);
} catch {}
try {
device0.queue.writeBuffer(buffer50, 4508, new BigUint64Array(5468), 246, 364);
} catch {}
let commandEncoder90 = device0.createCommandEncoder({});
let texture103 = device0.createTexture({
  label: '\u{1f986}\u86e1\u{1f79b}\u85a3\u{1fd67}\u{1fe78}\u0b7d\u{1fe92}\u72fd\u01d7',
  size: [64, 10, 110],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder82 = commandEncoder90.beginComputePass({label: '\u0431\u9e1d\u07ca\u{1f9a3}\u055c\uf220\u1d95\u0e54\u3ce9'});
let sampler62 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 40.50,
  lodMaxClamp: 48.71,
});
let externalTexture12 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'});
try {
renderPassEncoder14.setIndexBuffer(buffer40, 'uint32', 608, 1_199);
} catch {}
try {
device0.queue.writeBuffer(buffer40, 1232, new Int16Array(537), 113, 24);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture58,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(94).fill(100), /* required buffer size: 94 */
{offset: 94}, {width: 13, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
canvas7.getContext('2d');
} catch {}
let buffer62 = device0.createBuffer({
  label: '\u{1fbb3}\u{1f8dd}\u07d4\u42a1\u0299\u940b\u580e\u93df\u7841\u{1fd33}\u{1f905}',
  size: 12108,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let sampler63 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.76,
});
try {
computePassEncoder48.setBindGroup(2, bindGroup36, new Uint32Array(1951), 207, 0);
} catch {}
try {
computePassEncoder79.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder22.setBindGroup(3, bindGroup34);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer5, 'uint32', 56, 29);
} catch {}
try {
buffer38.unmap();
} catch {}
let bindGroup47 = device0.createBindGroup({layout: bindGroupLayout4, entries: [{binding: 13, resource: textureView66}]});
let commandEncoder91 = device0.createCommandEncoder({});
let textureView90 = texture63.createView({dimension: 'cube', mipLevelCount: 1});
try {
computePassEncoder36.end();
} catch {}
try {
renderPassEncoder15.setScissorRect(10, 0, 39, 0);
} catch {}
try {
computePassEncoder13.pushDebugGroup('\u03e4');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 656, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData5,
  origin: { x: 3, y: 19 },
  flipY: false,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule5 = device0.createShaderModule({
  code: `
enable f16;

enable f16;

requires unrestricted_pointer_parameters;

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

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

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

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

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

struct T0 {
  @align(16) @size(64) f0: atomic<i32>,
  @align(16) @size(1408) f1: array<u32>,
}

struct FragmentOutput4 {
  @builtin(frag_depth) f0: f32,
  @location(0) @interpolate(flat) f1: vec2i,
  @location(2) f2: vec4i,
}

@fragment
fn fragment5() -> FragmentOutput4 {
  var out: FragmentOutput4;
  let vf96: f16 = exp(f16(unconst_f16(11841.7)));
  var vf97: vec2h = faceForward(vec2h(unconst_f16(11294.3), unconst_f16(-673.3)), vec2h(tan(f16(unconst_f16(1843.4)))), vec2h(unconst_f16(6644.7), unconst_f16(17648.2)));
  out.f2 |= vec4i(i32(tan(f16(unconst_f16(6330.2)))));
  out.f0 = bitcast<f32>(vf97);
  var vf98: u32 = dot4U8Packed(u32(unconst_u32(45)), u32(unconst_u32(279)));
  out.f1 = vec2i(i32(distance(f32(unconst_f32(0.4983)), f32(unconst_f32(0.1441)))));
  let ptr63: ptr<function, vec2h> = &vf97;
  var vf99: vec2f = unpack2x16unorm(pack4x8unorm(vec4f(unconst_f32(0.1318), unconst_f32(0.04986), unconst_f32(0.01322), unconst_f32(0.1217))));
  let vf100: u32 = pack4x8unorm(vec4f(unconst_f32(0.4613), unconst_f32(0.03171), unconst_f32(0.06950), unconst_f32(0.02535)));
  let vf101: f32 = distance(vec4f(unconst_f32(0.1167), unconst_f32(0.06541), unconst_f32(0.01976), unconst_f32(0.00124)), vec4f(unconst_f32(0.1299), unconst_f32(0.2112), unconst_f32(0.09012), unconst_f32(0.4742)));
  var vf102: f32 = distance(f32(unconst_f32(0.1021)), f32(unconst_f32(0.1971)));
  var vf103: u32 = vf100;
  discard;
  out.f0 = f32(exp(f16(unconst_f16(21723.7))));
  out.f2 = vec4i(sqrt(vec4h(unconst_f16(4259.7), unconst_f16(10007.1), unconst_f16(1625.6), unconst_f16(4720.0))));
  vf99 *= unpack2x16float(vf98);
  var vf104: u32 = dot4U8Packed(u32(unconst_u32(230)), u32(unconst_u32(196)));
  vf103 += pack2x16float(vf99);
  vf102 += f32(vf96);
  let vf105: vec4h = asin(vec4h(unconst_f16(15719.0), unconst_f16(1006.6), unconst_f16(16431.6), unconst_f16(15972.6)));
  vf102 -= bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.5667), unconst_f32(0.01292), unconst_f32(0.1601), unconst_f32(0.07666))));
  let ptr64: ptr<function, f32> = &vf102;
  return out;
}`,
  sourceMap: {},
  hints: {},
});
let commandEncoder92 = device0.createCommandEncoder();
let textureView91 = texture2.createView({dimension: '3d'});
let computePassEncoder83 = commandEncoder91.beginComputePass({});
try {
renderPassEncoder2.setBindGroup(0, bindGroup37, new Uint32Array(998), 112, 0);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer45, 480, new BigUint64Array(390), 280, 68);
} catch {}
let pipeline2 = device0.createRenderPipeline({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule5,
  targets: [{format: 'r8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth32float',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilReadMask: 467427893,
    stencilWriteMask: 852552940,
    depthBias: -833142402,
    depthBiasClamp: -11.34064122206567,
  },
  vertex: {module: shaderModule1, entryPoint: 'vertex1', buffers: []},
  primitive: {cullMode: 'back'},
});
let buffer63 = device0.createBuffer({
  size: 8371,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder93 = device0.createCommandEncoder({});
let querySet16 = device0.createQuerySet({type: 'occlusion', count: 1138});
let textureView92 = texture1.createView({dimension: '3d', baseMipLevel: 0, mipLevelCount: 1});
try {
computePassEncoder83.setPipeline(pipeline0);
} catch {}
let bindGroup48 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [
    {binding: 191, resource: sampler62},
    {binding: 50, resource: sampler28},
    {binding: 128, resource: {buffer: buffer42, offset: 512, size: 928}},
  ],
});
try {
computePassEncoder35.setBindGroup(3, bindGroup14);
} catch {}
try {
computePassEncoder52.setBindGroup(3, bindGroup14, new Uint32Array(90), 18, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup39);
} catch {}
try {
commandEncoder92.copyTextureToTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture17,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
let texture104 = device0.createTexture({
  size: [32, 5, 5],
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder73.setBindGroup(2, bindGroup21);
} catch {}
try {
computePassEncoder18.setBindGroup(1, bindGroup40, new Uint32Array(237), 22, 0);
} catch {}
try {
renderPassEncoder16.setBindGroup(1, bindGroup41, []);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer59, 'uint32', 92, 275);
} catch {}
try {
commandEncoder92.copyBufferToBuffer(buffer45, 704, buffer21, 728, 80);
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 324 widthInBlocks: 81 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 424 */
  offset: 424,
  bytesPerRow: 1792,
  buffer: buffer51,
}, {
  texture: texture52,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 8},
  aspect: 'all',
}, {width: 81, height: 0, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder84 = commandEncoder93.beginComputePass({});
try {
computePassEncoder4.setBindGroup(3, bindGroup28);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer9, 556); };
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer34, 'uint32', 492, 111);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer14, 0);
} catch {}
try {
commandEncoder92.clearBuffer(buffer11, 3120, 1848);
} catch {}
try {
device0.queue.writeBuffer(buffer63, 1776, new Float32Array(25318), 864, 368);
} catch {}
await gc();
try {
computePassEncoder75.setBindGroup(2, bindGroup3, new Uint32Array(2356), 3, 0);
} catch {}
try {
computePassEncoder84.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle11]);
} catch {}
try {
renderPassEncoder8.setScissorRect(21, 0, 50, 0);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(buffer49, 'uint16', 112, 116);
} catch {}
try {
commandEncoder92.copyTextureToBuffer({
  texture: texture17,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 108 */
  offset: 108,
  bytesPerRow: 17152,
  buffer: buffer46,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder41.copyTextureToTexture({
  texture: texture27,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture7,
  mipLevel: 0,
  origin: {x: 60, y: 6, z: 0},
  aspect: 'all',
},
{width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(canvas6);
let img0 = await imageWithData(100, 36, '#10101010', '#20202020');
let buffer64 = device0.createBuffer({size: 2968, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT});
let textureView93 = texture51.createView({});
let computePassEncoder85 = commandEncoder92.beginComputePass();
let sampler64 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 79.56,
  lodMaxClamp: 99.80,
  maxAnisotropy: 4,
});
try {
computePassEncoder38.setBindGroup(3, bindGroup32, new Uint32Array(1155), 125, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup5);
} catch {}
try {
renderPassEncoder16.executeBundles([renderBundle1, renderBundle1, renderBundle4, renderBundle10, renderBundle3, renderBundle13]);
} catch {}
try {
renderPassEncoder13.setIndexBuffer(buffer18, 'uint32', 3_076, 8_374);
} catch {}
try {
renderPassEncoder14.setPipeline(pipeline1);
} catch {}
try {
commandEncoder41.copyTextureToBuffer({
  texture: texture62,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 192 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 880 */
  offset: 880,
  buffer: buffer7,
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder94 = device0.createCommandEncoder();
let sampler65 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 1.903,
  lodMaxClamp: 37.38,
  maxAnisotropy: 18,
});
try {
computePassEncoder66.setBindGroup(3, bindGroup42, new Uint32Array(255), 56, 0);
} catch {}
try {
computePassEncoder82.setPipeline(pipeline0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 656, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame8,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 198, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let querySet17 = device0.createQuerySet({label: '\u0415\u18c7\u1894\u0676\u557a\ud04a\u968f\ua619\uc4b6', type: 'occlusion', count: 46});
let texture105 = device0.createTexture({
  label: '\u7cd6\u{1f858}\u{1f737}\u2fab\ubd4e',
  size: {width: 129, height: 20, depthOrArrayLayers: 153},
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView94 = texture20.createView({dimension: '2d-array'});
let computePassEncoder86 = commandEncoder94.beginComputePass({label: '\u{1ff52}\uddf9\u161a'});
let sampler66 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'linear',
  lodMaxClamp: 78.32,
});
try {
computePassEncoder85.setPipeline(pipeline0);
} catch {}
canvas0.width = 200;
let buffer65 = device0.createBuffer({size: 783, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder95 = device0.createCommandEncoder({});
let textureView95 = texture51.createView({});
let sampler67 = device0.createSampler({
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 65.31,
  lodMaxClamp: 72.12,
  compare: 'greater-equal',
  maxAnisotropy: 6,
});
try {
computePassEncoder30.setBindGroup(0, bindGroup43, new Uint32Array(2790), 65, 0);
} catch {}
try {
computePassEncoder86.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer9, 'uint32', 1_740, 85);
} catch {}
try {
renderPassEncoder16.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(3, buffer20);
} catch {}
let buffer66 = device0.createBuffer({size: 5791, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let textureView96 = texture83.createView({baseArrayLayer: 2, arrayLayerCount: 3});
let renderPassEncoder25 = commandEncoder41.beginRenderPass({
  colorAttachments: [{
  view: textureView71,
  depthSlice: 4,
  clearValue: { r: 932.1, g: -882.9, b: 240.3, a: -359.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 400368155,
});
try {
computePassEncoder81.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder13.popDebugGroup();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12',  timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'pq'} });
let computePassEncoder87 = commandEncoder95.beginComputePass();
try {
{ clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1, 1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer9, 840); };
} catch {}
try {
computePassEncoder40.end();
} catch {}
try {
renderPassEncoder12.setBindGroup(0, bindGroup18, new Uint32Array(1651), 754, 0);
} catch {}
try {
renderPassEncoder15.executeBundles([renderBundle6]);
} catch {}
try {
renderPassEncoder12.draw(0, 614, 0, 676_682_443);
} catch {}
try {
renderPassEncoder12.drawIndexed(6, 182, 7, 450_369_210, 132_490_319);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 5},
  aspect: 'all',
}, new Uint8Array(4_007).fill(139), /* required buffer size: 4_007 */
{offset: 3, bytesPerRow: 286, rowsPerImage: 14}, {width: 14, height: 0, depthOrArrayLayers: 2});
} catch {}
let bindGroupLayout13 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 181,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder96 = device0.createCommandEncoder({});
let querySet18 = device0.createQuerySet({type: 'occlusion', count: 226});
let commandBuffer1 = commandEncoder47.finish();
let texture106 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 55},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView97 = texture53.createView({});
let computePassEncoder88 = commandEncoder96.beginComputePass({});
try {
computePassEncoder20.end();
} catch {}
try {
renderPassEncoder12.end();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 656, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 2, y: 0 },
  flipY: true,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 51, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.append(img0);
canvas0.height = 188;
let bindGroup49 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [{binding: 44, resource: {buffer: buffer9, offset: 256, size: 1884}}],
});
let buffer67 = device0.createBuffer({size: 907, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let commandEncoder97 = device0.createCommandEncoder({});
let textureView98 = texture63.createView({dimension: 'cube', baseArrayLayer: 2});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthStencilFormat: 'depth32float', depthReadOnly: true});
try {
computePassEncoder25.setBindGroup(2, bindGroup20, new Uint32Array(137), 8, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer43, 240); };
} catch {}
try {
renderPassEncoder19.executeBundles([]);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer66, 'uint32', 280, 587);
} catch {}
try {
commandEncoder24.resolveQuerySet(querySet9, 81, 56, buffer16, 11008);
} catch {}
try {
renderPassEncoder20.insertDebugMarker('\ua150');
} catch {}
try {
device0.queue.submit([commandBuffer1]);
} catch {}
let computePassEncoder89 = commandEncoder24.beginComputePass({label: '\u03ab\u15f3\u0d37'});
try {
computePassEncoder89.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder14.setBindGroup(0, bindGroup21, new Uint32Array(423), 40, 0);
} catch {}
let bindGroup50 = device0.createBindGroup({
  layout: bindGroupLayout10,
  entries: [
    {binding: 45, resource: textureView96},
    {binding: 120, resource: textureView76},
    {binding: 6, resource: textureView77},
  ],
});
let texture107 = device0.createTexture({
  size: {width: 129, height: 20, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  sampleCount: 1,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST,
});
let textureView99 = texture74.createView({mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 9});
let computePassEncoder90 = commandEncoder45.beginComputePass({});
let sampler68 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 98.56,
  lodMaxClamp: 99.89,
});
try {
computePassEncoder90.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle5, renderBundle11, renderBundle10]);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder14.setBindGroup(2, bindGroup8, new Uint32Array(720), 83, 0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 656, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame9,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 81, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder98 = device0.createCommandEncoder({});
let renderPassEncoder26 = commandEncoder98.beginRenderPass({
  colorAttachments: [{
  view: textureView78,
  clearValue: { r: -975.8, g: 713.1, b: -20.68, a: 700.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 85387107,
});
try {
renderPassEncoder5.setIndexBuffer(buffer28, 'uint16', 40, 601);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(1, buffer7, 0, 434);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(4, buffer8, 0);
} catch {}
try {
computePassEncoder70.pushDebugGroup('\u7ebc');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 656, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 81, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder99 = device0.createCommandEncoder();
try {
computePassEncoder69.setBindGroup(0, bindGroup3, new Uint32Array(5088), 1, 0);
} catch {}
try {
renderPassEncoder18.setBindGroup(0, bindGroup7);
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup3, new Uint32Array(822), 405, 0);
} catch {}
let bindGroupLayout14 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 48,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let texture108 = device0.createTexture({
  label: '\u{1fcf8}\uf490\ud134\ub0ac\u{1f897}',
  size: [328],
  dimension: '1d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView100 = texture91.createView({});
let computePassEncoder91 = commandEncoder99.beginComputePass({});
let renderPassEncoder27 = commandEncoder97.beginRenderPass({
  colorAttachments: [{
  view: textureView36,
  depthSlice: 18,
  clearValue: { r: -323.4, g: 793.8, b: 623.5, a: -222.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 90008176,
});
try {
computePassEncoder82.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setBindGroup(3, bindGroup40);
} catch {}
try {
renderPassEncoder14.setViewport(96.54783349961315, 0.6459949485457954, 27.079740711112652, 0.16822384477585364, 0.7996663149875829, 0.8387195618827443);
} catch {}
try {
globalThis.someLabel = buffer43.label;
} catch {}
let textureView101 = texture77.createView({arrayLayerCount: 5});
let texture109 = device0.createTexture({
  size: {width: 82},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView102 = texture104.createView({arrayLayerCount: 2});
let sampler69 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 84.80,
  lodMaxClamp: 88.30,
});
try {
computePassEncoder46.setBindGroup(2, bindGroup46, new Uint32Array(4882), 1_931, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer58, 1_264); };
} catch {}
try {
computePassEncoder88.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup45, new Uint32Array(572), 56, 0);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer28, 'uint32', 32, 1_893);
} catch {}
let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'bt2020_12bit'} });
let texture110 = device0.createTexture({
  size: [164, 1, 51],
  sampleCount: 1,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint'], stencilReadOnly: true});
try {
computePassEncoder75.setBindGroup(0, bindGroup34);
} catch {}
try {
renderPassEncoder11.setVertexBuffer(1, buffer3, 0, 4_450);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline1);
} catch {}
let buffer68 = device0.createBuffer({
  size: 34456,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder100 = device0.createCommandEncoder();
let texture111 = device0.createTexture({
  size: {width: 16, height: 2, depthOrArrayLayers: 153},
  mipLevelCount: 2,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
try {
computePassEncoder58.setBindGroup(1, bindGroup26);
} catch {}
try {
computePassEncoder87.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder15.setBindGroup(2, bindGroup39);
} catch {}
try {
commandEncoder100.copyBufferToTexture({
  /* bytesInLastRow: 72 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1160 */
  offset: 1160,
  bytesPerRow: 5888,
  buffer: buffer15,
}, {
  texture: texture109,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder100.copyTextureToTexture({
  texture: texture108,
  mipLevel: 0,
  origin: {x: 128, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture82,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder70.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer54, 304, new Int16Array(4245), 1152, 236);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let bindGroup51 = device0.createBindGroup({layout: bindGroupLayout14, entries: [{binding: 48, resource: textureView19}]});
let buffer69 = device0.createBuffer({
  size: 11987,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder92 = commandEncoder100.beginComputePass({});
let renderBundle14 = renderBundleEncoder14.finish({});
try {
computePassEncoder4.setBindGroup(3, bindGroup16);
} catch {}
try {
computePassEncoder31.setBindGroup(1, bindGroup28, new Uint32Array(1467), 75, 0);
} catch {}
try {
computePassEncoder91.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder23.setViewport(41.71971864676554, 15.736744834753743, 81.04496203055275, 2.240001490212786, 0.4840405820867941, 0.5681208830678555);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline1);
} catch {}
let imageBitmap1 = await createImageBitmap(videoFrame8);
let bindGroup52 = device0.createBindGroup({layout: bindGroupLayout13, entries: [{binding: 181, resource: textureView97}]});
let textureView103 = texture99.createView({aspect: 'depth-only', baseMipLevel: 1, baseArrayLayer: 2, arrayLayerCount: 3});
try {
computePassEncoder75.setBindGroup(2, bindGroup38);
} catch {}
try {
computePassEncoder85.setBindGroup(2, bindGroup5, new Uint32Array(4084), 1_047, 0);
} catch {}
try {
renderPassEncoder14.setBindGroup(2, bindGroup9, new Uint32Array(844), 180, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer40, 'uint16', 1_066, 364);
} catch {}
try {
renderBundleEncoder15.setBindGroup(0, bindGroup8);
} catch {}
let buffer70 = device0.createBuffer({
  size: 337,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let sampler70 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.34,
  lodMaxClamp: 99.89,
  maxAnisotropy: 17,
});
try {
computePassEncoder92.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder19.setBindGroup(1, bindGroup31, []);
} catch {}
try {
renderBundleEncoder15.setBindGroup(3, bindGroup38, new Uint32Array(936), 190, 0);
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
let bindGroup53 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [
    {binding: 227, resource: {buffer: buffer49, offset: 512, size: 195}},
    {binding: 68, resource: textureView27},
  ],
});
let commandEncoder101 = device0.createCommandEncoder({label: '\u0853\ubd48\u4878\uc132\ue202\u2f56\u0e5a'});
let texture112 = device0.createTexture({
  size: {width: 656, height: 1, depthOrArrayLayers: 9},
  mipLevelCount: 3,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView104 = texture81.createView({dimension: '2d-array'});
let computePassEncoder93 = commandEncoder101.beginComputePass({});
let renderBundle15 = renderBundleEncoder15.finish({});
try {
computePassEncoder8.setBindGroup(3, bindGroup48);
} catch {}
try {
renderPassEncoder5.executeBundles([renderBundle9, renderBundle0]);
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer49, 'uint32', 208, 114);
} catch {}
let buffer71 = device0.createBuffer({
  size: 9702,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder102 = device0.createCommandEncoder({});
let textureView105 = texture62.createView({dimension: '2d-array', format: 'rgba32sint', mipLevelCount: 1});
try {
computePassEncoder93.setBindGroup(1, bindGroup52);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer58, 1_428); };
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
document.body.append(img0);
await gc();
let commandEncoder103 = device0.createCommandEncoder({});
let textureView106 = texture89.createView({dimension: '2d', aspect: 'depth-only'});
try {
computePassEncoder93.setBindGroup(0, bindGroup28);
} catch {}
try {
computePassEncoder93.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder10.setBindGroup(1, bindGroup31);
} catch {}
try {
renderPassEncoder20.executeBundles([renderBundle1]);
} catch {}
try {
renderPassEncoder19.setVertexBuffer(7, buffer54, 112);
} catch {}
try {
commandEncoder103.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1104 */
  offset: 1104,
  rowsPerImage: 22,
  buffer: buffer45,
}, {
  texture: texture30,
  mipLevel: 0,
  origin: {x: 2, y: 2, z: 0},
  aspect: 'all',
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup54 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [
    {binding: 68, resource: textureView24},
    {binding: 227, resource: {buffer: buffer9, offset: 512, size: 494}},
  ],
});
let textureView107 = texture45.createView({arrayLayerCount: 1});
try {
renderPassEncoder1.setBindGroup(3, bindGroup54);
} catch {}
try {
renderPassEncoder19.beginOcclusionQuery(44);
} catch {}
try {
renderPassEncoder19.endOcclusionQuery();
} catch {}
try {
renderPassEncoder27.setBlendConstant({ r: 854.3, g: 743.7, b: -844.3, a: -577.6, });
} catch {}
try {
renderPassEncoder19.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture78,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 2},
  aspect: 'all',
}, new Uint8Array(38_329).fill(30), /* required buffer size: 38_329 */
{offset: 24, bytesPerRow: 163, rowsPerImage: 47}, {width: 1, height: 0, depthOrArrayLayers: 6});
} catch {}
let bindGroup55 = device0.createBindGroup({
  layout: bindGroupLayout5,
  entries: [
    {binding: 25, resource: textureView42},
    {binding: 104, resource: textureView38},
    {binding: 58, resource: {buffer: buffer24, offset: 0}},
    {binding: 10, resource: textureView43},
    {binding: 462, resource: sampler20},
    {binding: 112, resource: sampler40},
    {binding: 216, resource: {buffer: buffer54, offset: 0}},
    {binding: 73, resource: sampler11},
    {binding: 5, resource: textureView0},
    {binding: 9, resource: textureView106},
    {binding: 81, resource: textureView75},
    {binding: 89, resource: sampler48},
    {binding: 179, resource: externalTexture7},
    {binding: 14, resource: {buffer: buffer39, offset: 256, size: 5072}},
    {binding: 42, resource: textureView0},
    {binding: 277, resource: textureView51},
  ],
});
let texture113 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 174},
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder94 = commandEncoder103.beginComputePass({});
try {
computePassEncoder57.setBindGroup(2, bindGroup41);
} catch {}
try {
renderPassEncoder27.setBindGroup(3, bindGroup40);
} catch {}
try {
renderPassEncoder27.setVertexBuffer(7, buffer4);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder104 = device0.createCommandEncoder({});
let texture114 = device0.createTexture({
  size: [656, 1, 21],
  format: 'depth32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder95 = commandEncoder102.beginComputePass();
let renderPassEncoder28 = commandEncoder104.beginRenderPass({colorAttachments: [{view: textureView71, depthSlice: 7, loadOp: 'load', storeOp: 'discard'}]});
try {
computePassEncoder93.setBindGroup(0, bindGroup8, new Uint32Array(1614), 400, 0);
} catch {}
try {
buffer56.destroy();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); };
} catch {}
let buffer72 = device0.createBuffer({
  size: 3352,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let textureView108 = texture102.createView({
  label: '\ufd0a\ubeb1\u003d\u622b\ucf82\u8356',
  dimension: '2d-array',
  mipLevelCount: 1,
  arrayLayerCount: 1,
});
try {
renderPassEncoder3.setPipeline(pipeline1);
} catch {}
let commandEncoder105 = device0.createCommandEncoder();
let texture115 = device0.createTexture({
  size: [656, 1, 80],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView109 = texture6.createView({});
let renderPassEncoder29 = commandEncoder105.beginRenderPass({
  colorAttachments: [{
  view: textureView62,
  clearValue: { r: -467.1, g: -806.1, b: -817.4, a: 693.0, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet2,
  maxDrawCount: 519664055,
});
try {
renderPassEncoder6.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer69, 'uint16', 1_038, 4_260);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, buffer4, 0, 199);
} catch {}
try {
device0.queue.writeBuffer(buffer52, 380, new DataView(new ArrayBuffer(14027)), 262, 216);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); };
} catch {}
let buffer73 = device0.createBuffer({size: 11911, usage: GPUBufferUsage.MAP_WRITE});
let texture116 = device0.createTexture({
  label: '\u8657\u{1f9b2}\u0b75\u059d\u{1f999}\u6b43\u{1febc}\u{1f80c}',
  size: [328, 1, 8],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler71 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.30,
  lodMaxClamp: 99.46,
  maxAnisotropy: 15,
});
try {
computePassEncoder95.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer16, 0, 1_339);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture59,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 9},
  aspect: 'all',
}, new Uint8Array(20_695).fill(220), /* required buffer size: 20_695 */
{offset: 87, bytesPerRow: 56, rowsPerImage: 46}, {width: 2, height: 0, depthOrArrayLayers: 9});
} catch {}
let buffer74 = device0.createBuffer({size: 975, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let texture117 = device0.createTexture({
  size: [64, 10, 1],
  sampleCount: 1,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView110 = texture84.createView({mipLevelCount: 1});
let sampler72 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 19,
});
try {
computePassEncoder71.setBindGroup(0, bindGroup43);
} catch {}
try {
computePassEncoder94.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder5.setBindGroup(1, bindGroup33);
} catch {}
let commandEncoder106 = device0.createCommandEncoder({});
let texture118 = device0.createTexture({
  label: '\ufced\u01b3\u{1feeb}',
  size: {width: 129, height: 20, depthOrArrayLayers: 221},
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder47.setBindGroup(2, bindGroup42, new Uint32Array(2699), 69, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline1);
} catch {}
try {
commandEncoder106.resolveQuerySet(querySet4, 71, 103, buffer45, 256);
} catch {}
try {
gpuCanvasContext6.unconfigure();
} catch {}
let renderPassEncoder30 = commandEncoder106.beginRenderPass({
  colorAttachments: [{
  view: textureView59,
  clearValue: { r: 380.8, g: 859.2, b: 601.9, a: 801.8, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 241046507,
});
try {
computePassEncoder59.setBindGroup(3, bindGroup23);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); };
} catch {}
try {
computePassEncoder30.end();
} catch {}
try {
renderPassEncoder0.setViewport(112.42973104370161, 0.37478179659976163, 201.79994199069364, 0.483253690618021, 0.38026401706678836, 0.7323372096994455);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline1);
} catch {}
try {
  await shaderModule5.getCompilationInfo();
} catch {}
try {
commandEncoder34.clearBuffer(buffer3, 564, 992);
} catch {}
let texture119 = device0.createTexture({
  label: '\uaed7\u43bd\u07d1\u5eb4\uc7cc\u1bb9\u06b5\u{1f6fd}',
  size: {width: 16, height: 2, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder96 = commandEncoder34.beginComputePass({});
let sampler73 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 1.686,
  lodMaxClamp: 10.82,
});
try {
computePassEncoder44.setBindGroup(3, bindGroup39);
} catch {}
try {
computePassEncoder42.setBindGroup(2, bindGroup47, new Uint32Array(1445), 549, 0);
} catch {}
try {
renderPassEncoder15.setBindGroup(2, bindGroup32, new Uint32Array(656), 19, 0);
} catch {}
try {
renderPassEncoder24.setBlendConstant({ r: -275.2, g: -362.8, b: 398.7, a: -353.0, });
} catch {}
try {
renderPassEncoder1.setScissorRect(6, 0, 40, 0);
} catch {}
try {
renderPassEncoder28.setIndexBuffer(buffer30, 'uint32', 10_428, 1_040);
} catch {}
let bindGroupLayout15 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 183,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', hasDynamicOffset: false },
    },
    {
      binding: 182,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 110,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 444,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true },
    },
  ],
});
let bindGroup56 = device0.createBindGroup({
  layout: bindGroupLayout8,
  entries: [
    {binding: 191, resource: sampler55},
    {binding: 128, resource: {buffer: buffer24, offset: 256}},
    {binding: 50, resource: sampler54},
  ],
});
let texture120 = device0.createTexture({
  size: {width: 656, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder32.setBindGroup(1, bindGroup52);
} catch {}
try {
computePassEncoder96.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline1);
} catch {}
try {
computePassEncoder74.insertDebugMarker('\u00f8');
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let textureView111 = texture120.createView({
  label: '\uc46d\u5199\u0b8a\u2850\u0159\u27d0\udf18\u{1fca2}\u4917\u80b8',
  mipLevelCount: 1,
  arrayLayerCount: 1,
});
try {
computePassEncoder13.setBindGroup(0, bindGroup1, new Uint32Array(1272), 10, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder93); computePassEncoder93.dispatchWorkgroupsIndirect(buffer25, 32); };
} catch {}
try {
renderPassEncoder2.setBindGroup(2, bindGroup40, new Uint32Array(92), 24, 0);
} catch {}
let textureView112 = texture94.createView({label: '\u{1f669}\u45c9\u{1fc0a}\u2b36\uf3e6\u8784', dimension: '2d-array'});
let textureView113 = texture58.createView({});
try {
renderPassEncoder7.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup13, new Uint32Array(622), 0, 0);
} catch {}
try {
renderPassEncoder25.setVertexBuffer(3, buffer48);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(2_594).fill(125), /* required buffer size: 2_594 */
{offset: 248, bytesPerRow: 69, rowsPerImage: 17}, {width: 3, height: 0, depthOrArrayLayers: 3});
} catch {}
try {
computePassEncoder52.setBindGroup(2, bindGroup24, new Uint32Array(1252), 49, 0);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer66, 'uint32', 1_044, 161);
} catch {}
try {
device0.queue.writeBuffer(buffer37, 924, new Float32Array(21962), 675, 128);
} catch {}
let commandEncoder107 = device0.createCommandEncoder();
try {
computePassEncoder93.end();
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer4, 0, 151);
} catch {}
try {
commandEncoder107.copyBufferToBuffer(buffer16, 172, buffer13, 112, 60);
} catch {}
try {
device0.queue.submit([]);
} catch {}
let texture121 = device0.createTexture({
  size: [164, 1, 1],
  sampleCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder97 = commandEncoder101.beginComputePass();
let renderPassEncoder31 = commandEncoder107.beginRenderPass({
  colorAttachments: [{
  view: textureView30,
  depthSlice: 31,
  clearValue: { r: -110.5, g: 910.9, b: 530.4, a: 467.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet11,
});
try {
computePassEncoder3.setBindGroup(2, bindGroup37);
} catch {}
try {
computePassEncoder97.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder26.setBlendConstant({ r: -687.4, g: 328.2, b: -861.0, a: -141.5, });
} catch {}
try {
renderPassEncoder8.draw(0, 110, 0, 1_680_151_734);
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer67, 'uint32', 56, 99);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline1);
} catch {}
try {
device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); });
} catch {}
let bindGroup57 = device0.createBindGroup({
  layout: bindGroupLayout15,
  entries: [
    {binding: 183, resource: {buffer: buffer5, offset: 0, size: 244}},
    {binding: 444, resource: textureView111},
    {binding: 110, resource: textureView97},
    {binding: 182, resource: textureView66},
    {binding: 8, resource: textureView112},
  ],
});
let buffer75 = device0.createBuffer({
  label: '\u02d6\u0586\u0cc0\ua9d1\u1d70\u48e7',
  size: 12075,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let textureView114 = texture60.createView({mipLevelCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder57); computePassEncoder57.dispatchWorkgroupsIndirect(buffer55, 808); };
} catch {}
try {
renderPassEncoder15.setVertexBuffer(5, buffer11, 0, 384);
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
computePassEncoder56.setBindGroup(1, bindGroup57);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup35, new Uint32Array(2317), 410, 0);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer12, 3_548);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline1);
} catch {}
let bindGroupLayout16 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 165,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
    {
      binding: 52,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 396,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' },
    },
  ],
});
let texture122 = device0.createTexture({
  size: {width: 129, height: 20, depthOrArrayLayers: 1},
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView115 = texture110.createView({dimension: '2d', baseArrayLayer: 50});
let sampler74 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 68.95,
  lodMaxClamp: 77.12,
  maxAnisotropy: 13,
});
try {
computePassEncoder21.setBindGroup(0, bindGroup34);
} catch {}
try {
renderPassEncoder15.setBindGroup(3, bindGroup16, new Uint32Array(368), 1, 0);
} catch {}
try {
renderPassEncoder30.end();
} catch {}
try {
renderPassEncoder15.setIndexBuffer(buffer5, 'uint32', 8, 208);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(5, buffer57, 2_268, 1_551);
} catch {}
try {
device0.queue.writeBuffer(buffer62, 1476, new Float32Array(11534), 308, 448);
} catch {}
let bindGroup58 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 67, resource: textureView57}]});
let commandEncoder108 = device0.createCommandEncoder();
let texture123 = device0.createTexture({
  size: {width: 32, height: 5, depthOrArrayLayers: 113},
  format: 'r32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let texture124 = device0.createTexture({
  size: {width: 16},
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder3.setBindGroup(1, bindGroup42);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer70, 100);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture25,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(177).fill(103), /* required buffer size: 177 */
{offset: 177}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup59 = device0.createBindGroup({
  label: '\u{1f7ef}\u5067\u{1ff2a}\u0268\ud83b\ud832\u0227\ubd41\u01e4\u058d',
  layout: bindGroupLayout14,
  entries: [{binding: 48, resource: textureView19}],
});
let commandEncoder109 = device0.createCommandEncoder();
let textureView116 = texture122.createView({label: '\u{1fe54}\u{1f8f6}\u06f2\u029c\u1ac6\u00bd\u{1fb9b}'});
let texture125 = device0.createTexture({
  size: [129, 20, 221],
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
{ clearResourceUsages(device0, computePassEncoder57); computePassEncoder57.dispatchWorkgroupsIndirect(buffer67, 28); };
} catch {}
try {
renderPassEncoder31.setViewport(462.2199966598913, 0.9457403056418926, 181.97210849480666, 0.01869142391917289, 0.5604684290076107, 0.716604681950097);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); };
} catch {}
await gc();
let buffer76 = device0.createBuffer({
  size: 14355,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder110 = device0.createCommandEncoder({});
let textureView117 = texture7.createView({dimension: '2d-array', baseArrayLayer: 0});
let computePassEncoder98 = commandEncoder110.beginComputePass({});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthStencilFormat: 'depth32float', depthReadOnly: true});
let sampler75 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 0.7184,
  lodMaxClamp: 76.89,
  maxAnisotropy: 9,
});
try {
computePassEncoder98.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder25.setBindGroup(3, bindGroup49);
} catch {}
try {
renderBundleEncoder16.setVertexBuffer(4, buffer17);
} catch {}
try {
querySet14.destroy();
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder111 = device0.createCommandEncoder({});
let textureView118 = texture119.createView({aspect: 'depth-only'});
let computePassEncoder99 = commandEncoder109.beginComputePass({});
let renderBundle16 = renderBundleEncoder16.finish({label: '\u07d0\u3b1c\ua7fd'});
try {
{ clearResourceUsages(device0, computePassEncoder57); computePassEncoder57.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder99.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder16.setBindGroup(3, bindGroup31, new Uint32Array(1006), 156, 0);
} catch {}
try {
renderPassEncoder20.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(0, buffer70);
} catch {}
try {
gpuCanvasContext5.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST});
} catch {}
let canvas8 = document.createElement('canvas');
let bindGroup60 = device0.createBindGroup({
  layout: bindGroupLayout16,
  entries: [
    {binding: 165, resource: {buffer: buffer11, offset: 256, size: 7152}},
    {binding: 396, resource: textureView116},
    {binding: 52, resource: textureView51},
  ],
});
let texture126 = device0.createTexture({
  size: {width: 64, height: 10, depthOrArrayLayers: 110},
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let textureView119 = texture9.createView({mipLevelCount: 1});
let computePassEncoder100 = commandEncoder111.beginComputePass({});
let renderPassEncoder32 = commandEncoder108.beginRenderPass({
  label: '\u{1f636}\u0ea3\u32b9\u7a38\u70bc',
  colorAttachments: [{
  view: textureView95,
  depthSlice: 33,
  clearValue: { r: -218.6, g: 198.0, b: 366.7, a: -180.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet0,
});
try {
computePassEncoder66.setBindGroup(1, bindGroup58);
} catch {}
try {
renderPassEncoder32.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder24.setViewport(19.769131119453327, 0.34098249997407426, 144.34914273270246, 0.2379454409770424, 0.021336852387237593, 0.2529523383142108);
} catch {}
try {
renderPassEncoder8.draw(0, 749, 0, 1_781_841_735);
} catch {}
try {
computePassEncoder47.pushDebugGroup('\ub5c4');
} catch {}
let bindGroup61 = device0.createBindGroup({
  label: '\u{1fd07}\u854f\u010e\u9051\u{1f9ad}\ud5e5\u2083\u31f5\u{1f6c0}',
  layout: bindGroupLayout0,
  entries: [{binding: 67, resource: textureView91}],
});
let commandEncoder112 = device0.createCommandEncoder({});
let textureView120 = texture122.createView({});
try {
computePassEncoder59.setBindGroup(0, bindGroup54);
} catch {}
try {
computePassEncoder75.setBindGroup(1, bindGroup52, new Uint32Array(4910), 573, 0);
} catch {}
try {
computePassEncoder100.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.draw(0, 21, 0, 327_304_053);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer16, 5_412);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(5, buffer68, 960, 228);
} catch {}
try {
commandEncoder112.copyBufferToBuffer(buffer43, 4392, buffer74, 324, 76);
} catch {}
let commandEncoder113 = device0.createCommandEncoder({});
let texture127 = device0.createTexture({
  size: {width: 64, height: 10, depthOrArrayLayers: 89},
  format: 'r8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder101 = commandEncoder112.beginComputePass({});
try {
renderPassEncoder29.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder8.draw(0, 88, 0, 81_170_011);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer12, 1_144);
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer40, 'uint32', 88, 1_061);
} catch {}
try {
commandEncoder106.copyTextureToTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer50, 2664, new Float32Array(1612), 332, 4);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture81,
  mipLevel: 0,
  origin: {x: 54, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(13).fill(35), /* required buffer size: 13 */
{offset: 13, rowsPerImage: 107}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
document.body.prepend(canvas4);
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup62 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 69, resource: externalTexture2}]});
let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: []});
let buffer77 = device0.createBuffer({size: 8610, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM});
let textureView121 = texture3.createView({label: '\u51ad\u18c7\u434f\u{1f903}\u0dd1', aspect: 'all', baseArrayLayer: 41, arrayLayerCount: 6});
let sampler76 = device0.createSampler({
  label: '\uf0c3\ufcbd\u{1f755}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 73.82,
  lodMaxClamp: 79.62,
  maxAnisotropy: 18,
});
try {
computePassEncoder90.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder10.setStencilReference(3819);
} catch {}
try {
renderPassEncoder8.draw(0, 4, 0, 146_966_032);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(7, buffer5, 0);
} catch {}
try {
commandEncoder106.copyBufferToBuffer(buffer65, 352, buffer37, 8124, 96);
} catch {}
try {
computePassEncoder47.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer47, 324, new BigUint64Array(30395), 3917, 24);
} catch {}
let buffer78 = device0.createBuffer({
  size: 8539,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder114 = device0.createCommandEncoder();
let texture128 = device0.createTexture({size: [32, 5, 102], format: 'r8sint', usage: GPUTextureUsage.RENDER_ATTACHMENT});
let computePassEncoder102 = commandEncoder113.beginComputePass({});
try {
computePassEncoder101.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.draw(0, 119, 0, 197_759_122);
} catch {}
try {
renderPassEncoder8.drawIndirect(buffer46, 820);
} catch {}
try {
renderPassEncoder31.setVertexBuffer(1, buffer70, 0);
} catch {}
try {
commandEncoder114.copyBufferToTexture({
  /* bytesInLastRow: 304 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1568 */
  offset: 1568,
  rowsPerImage: 3,
  buffer: buffer29,
}, {
  texture: texture55,
  mipLevel: 0,
  origin: {x: 17, y: 3, z: 8},
  aspect: 'all',
}, {width: 19, height: 1, depthOrArrayLayers: 0});
} catch {}
let imageData9 = new ImageData(52, 32);
let commandEncoder115 = device0.createCommandEncoder();
let texture129 = device0.createTexture({
  size: [32, 5, 55],
  dimension: '3d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView122 = texture129.createView({});
let computePassEncoder103 = commandEncoder106.beginComputePass({});
try {
computePassEncoder14.setBindGroup(1, bindGroup49);
} catch {}
try {
computePassEncoder103.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder29.endOcclusionQuery();
} catch {}
try {
renderPassEncoder24.setVertexBuffer(1, buffer6, 1_632);
} catch {}
try {
commandEncoder115.copyTextureToTexture({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 126, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture37,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 1},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder114.resolveQuerySet(querySet7, 28, 126, buffer3, 2048);
} catch {}
let texture130 = device0.createTexture({
  size: [129, 20, 59],
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder31.setBindGroup(2, bindGroup4);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroups(4); };
} catch {}
try {
computePassEncoder102.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder8.draw(0, 21, 0, 67_596_313);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline1);
} catch {}
let texture131 = device0.createTexture({
  label: '\u0509\u72f1\u0bf5\u{1f737}',
  size: [16, 2, 27],
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder104 = commandEncoder114.beginComputePass();
let externalTexture13 = device0.importExternalTexture({source: videoFrame2});
try {
renderPassEncoder32.setViewport(2.398617375054531, 3.5549950358861175, 12.243754923409007, 0.6480393011305156, 0.1833923655127061, 0.6296556558352271);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(7, buffer76);
} catch {}
await gc();
try {
canvas8.getContext('webgl2');
} catch {}
let computePassEncoder105 = commandEncoder115.beginComputePass({});
let sampler77 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 19.69,
  lodMaxClamp: 42.48,
});
try {
renderPassEncoder32.setBindGroup(2, bindGroup50);
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup9, new Uint32Array(406), 82, 0);
} catch {}
try {
renderPassEncoder8.draw(0, 330, 0, 43_174_883);
} catch {}
try {
renderPassEncoder18.setIndexBuffer(buffer66, 'uint16', 14, 2_992);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(2, buffer70, 0, 5);
} catch {}
try {
  await shaderModule5.getCompilationInfo();
} catch {}
requestAnimationFrame(startTime => globalThis.startTime=startTime);
let bindGroup63 = device0.createBindGroup({
  layout: bindGroupLayout2,
  entries: [
    {binding: 68, resource: textureView51},
    {binding: 227, resource: {buffer: buffer49, offset: 0, size: 647}},
  ],
});
let commandEncoder116 = device0.createCommandEncoder({label: '\uee24\u{1f968}\u43e6\u0de3\u5ff3'});
let textureView123 = texture120.createView({});
let sampler78 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 51.98,
  lodMaxClamp: 67.58,
});
try {
computePassEncoder103.setBindGroup(1, bindGroup26);
} catch {}
try {
computePassEncoder44.end();
} catch {}
try {
renderPassEncoder26.setBindGroup(2, bindGroup14, new Uint32Array(222), 29, 0);
} catch {}
try {
renderPassEncoder32.setPipeline(pipeline1);
} catch {}
let imageData10 = new ImageData(4, 92);
let buffer79 = device0.createBuffer({
  size: 15605,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let computePassEncoder106 = commandEncoder52.beginComputePass({label: '\u0129\ucfd2\u0eee\u6464\u0fb9\u9c72'});
let sampler79 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 65.70,
  lodMaxClamp: 92.40,
});
try {
computePassEncoder94.setBindGroup(1, bindGroup38, new Uint32Array(3131), 196, 0);
} catch {}
try {
renderPassEncoder8.end();
} catch {}
try {
renderPassEncoder1.setVertexBuffer(2, buffer40, 2_232);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let texture132 = device0.createTexture({
  size: [164, 1, 31],
  sampleCount: 1,
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture133 = device0.createTexture({
  size: {width: 16, height: 2, depthOrArrayLayers: 31},
  mipLevelCount: 1,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView124 = texture122.createView({label: '\u{1ff51}\u{1f8ad}', dimension: '2d-array', baseArrayLayer: 0, arrayLayerCount: 1});
try {
renderPassEncoder15.setBindGroup(0, bindGroup30, new Uint32Array(337), 47, 0);
} catch {}
try {
commandEncoder39.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1568 */
  offset: 1568,
  bytesPerRow: 3072,
  buffer: buffer53,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext4.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT, alphaMode: 'opaque'});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture130,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 3},
  aspect: 'all',
}, new Uint8Array(20_364).fill(96), /* required buffer size: 20_364 */
{offset: 79, bytesPerRow: 48, rowsPerImage: 19}, {width: 29, height: 5, depthOrArrayLayers: 23});
} catch {}
try {
gpuCanvasContext4.unconfigure();
} catch {}
let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt709', transfer: 'smpte170m'} });
let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: []});
let texture134 = device0.createTexture({
  size: {width: 82, height: 1, depthOrArrayLayers: 1},
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder107 = commandEncoder116.beginComputePass({});
try {
computePassEncoder64.setBindGroup(2, bindGroup16);
} catch {}
await gc();
let img1 = await imageWithData(26, 25, '#10101010', '#20202020');
let commandEncoder117 = device0.createCommandEncoder();
try {
{ clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer30, 4_756); };
} catch {}
try {
computePassEncoder107.setPipeline(pipeline0);
} catch {}
let pipeline3 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule1, entryPoint: 'compute1'}});
let img2 = await imageWithData(41, 21, '#10101010', '#20202020');
let commandBuffer2 = commandEncoder39.finish();
let textureView125 = texture122.createView({dimension: '2d-array', arrayLayerCount: 1});
let computePassEncoder108 = commandEncoder117.beginComputePass({});
let externalTexture14 = device0.importExternalTexture({
  label: '\ud957\uc267\u0627\u09b5\ua725\u{1fadd}\u12c3\u6b51\uac63\u5459',
  source: videoFrame4,
  colorSpace: 'display-p3',
});
try {
{ clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroups(2); };
} catch {}
try {
computePassEncoder105.setPipeline(pipeline3);
} catch {}
let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX',  timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'film', transfer: 'bt2020_12bit'} });
let buffer80 = device0.createBuffer({
  size: 2549,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let externalTexture15 = device0.importExternalTexture({source: videoFrame12, colorSpace: 'display-p3'});
try {
computePassEncoder54.setBindGroup(3, bindGroup23, new Uint32Array(272), 2, 0);
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer55, 684); };
} catch {}
try {
computePassEncoder67.setPipeline(pipeline3);
} catch {}
try {
computePassEncoder108.setPipeline(pipeline0);
} catch {}
try {
computePassEncoder11.insertDebugMarker('\u0f07');
} catch {}
let commandEncoder118 = device0.createCommandEncoder({});
let texture135 = device0.createTexture({
  size: {width: 82, height: 1, depthOrArrayLayers: 1},
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler80 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 35.24,
  lodMaxClamp: 80.75,
  maxAnisotropy: 20,
});
try {
computePassEncoder38.setBindGroup(0, bindGroup62, new Uint32Array(939), 27, 0);
} catch {}
try {
computePassEncoder27.end();
} catch {}
try {
renderPassEncoder18.setPipeline(pipeline1);
} catch {}
try {
device0.queue.writeBuffer(buffer75, 656, new DataView(new ArrayBuffer(879)), 231, 28);
} catch {}
let commandEncoder119 = device0.createCommandEncoder({});
let renderPassEncoder33 = commandEncoder31.beginRenderPass({
  colorAttachments: [{
  view: textureView62,
  clearValue: { r: -402.6, g: 683.1, b: -386.4, a: -708.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet14,
  maxDrawCount: 15898719,
});
let sampler81 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 93.26,
  lodMaxClamp: 97.39,
});
let externalTexture16 = device0.importExternalTexture({source: videoFrame4});
try {
computePassEncoder0.end();
} catch {}
try {
computePassEncoder106.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder4.setBindGroup(2, bindGroup41, new Uint32Array(516), 138, 0);
} catch {}
try {
commandEncoder119.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 544 */
  offset: 544,
  bytesPerRow: 2304,
  buffer: buffer38,
}, {
  texture: texture75,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer2]);
} catch {}
let bindGroupLayout17 = device0.createBindGroupLayout({
  label: '\u{1fdc3}\ud69d',
  entries: [
    {
      binding: 69,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false },
    },
    {
      binding: 67,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let buffer81 = device0.createBuffer({
  size: 16408,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let sampler82 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 49.06,
  lodMaxClamp: 55.19,
  maxAnisotropy: 13,
});
try {
renderPassEncoder22.setBindGroup(3, bindGroup28, new Uint32Array(1571), 345, 0);
} catch {}
try {
renderPassEncoder32.beginOcclusionQuery(0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 300, height: 150, depthOrArrayLayers: 1}
*/
{
  source: videoFrame12,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture98,
  mipLevel: 0,
  origin: {x: 9, y: 8, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder26.setBindGroup(2, bindGroup9, new Uint32Array(1443), 317, 0);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer54, 'uint32', 588, 312);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder120 = device0.createCommandEncoder();
let texture136 = device0.createTexture({
  size: [16, 16, 12],
  format: 'depth24plus-stencil8',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView126 = texture30.createView({dimension: '2d-array', mipLevelCount: 1});
let computePassEncoder109 = commandEncoder119.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroups(1); };
} catch {}
try {
{ clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroupsIndirect(buffer67, 220); };
} catch {}
try {
computePassEncoder104.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer78, 'uint16', 182, 569);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture78,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(11_400).fill(55), /* required buffer size: 11_400 */
{offset: 224, bytesPerRow: 22, rowsPerImage: 127}, {width: 4, height: 0, depthOrArrayLayers: 5});
} catch {}
let shaderModule6 = device0.createShaderModule({
  code: `
enable f16;

requires pointer_composite_access;

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

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

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

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

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

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

struct FragmentOutput5 {
  @location(6) @interpolate(linear, centroid) f0: vec2f,
  @location(2) @interpolate(flat) f1: vec2u,
  @location(3) f2: u32,
  @location(0) @interpolate(linear, sample) f3: vec4f,
}

fn fn0(a0: ptr<uniform, array<array<mat3x2f, 1>, 1>>) -> array<FragmentOutput5, 1> {
  var out: array<FragmentOutput5, 1>;
  out[u32(unconst_u32(409))].f0 -= vec2f(bitcast<f32>(dot4U8Packed(u32(unconst_u32(227)), u32(unconst_u32(388)))));
  out[u32(unconst_u32(6))] = FragmentOutput5(vec2f(f32(distance(f16(unconst_f16(11126.0)), f16(unconst_f16(-6920.5))))), vec2u(u32(distance(f16(unconst_f16(11126.0)), f16(unconst_f16(-6920.5))))), u32(distance(f16(unconst_f16(11126.0)), f16(unconst_f16(-6920.5)))), vec4f(f32(distance(f16(unconst_f16(11126.0)), f16(unconst_f16(-6920.5))))));
  out[u32(unconst_u32(67))].f3 = (*a0)[u32(unconst_u32(368))][0][unconst_i32(2)].xyxx;
  var vf106: f32 = cosh(f32(unconst_f32(0.2689)));
  vf106 = (*a0)[0][u32(unconst_u32(97))][u32(unconst_u32(215))][u32(unconst_u32(207))];
  let ptr65: ptr<uniform, mat3x2f> = &(*a0)[0][0];
  let ptr66: ptr<uniform, mat3x2f> = &(*a0)[u32(unconst_u32(85))][u32(unconst_u32(207))];
  let ptr67: ptr<uniform, mat3x2f> = &(*ptr65);
  let ptr68: ptr<uniform, array<mat3x2f, 1>> = &(*a0)[u32(unconst_u32(62))];
  return out;
}

var<workgroup> vw11: array<array<f16, 12>, 1>;

@fragment
fn fragment6() -> FragmentOutput5 {
  var out: FragmentOutput5;
  out.f2 -= vec4u(reverseBits(vec4i(unconst_i32(-250), unconst_i32(23), unconst_i32(187), unconst_i32(303))))[0];
  return out;
}

@compute @workgroup_size(5, 1, 1)
fn compute6(@builtin(local_invocation_id) a0: vec3u) {
  vw11[0][u32(unconst_u32(8))] = vw11[0][11];
  let ptr69: ptr<workgroup, f16> = &(*&vw11)[u32(unconst_u32(31))][u32(unconst_u32(100))];
  vw11[u32(unconst_u32(45))][11] *= vw11[u32(unconst_u32(184))][u32(unconst_u32(660))];
  let ptr70: ptr<workgroup, f16> = &vw11[0][11];
  let ptr71: ptr<workgroup, f16> = &(*&vw11)[0][pack4xU8Clamp(vec4u(atan2(vec4h(unconst_f16(-3669.3), unconst_f16(10109.4), unconst_f16(37820.3), unconst_f16(2055.8)), vec4h(unconst_f16(22301.9), unconst_f16(3584.4), unconst_f16(4330.6), unconst_f16(11362.5)))))];
  vw11[u32(unconst_u32(342))][u32(unconst_u32(350))] = vw11[0][vec3u(select(vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true)), vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false)), vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false)))).y];
  vw11[u32(unconst_u32(60))][u32(unconst_u32(53))] = f16(pack4xU8Clamp(vec4u(unconst_u32(154), unconst_u32(383), unconst_u32(510), unconst_u32(232))));
  let ptr72: ptr<workgroup, f16> = &vw11[0][u32(unconst_u32(32))];
  vw11[0][u32(unconst_u32(1))] = vw11[u32(unconst_u32(355))][11];
  let ptr73: ptr<workgroup, f16> = &(*ptr69);
  let ptr74: ptr<workgroup, f16> = &(*ptr72);
  let ptr75: ptr<workgroup, f16> = &vw11[u32(unconst_u32(104))][11];
  let ptr76: ptr<workgroup, f16> = &(*ptr74);
  vw11[u32(unconst_u32(420))][u32(vw11[u32(unconst_u32(121))][11])] = vw11[0][11];
  vw11[u32(unconst_u32(107))][u32(unconst_u32(178))] = (*&vw11)[u32(unconst_u32(372))][11];
  let ptr77: ptr<workgroup, array<f16, 12>> = &(*&vw11)[u32(unconst_u32(130))];
  vw11[u32((*&vw11)[u32(unconst_u32(31))][u32(unconst_u32(231))])][u32(unconst_u32(113))] = (*ptr77)[11];
  vw11[u32(unconst_u32(164))][u32(unconst_u32(152))] = vec2h(countTrailingZeros(vec2i(unconst_i32(92), unconst_i32(168))))[1];
  vw11[0][u32((*ptr77)[11])] -= f16(asin(vec3f(unconst_f32(0.03042), unconst_f32(0.2890), unconst_f32(0.6732))).x);
  vw11[u32(unconst_u32(543))][u32(unconst_u32(74))] *= vw11[u32(unconst_u32(292))][11];
}`,
  hints: {},
});
let bindGroupLayout18 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 155,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 56,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let buffer82 = device0.createBuffer({size: 3983, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let querySet19 = device0.createQuerySet({type: 'occlusion', count: 335});
let texture137 = device0.createTexture({
  size: [164],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['bgra8unorm'],
});
let textureView127 = texture126.createView({arrayLayerCount: 1});
let renderPassEncoder34 = commandEncoder0.beginRenderPass({
  colorAttachments: [{view: textureView126, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet6,
});
try {
renderPassEncoder2.setBindGroup(2, bindGroup9);
} catch {}
try {
commandEncoder120.copyBufferToTexture({
  /* bytesInLastRow: 288 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1680 */
  offset: 1680,
  bytesPerRow: 4352,
  buffer: buffer53,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, {width: 18, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
externalTexture8.label = '\u{1f93a}\u079b\u0bb6\u{1faa4}\u{1f6e0}';
} catch {}
let bindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 15,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', hasDynamicOffset: false },
    },
  ],
});
let texture138 = device0.createTexture({
  label: '\u{1ffab}\u{1ff8f}\u49a0\u0d1e\u598a',
  size: [82, 1, 19],
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder110 = commandEncoder120.beginComputePass({});
try {
{ clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroupsIndirect(buffer55, 196); };
} catch {}
try {
renderPassEncoder32.endOcclusionQuery();
} catch {}
try {
commandEncoder118.copyTextureToTexture({
  texture: texture94,
  mipLevel: 0,
  origin: {x: 70, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture98,
  mipLevel: 0,
  origin: {x: 3, y: 17, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
document.body.append(canvas4);
try {
globalThis.someLabel = device0.label;
} catch {}
let commandEncoder121 = device0.createCommandEncoder({label: '\u09a2\ue1ce\u2d63\u08a5\u8b04\uece9'});
let texture139 = device0.createTexture({
  label: '\u91d9\udb44\u06e7',
  size: {width: 64, height: 10, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView128 = texture132.createView({format: 'r32float', arrayLayerCount: 1});
try {
{ clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroupsIndirect(buffer72, 20); };
} catch {}
try {
renderPassEncoder4.setIndexBuffer(buffer76, 'uint16', 110, 705);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline1);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer61, 0);
} catch {}
try {
commandEncoder121.insertDebugMarker('\u58cd');
} catch {}
let imageData11 = new ImageData(92, 52);
let bindGroupLayout20 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 424,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', hasDynamicOffset: false },
    },
  ],
});
let buffer83 = device0.createBuffer({
  label: '\u{1f8a7}\u4657\u4ee3\ua729\u103b\ub57f\u{1ff0a}\u{1f9ab}\ub216',
  size: 11883,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let textureView129 = texture123.createView({dimension: '2d', baseArrayLayer: 13});
let textureView130 = texture38.createView({label: '\u0fef\uc87e\u50bb', mipLevelCount: 1, arrayLayerCount: 3});
let computePassEncoder111 = commandEncoder118.beginComputePass({label: '\u0b1e\u0e9b\ud475\u0bf6\uc277\u3f88\u062e\ubdcf\u236c'});
try {
{ clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroups(1, 1); };
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer49, 'uint16', 8, 77);
} catch {}
try {
renderPassEncoder28.setPipeline(pipeline1);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { e.label = device0.label; });
} catch {}
try {
commandEncoder121.copyTextureToBuffer({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 288 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 224 */
  offset: 224,
  buffer: buffer43,
}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
await gc();
let sampler83 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 38.01});
try {
computePassEncoder68.setBindGroup(2, bindGroup32, new Uint32Array(1268), 72, 0);
} catch {}
try {
commandEncoder121.copyBufferToBuffer(buffer14, 312, buffer43, 2868, 324);
} catch {}
try {
commandEncoder121.copyTextureToBuffer({
  texture: texture40,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 64 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1328 */
  offset: 1328,
  bytesPerRow: 9728,
  rowsPerImage: 1717,
  buffer: buffer72,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder122 = device0.createCommandEncoder({});
let computePassEncoder112 = commandEncoder122.beginComputePass({});
try {
computePassEncoder48.setBindGroup(2, bindGroup30, new Uint32Array(4789), 149, 0);
} catch {}
try {
computePassEncoder110.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder6.setBindGroup(1, bindGroup32, new Uint32Array(533), 224, 0);
} catch {}
try {
commandEncoder121.copyBufferToTexture({
  /* bytesInLastRow: 1216 widthInBlocks: 76 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 976 */
  offset: 976,
  buffer: buffer16,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 10},
  aspect: 'all',
}, {width: 76, height: 0, depthOrArrayLayers: 1});
} catch {}
let buffer84 = device0.createBuffer({size: 35277, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE});
let commandEncoder123 = device0.createCommandEncoder({});
try {
computePassEncoder112.setPipeline(pipeline0);
} catch {}
try {
buffer40.unmap();
} catch {}
try {
commandEncoder123.copyTextureToBuffer({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 83, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 848 widthInBlocks: 53 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2976 */
  offset: 2976,
  buffer: buffer71,
}, {width: 53, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup64 = device0.createBindGroup({
  layout: bindGroupLayout9,
  entries: [{binding: 44, resource: {buffer: buffer3, offset: 256, size: 60}}],
});
let computePassEncoder113 = commandEncoder121.beginComputePass({});
try {
computePassEncoder11.setBindGroup(0, bindGroup13, new Uint32Array(1523), 106, 0);
} catch {}
let bindGroupLayout21 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 144,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let commandEncoder124 = device0.createCommandEncoder({});
let texture140 = device0.createTexture({
  size: [82, 1, 38],
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let externalTexture17 = device0.importExternalTexture({source: videoFrame15});
try {
computePassEncoder111.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder27.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder22.setBindGroup(2, bindGroup49, new Uint32Array(3309), 1_157, 0);
} catch {}
try {
renderPassEncoder19.setIndexBuffer(buffer50, 'uint32', 17_696, 6_760);
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(2, 114);
let textureView131 = texture140.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 4});
let texture141 = device0.createTexture({
  size: [16, 16, 12],
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView132 = texture37.createView({dimension: '3d', baseArrayLayer: 0});
try {
computePassEncoder7.setBindGroup(2, bindGroup41);
} catch {}
try {
computePassEncoder75.end();
} catch {}
try {
renderPassEncoder29.setBindGroup(1, bindGroup29);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder125 = device0.createCommandEncoder();
try {
computePassEncoder26.setBindGroup(3, bindGroup59);
} catch {}
try {
computePassEncoder109.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle2]);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(7, buffer28, 0, 709);
} catch {}
let gpuCanvasContext7 = offscreenCanvas0.getContext('webgpu');
let texture142 = device0.createTexture({
  label: '\u0271\u687d\u{1fde9}\u{1fa7a}\u4084\u0480\ude70\u051b\u4eff',
  size: {width: 129},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView133 = texture34.createView({baseArrayLayer: 0});
try {
computePassEncoder113.setPipeline(pipeline3);
} catch {}
try {
renderPassEncoder4.setScissorRect(67, 0, 55, 0);
} catch {}
let commandEncoder126 = device0.createCommandEncoder({});
let texture143 = gpuCanvasContext2.getCurrentTexture();
let renderBundleEncoder17 = device0.createRenderBundleEncoder({
  colorFormats: ['bgra8unorm-srgb'],
  depthStencilFormat: 'depth24plus',
  depthReadOnly: true,
  stencilReadOnly: false,
});
let renderBundle17 = renderBundleEncoder17.finish({});
try {
computePassEncoder11.setBindGroup(3, bindGroup44, new Uint32Array(4234), 237, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(4, buffer25, 0, 148);
} catch {}
try {
commandEncoder126.copyBufferToBuffer(buffer78, 1988, buffer74, 232, 64);
} catch {}
let buffer85 = device0.createBuffer({size: 20369, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM});
let commandBuffer3 = commandEncoder85.finish();
let textureView134 = texture140.createView({baseArrayLayer: 11, arrayLayerCount: 6});
let textureView135 = texture92.createView({});
try {
renderPassEncoder7.setIndexBuffer(buffer79, 'uint32', 8_056, 2);
} catch {}
try {
renderPassEncoder4.insertDebugMarker('\u1369');
} catch {}
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame6.close();
videoFrame7.close();
videoFrame8.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
videoFrame18.close();
}

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

  let workers = [

  ];
  let promises = [ window0(), window1(), window2() ];
  let results = await Promise.allSettled(promises);
  for (let result of results) {
    if (result.status === 'rejected') { throw result.reason; }
  }

  } catch (e) {

      if (e instanceof GPUPipelineError) {
      
    } else if (e instanceof DOMException) {
      if (e.name === 'OperationError') {
      
      } else if (e.name === 'InvalidStateError') {
      } else {
        
      }
    } else if (e instanceof GPUValidationError) {
      
    } else if (e instanceof GPUOutOfMemoryError) {
      
    } else if (e instanceof TypeError) {
      
    } else {
      
    }
  }
  debug('Pass')
    globalThis.testRunner?.notifyDone();
};
</script>