<style>
  :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; }
</style>
<script src="../../../resources/js-test-pre.js"></script>
<script>
globalThis.testRunner?.dumpAsText();
globalThis.testRunner?.waitUntilDone();

function log(s) {
}

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

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

/**
* @returns {Promise<HTMLVideoElement>}
*/
function videoWithData() {
  const veryBrightVideo = `data:video/mp4;base64,AAAAHGZ0eXBpc29tAAACAGlzb21pc28ybXA0MQAAAAhmcmVlAAAAvG1kYXQAAAAfTgEFGkdWStxcTEM/lO/FETzRQ6gD7gAA7gIAA3EYgAAAAEgoAa8iNjAkszOL+e58c//cEe//0TT//scp1n/381P/RWP/zOW4QtxorfVogeh8nQDbQAAAAwAQMCcWUTAAAAMAAAMAAAMA84AAAAAVAgHQAyu+KT35E7gAADFgAAADABLQAAAAEgIB4AiS76MTkNbgAAF3AAAPSAAAABICAeAEn8+hBOTXYAADUgAAHRAAAAPibW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAAAKcAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAw10cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAAAKcAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAABAAAAAQAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAACnAAAAAAABAAAAAAKFbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAABdwAAAD6BVxAAAAAAAMWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABDb3JlIE1lZGlhIFZpZGVvAAAAAixtaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAHsc3RibAAAARxzdHNkAAAAAAAAAAEAAAEMaHZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAQABAASAAAAEgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAAHVodmNDAQIgAAAAsAAAAAAAPPAA/P36+gAACwOgAAEAGEABDAH//wIgAAADALAAAAMAAAMAPBXAkKEAAQAmQgEBAiAAAAMAsAAAAwAAAwA8oBQgQcCTDLYgV7kWVYC1CRAJAICiAAEACUQBwChkuNBTJAAAAApmaWVsAQAAAAATY29scm5jbHgACQAQAAkAAAAAEHBhc3AAAAABAAAAAQAAABRidHJ0AAAAAAAALPwAACz8AAAAKHN0dHMAAAAAAAAAAwAAAAIAAAPoAAAAAQAAAAEAAAABAAAD6AAAABRzdHNzAAAAAAAAAAEAAAABAAAAEHNkdHAAAAAAIBAQGAAAAChjdHRzAAAAAAAAAAMAAAABAAAAAAAAAAEAAAfQAAAAAgAAAAAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAAQAAAABAAAAJHN0c3oAAAAAAAAAAAAAAAQAAABvAAAAGQAAABYAAAAWAAAAFHN0Y28AAAAAAAAAAQAAACwAAABhdWR0YQAAAFltZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAACxpbHN0AAAAJKl0b28AAAAcZGF0YQAAAAEAAAAATGF2ZjYwLjMuMTAw`;
  let video = document.createElement('video');
  video.src = veryBrightVideo;
  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;
}

onload = async () => {
  try {
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  label: '\ub764\u7ace\u{1fa99}\u0ce6',
  defaultQueue: {label: '\u{1f857}\u{1fccf}\u0699\u{1ff7e}\u0ffc\u{1f78c}\u488e\u7296'},
  requiredLimits: {
    maxStorageTexturesPerShaderStage: 4,
    minUniformBufferOffsetAlignment: 256,
    maxUniformBufferBindingSize: 175306349,
    maxStorageBufferBindingSize: 233297794,
  },
});
let texture0 = device0.createTexture({
  label: '\u{1f85e}\u936f\u4794\uc171\u{1f643}\u6074\u8957',
  size: [165, 120, 124],
  mipLevelCount: 2,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView0 = texture0.createView({
  label: '\u7476\ud57a\u2d44\u{1fda8}\u06f9\u2a91\u00c6\u01c9\u{1f9f1}\u0fab',
  dimension: '2d',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 79,
});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({
  label: '\u6b26\uaa2a',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let renderBundle0 = renderBundleEncoder0.finish({label: '\u7f8e\u{1fc6e}\u{1ffd9}\u99b2\u0cfc\u7422\uede1\u0830\u08de\ufc0d\ua497'});
let canvas0 = document.createElement('canvas');
let commandEncoder0 = device0.createCommandEncoder({label: '\u{1f879}\ucd75\u85f2\u6a9c\ufc5f\u6979\u0921\u313d\u040b\u7a08\u0c2d'});
let texture1 = device0.createTexture({
  size: {width: 330, height: 240, depthOrArrayLayers: 1627},
  mipLevelCount: 10,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba16uint'],
});
let commandBuffer0 = commandEncoder0.finish({label: '\u6304\ua7a9\u0922\u004a'});
let textureView1 = texture0.createView({label: '\u0c38\uce11\u3720\ub50e', dimension: '2d', baseMipLevel: 1, baseArrayLayer: 27});
let renderBundleEncoder1 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  sampleCount: 1,
  depthReadOnly: true,
});
let video0 = await videoWithData();
let bindGroupLayout0 = device0.createBindGroupLayout({
  label: '\u0b93\u{1f8b1}\u0a41\u{1ff86}\u{1fcaf}\u0939\u5a77\u8c8f\u8a53',
  entries: [
    {
      binding: 954,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let commandEncoder1 = device0.createCommandEncoder({label: '\u6d5c\ua4b1\u2359\u1cb4\u0edf\u0d60\u9b37'});
let renderBundle1 = renderBundleEncoder0.finish({label: '\u{1fab8}\ube79\u60e6\u02cd\uab15\u0b37\u{1fe63}\u512f\u{1fa57}\u{1f802}'});
let externalTexture0 = device0.importExternalTexture({label: '\u{1fb69}\u4739\u{1fc83}\uc255\ud3ad', source: video0, colorSpace: 'srgb'});
let video1 = await videoWithData();
let commandEncoder2 = device0.createCommandEncoder({});
let textureView2 = texture0.createView({label: '\u0255\u6e6b\u{1f6ff}\u{1ff29}\u08d9\u2eec\u32e8', baseArrayLayer: 115, arrayLayerCount: 5});
let externalTexture1 = device0.importExternalTexture({
  label: '\u03b2\u0862\u68a8\ub4ea\u9fc8\u0ca6\udc01\u{1f9ff}\u0ffe',
  source: video1,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder1.setVertexBuffer(4_294_967_295, undefined, 0, 506_429_834);
} catch {}
let pipelineLayout0 = device0.createPipelineLayout({
  label: '\u{1fd21}\ue2ce\u9495\ub372\u{1fed5}\u{1fa23}\u4766\ub41e\u{1ff72}',
  bindGroupLayouts: [bindGroupLayout0, bindGroupLayout0, bindGroupLayout0, bindGroupLayout0],
});
let textureView3 = texture1.createView({
  label: '\u967b\u0262\u{1fe52}\u112d\ucfbd\u0271\uc186\u126f\u036d\ufef1\u5b65',
  format: 'rgba16uint',
  baseMipLevel: 7,
  mipLevelCount: 2,
});
let gpuCanvasContext0 = canvas0.getContext('webgpu');
let querySet0 = device0.createQuerySet({label: '\u{1fa5f}\u{1f7f6}\u038a\uffc9\ufe3a\u2c4f\u1601', type: 'occlusion', count: 2164});
let commandBuffer1 = commandEncoder2.finish({});
let commandEncoder3 = device0.createCommandEncoder({});
let textureView4 = texture1.createView({aspect: 'all', baseMipLevel: 4, arrayLayerCount: 1});
let renderBundle2 = renderBundleEncoder1.finish({label: '\u{1fe1f}\u{1f970}\ue7c8\u52dc\ud5d7\u4a17'});
try {
adapter0.label = '\u{1fbc8}\u9c55\u0eca\u{1f69f}\u{1f85c}\u9765\u0996\u2a26\ue26d';
} catch {}
let shaderModule0 = device0.createShaderModule({
  code: `@group(3) @binding(954)
var<storage, read_write> local0: array<u32>;
@group(2) @binding(954)
var<storage, read_write> global0: array<u32>;
@group(1) @binding(954)
var<storage, read_write> type0: array<u32>;
@group(0) @binding(954)
var<storage, read_write> parameter0: array<u32>;

@compute @workgroup_size(1, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S0 {
  @location(0) f0: vec2<u32>,
  @location(7) f1: vec2<f16>,
  @location(1) f2: vec4<f16>
}
struct FragmentOutput0 {
  @location(2) f0: vec3<f32>,
  @location(4) f1: vec4<u32>,
  @location(0) f2: vec3<f32>,
  @location(3) f3: vec3<f32>
}

@fragment
fn fragment0(@location(15) a0: vec2<i32>, @location(8) a1: vec3<i32>, a2: S0, @builtin(sample_mask) a3: u32, @location(13) a4: vec4<i32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(15) f0: vec2<i32>,
  @location(7) f1: vec2<f16>,
  @location(8) f2: vec3<i32>,
  @location(1) f3: vec4<f16>,
  @builtin(position) f4: vec4<f32>,
  @location(0) f5: vec2<u32>,
  @location(13) f6: vec4<i32>
}

@vertex
fn vertex0(@location(14) a0: f16, @location(7) a1: vec2<i32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  hints: {},
});
let buffer0 = device0.createBuffer({
  size: 385447,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let textureView5 = texture0.createView({
  label: '\uc5b4\u{1fe23}\udf0b\u{1fd4c}\u{1f7d4}',
  dimension: '2d',
  baseArrayLayer: 46,
  arrayLayerCount: 1,
});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({
  label: '\u{1f887}\u0c54\u{1fc65}\u0efb\u{1fd97}\u2d06\u0879\u{1f932}\u18c8\u0e92',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle3 = renderBundleEncoder0.finish({});
let pipeline0 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}});
let imageBitmap0 = await createImageBitmap(video1);
let bindGroupLayout1 = device0.createBindGroupLayout({label: '\uedc4\ueeaa\u0877\u09c3\u03aa\u1126\u{1fa30}\u{1fa95}\u0499', entries: []});
let texture2 = device0.createTexture({
  label: '\ue741\u04d6\uc934',
  size: {width: 660, height: 480, depthOrArrayLayers: 106},
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView6 = texture2.createView({label: '\u3c26\u{1ffd4}\u02b0\u{1f839}\u2496', format: 'rg8unorm', baseMipLevel: 1, mipLevelCount: 5});
let renderBundle4 = renderBundleEncoder1.finish({});
try {
renderBundleEncoder2.setIndexBuffer(buffer0, 'uint16', 4_562, 19_878);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
commandEncoder3.resolveQuerySet(querySet0, 451, 143, buffer0, 26368);
} catch {}
try {
device0.queue.submit([commandBuffer0]);
} catch {}
gc();
let video2 = await videoWithData();
let commandBuffer2 = commandEncoder3.finish({label: '\u0fd8\ueb20\u6ae3\u{1fffa}\u38cd'});
let sampler0 = device0.createSampler({
  label: '\u3821\u021e\ua44d\u{1fe8d}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 97.17,
});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm'],
  colorSpace: 'display-p3',
});
} catch {}
let pipeline1 = await device0.createRenderPipelineAsync({
  label: '\u0402\u39ae\u3f62\u{1f8c5}\u{1f68c}\u{1fec0}',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one-minus-constant'},
  },
  writeMask: 0,
}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.RED,
}, {format: 'rgba16uint'}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {arrayStride: 0, attributes: []},
      {arrayStride: 220, attributes: []},
      {arrayStride: 188, stepMode: 'instance', attributes: []},
      {arrayStride: 184, attributes: []},
      {arrayStride: 344, attributes: []},
      {arrayStride: 548, attributes: []},
      {arrayStride: 116, attributes: []},
      {
        arrayStride: 68,
        stepMode: 'vertex',
        attributes: [
          {format: 'unorm8x4', offset: 4, shaderLocation: 14},
          {format: 'sint16x4', offset: 4, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
let promise0 = device0.popErrorScope();
try {
buffer0.destroy();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 41, height: 30, depthOrArrayLayers: 6}
*/
{
  source: video1,
  origin: { x: 8, y: 0 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 4,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 7, depthOrArrayLayers: 0});
} catch {}
let pipeline2 = await device0.createComputePipelineAsync({
  label: '\u8f9a\u{1fd21}',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let imageData0 = new ImageData(60, 88);
let bindGroup0 = device0.createBindGroup({
  label: '\u{1f793}\u05c3\u{1fbd6}\u0993\u689b\u{1f676}\u{1fcd4}\u{1f86d}\u{1f879}',
  layout: bindGroupLayout1,
  entries: [],
});
let commandEncoder4 = device0.createCommandEncoder({label: '\u0efa\ufdfe\u{1f85d}\u{1f6d2}\u{1fae6}\ua269\u0290\u93d5\u{1fcd0}\u{1ff07}\u0358'});
let textureView7 = texture0.createView({
  label: '\uca51\ud3e0\u{1f8dc}',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 23,
  arrayLayerCount: 36,
});
let computePassEncoder0 = commandEncoder1.beginComputePass({label: '\u0627\u{1ff75}\u09b6\u0d40\u70fe\ua88a'});
try {
renderBundleEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(6417), 1089, 0);
} catch {}
let pipeline3 = await device0.createComputePipelineAsync({
  label: '\u2dc5\u0675\u{1f643}',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandBuffer3 = commandEncoder4.finish({label: '\u0b2a\u06ae\u0e04'});
let sampler1 = device0.createSampler({
  label: '\u{1f742}\u6a59\u4f51\u0dac\u0528\u05d1\u0c31\u17ab',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 7,
});
try {
renderBundleEncoder2.setPipeline(pipeline1);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
  await promise0;
} catch {}
let commandEncoder5 = device0.createCommandEncoder({label: '\u7489\u8a7a\u{1fd5a}\u39f1\ubdbe\u7393'});
let textureView8 = texture1.createView({mipLevelCount: 3});
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let video3 = await videoWithData();
let imageData1 = new ImageData(76, 200);
let commandEncoder6 = device0.createCommandEncoder({label: '\ue28b\u0eca\ucfd8\u030c\u0598\u022f\u850f'});
let querySet1 = device0.createQuerySet({label: '\u32b2\u0344\u{1f63f}\u0392\u{1f7cf}\u0b3f', type: 'occlusion', count: 1103});
let textureView9 = texture2.createView({label: '\u05f5\u882b\u073f\u{1f8d6}\u05c2\ue8c7', dimension: '3d', baseMipLevel: 2, mipLevelCount: 3});
let externalTexture2 = device0.importExternalTexture({
  label: '\uf378\u011b\u0d6d\u3365\u0402\uacdc\u{1fcdd}\u0e6d\u885c',
  source: video2,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder2.setBindGroup(1, bindGroup0);
} catch {}
try {
commandEncoder6.resolveQuerySet(querySet0, 1802, 44, buffer0, 1792);
} catch {}
gc();
let adapter1 = await navigator.gpu.requestAdapter({});
let shaderModule1 = device0.createShaderModule({
  label: '\u8d76\u{1f609}\u{1fb06}\ua773',
  code: `@group(0) @binding(954)
var<storage, read_write> n0: array<u32>;
@group(2) @binding(954)
var<storage, read_write> field0: array<u32>;
@group(1) @binding(954)
var<storage, read_write> local1: array<u32>;

@compute @workgroup_size(4, 4, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S2 {
  @location(3) f0: vec2<f32>,
  @location(4) f1: vec4<f16>
}
struct FragmentOutput0 {
  @location(2) f0: vec3<f32>,
  @location(4) f1: vec4<u32>,
  @location(0) f2: vec3<f32>,
  @location(3) f3: vec3<f32>,
  @location(1) f4: vec4<f32>
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32, @location(1) a1: u32, @location(14) a2: vec4<f32>, @location(0) a3: vec4<f16>, @location(2) a4: vec2<i32>, a5: S2, @builtin(front_facing) a6: bool, @builtin(position) a7: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S1 {
  @location(0) f0: vec3<f16>,
  @location(13) f1: vec3<i32>,
  @builtin(vertex_index) f2: u32,
  @location(4) f3: vec4<i32>,
  @location(11) f4: vec4<i32>,
  @location(2) f5: vec4<i32>,
  @location(8) f6: vec4<f16>,
  @location(6) f7: vec2<i32>,
  @location(9) f8: vec3<f32>,
  @location(1) f9: vec3<f32>,
  @location(12) f10: vec4<u32>
}
struct VertexOutput0 {
  @location(4) f7: vec4<f16>,
  @location(14) f8: vec4<f32>,
  @location(3) f9: vec2<f32>,
  @builtin(position) f10: vec4<f32>,
  @location(1) f11: u32,
  @location(2) f12: vec2<i32>,
  @location(0) f13: vec4<f16>
}

@vertex
fn vertex0(@location(5) a0: vec2<f32>, @location(7) a1: i32, @location(14) a2: vec4<i32>, @location(3) a3: vec2<u32>, a4: S1, @location(10) a5: vec3<f16>, @location(15) a6: i32, @builtin(instance_index) a7: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let externalTexture3 = device0.importExternalTexture({source: video3, colorSpace: 'display-p3'});
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
let bindGroupLayout2 = device0.createBindGroupLayout({label: '\u{1fbff}\u256c', entries: []});
let commandEncoder7 = device0.createCommandEncoder({label: '\uff95\u07d6\u0723'});
let querySet2 = device0.createQuerySet({label: '\u{1f88b}\u2ba7', type: 'occlusion', count: 134});
let textureView10 = texture2.createView({
  label: '\u7048\u{1fb4b}\u3736\u{1f86e}\uc1f1\u0514',
  format: 'rg8unorm',
  baseMipLevel: 0,
  mipLevelCount: 1,
});
try {
computePassEncoder0.setBindGroup(0, bindGroup0, new Uint32Array(9198), 2290, 0);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder2.setIndexBuffer(buffer0, 'uint16', 11_460, 78_926);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 53}
*/
{
  source: imageBitmap0,
  origin: { x: 1, y: 5 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 42, y: 70, z: 5},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandEncoder8 = device0.createCommandEncoder();
let computePassEncoder1 = commandEncoder5.beginComputePass({label: '\u{1fbfd}\ud369\u06e4\u0f33\u16bf\ube0e\u0c2b\u0920\u8727\u01a8'});
let sampler2 = device0.createSampler({
  label: '\u7eac\ucc98\u{1f646}\u{1f93b}\u231a\u6d11',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 83.43,
  maxAnisotropy: 20,
});
try {
renderBundleEncoder2.setVertexBuffer(6, undefined);
} catch {}
try {
commandEncoder8.resolveQuerySet(querySet2, 17, 32, buffer0, 84992);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(16), /* required buffer size: 254_175 */
{offset: 305, bytesPerRow: 228, rowsPerImage: 151}, {width: 53, height: 57, depthOrArrayLayers: 8});
} catch {}
let pipeline4 = await device0.createRenderPipelineAsync({
  label: '\u{1faa9}\u{1feda}\u0804\u085a',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'constant', dstFactor: 'constant'},
  },
  writeMask: 0,
}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.RED}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilFront: {compare: 'always', failOp: 'zero', depthFailOp: 'replace', passOp: 'decrement-wrap'},
    stencilBack: {failOp: 'invert', depthFailOp: 'invert', passOp: 'replace'},
    stencilReadMask: 2809083598,
    stencilWriteMask: 2121669782,
    depthBias: 0,
    depthBiasSlopeScale: 677.7471262965878,
  },
  vertex: {
    module: shaderModule0,
    constants: {},
    buffers: [
      {arrayStride: 468, stepMode: 'vertex', attributes: []},
      {arrayStride: 256, stepMode: 'instance', attributes: []},
      {arrayStride: 192, attributes: []},
      {arrayStride: 204, attributes: []},
      {arrayStride: 36, attributes: []},
      {arrayStride: 128, attributes: []},
      {arrayStride: 348, stepMode: 'instance', attributes: []},
      {
        arrayStride: 124,
        attributes: [
          {format: 'float32x4', offset: 0, shaderLocation: 14},
          {format: 'sint32x2', offset: 16, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'back'},
});
let promise1 = adapter0.requestAdapterInfo();
let shaderModule2 = device0.createShaderModule({
  label: '\u8946\u9fdc\u{1fe81}\uc425',
  code: `@group(3) @binding(954)
var<storage, read_write> field1: array<u32>;
@group(1) @binding(954)
var<storage, read_write> parameter1: array<u32>;
@group(0) @binding(954)
var<storage, read_write> n1: array<u32>;
@group(2) @binding(954)
var<storage, read_write> parameter2: array<u32>;

@compute @workgroup_size(7, 3, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S3 {
  @location(13) f0: vec2<f16>,
  @location(4) f1: u32,
  @location(5) f2: vec2<i32>,
  @location(6) f3: u32,
  @location(15) f4: vec4<f32>,
  @location(8) f5: f16,
  @location(11) f6: vec4<f16>,
  @location(2) f7: vec2<f32>,
  @location(14) f8: vec3<f16>,
  @location(12) f9: vec3<f16>,
  @location(1) f10: vec4<i32>,
  @location(10) f11: i32,
  @location(9) f12: vec4<f32>,
  @location(0) f13: f16,
  @location(7) f14: vec2<f32>
}
struct FragmentOutput0 {
  @location(1) f0: vec4<i32>,
  @location(0) f1: vec4<f32>,
  @location(4) f2: vec2<u32>,
  @location(2) f3: vec4<f32>,
  @location(5) f4: vec4<f32>,
  @location(3) f5: vec3<u32>
}

@fragment
fn fragment0(a0: S3, @builtin(sample_index) a1: u32, @builtin(front_facing) a2: bool, @builtin(sample_mask) a3: u32, @builtin(position) a4: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(1) f14: vec4<i32>,
  @location(6) f15: u32,
  @location(14) f16: vec3<f16>,
  @location(7) f17: vec2<f32>,
  @location(0) f18: f16,
  @builtin(position) f19: vec4<f32>,
  @location(11) f20: vec4<f16>,
  @location(15) f21: vec4<f32>,
  @location(10) f22: i32,
  @location(9) f23: vec4<f32>,
  @location(5) f24: vec2<i32>,
  @location(4) f25: u32,
  @location(8) f26: f16,
  @location(12) f27: vec3<f16>,
  @location(13) f28: vec2<f16>,
  @location(2) f29: vec2<f32>
}

@vertex
fn vertex0(@location(13) a0: vec4<u32>, @builtin(instance_index) a1: u32, @location(4) a2: i32, @builtin(vertex_index) a3: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder9 = device0.createCommandEncoder({label: '\u265d\ua785\uc230\u42eb\u0804'});
let textureView11 = texture2.createView({
  label: '\u{1f950}\u059c\u42c0\uf7fe\ucf31\u8571\u{1f8db}\u74dc\u{1fda6}',
  aspect: 'all',
  mipLevelCount: 2,
});
let computePassEncoder2 = commandEncoder9.beginComputePass({});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({
  label: '\u9489\ue7fc',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
});
let externalTexture4 = device0.importExternalTexture({label: '\u09ac\u9519\uded6\ue197\u{1fe5b}\u1a2a', source: video0, colorSpace: 'srgb'});
try {
renderBundleEncoder3.setBindGroup(0, bindGroup0);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 53}
*/
{
  source: canvas0,
  origin: { x: 16, y: 22 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 54, y: 4, z: 19},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 40, height: 8, depthOrArrayLayers: 0});
} catch {}
let pipeline5 = await device0.createRenderPipelineAsync({
  label: '\u{1fe71}\u{1ff04}\u70af\uee06',
  layout: pipelineLayout0,
  multisample: {count: 4, mask: 0x3a663122},
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'constant'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.GREEN}, {format: 'rg16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rgba16uint', writeMask: GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'never',
    stencilFront: {compare: 'not-equal', failOp: 'decrement-clamp', depthFailOp: 'replace', passOp: 'replace'},
    stencilBack: {compare: 'never', failOp: 'increment-clamp', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'},
    stencilReadMask: 1124851915,
    stencilWriteMask: 3589126873,
  },
  vertex: {
    module: shaderModule1,
    buffers: [
      {arrayStride: 0, stepMode: 'vertex', attributes: [{format: 'sint32', offset: 60, shaderLocation: 7}]},
      {
        arrayStride: 340,
        stepMode: 'instance',
        attributes: [{format: 'sint32x2', offset: 24, shaderLocation: 11}],
      },
      {arrayStride: 24, stepMode: 'instance', attributes: []},
      {arrayStride: 16, attributes: []},
      {
        arrayStride: 20,
        attributes: [{format: 'sint8x2', offset: 4, shaderLocation: 13}, {format: 'sint32x2', offset: 0, shaderLocation: 4}],
      },
      {
        arrayStride: 140,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 0, shaderLocation: 5},
          {format: 'float16x4', offset: 12, shaderLocation: 0},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 9},
          {format: 'snorm16x4', offset: 8, shaderLocation: 8},
        ],
      },
      {arrayStride: 216, stepMode: 'instance', attributes: []},
      {
        arrayStride: 1308,
        attributes: [
          {format: 'float16x4', offset: 188, shaderLocation: 1},
          {format: 'unorm8x4', offset: 316, shaderLocation: 10},
          {format: 'uint32', offset: 16, shaderLocation: 3},
          {format: 'uint32', offset: 148, shaderLocation: 12},
          {format: 'sint16x2', offset: 176, shaderLocation: 2},
          {format: 'sint8x4', offset: 320, shaderLocation: 6},
          {format: 'sint32x2', offset: 76, shaderLocation: 14},
          {format: 'sint16x2', offset: 424, shaderLocation: 15},
        ],
      },
    ],
  },
});
let img0 = await imageWithData(7, 57, '#75fd43ea', '#08fee24b');
let bindGroup1 = device0.createBindGroup({label: '\u51e1\u0fb3\uc973\u{1fc5e}\u0e21\u0f0c\u37c7\u067c', layout: bindGroupLayout2, entries: []});
let renderBundle5 = renderBundleEncoder2.finish({});
try {
commandEncoder7.resolveQuerySet(querySet2, 5, 15, buffer0, 3072);
} catch {}
let textureView12 = texture0.createView({label: '\u53fc\u26c2\u421c\u1b8a\u0ec1\u06a9', baseArrayLayer: 14, arrayLayerCount: 84});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({
  label: '\u06de\u0f84\u00d0\ubd40\u{1fe2d}\u752e',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(2620), 1445, 0);
} catch {}
try {
renderBundleEncoder3.setBindGroup(3, bindGroup0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 6,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, new Float32Array(new ArrayBuffer(8)), /* required buffer size: 748 */
{offset: 732, bytesPerRow: 17, rowsPerImage: 95}, {width: 8, height: 1, depthOrArrayLayers: 1});
} catch {}
let imageBitmap1 = await createImageBitmap(video0);
let bindGroupLayout3 = device0.createBindGroupLayout({label: '\u0617\u0b96\uf38c\u26a7\u43cd\u028d\u01e3\u4156\u007f\u01fe\ucd76', entries: []});
try {
renderBundleEncoder4.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(4_294_967_295, undefined, 0, 1_125_442_236);
} catch {}
try {
buffer0.destroy();
} catch {}
let commandEncoder10 = device0.createCommandEncoder({label: '\u{1f97f}\ue41f\u0e70\ufcd2\u{1ff9b}\u80c7'});
try {
renderBundleEncoder3.setVertexBuffer(5, undefined);
} catch {}
try {
querySet0.destroy();
} catch {}
try {
computePassEncoder0.insertDebugMarker('\u{1f76e}');
} catch {}
let texture3 = device0.createTexture({
  size: [1320],
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['r16float'],
});
let textureView13 = texture3.createView({});
try {
renderBundleEncoder3.setBindGroup(2, bindGroup0, new Uint32Array(5923), 3154, 0);
} catch {}
let pipeline6 = await device0.createComputePipelineAsync({
  label: '\ucb5f\u8d92\ue7bc\u055f\u08ac\udb0f\u{1fb25}',
  layout: pipelineLayout0,
  compute: {module: shaderModule1, entryPoint: 'compute0'},
});
let buffer1 = device0.createBuffer({
  label: '\u3838\u4b64\ue4d8\u668b\u00a8\u{1ffca}\ub235\ua988\u1970',
  size: 319684,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: true,
});
let commandEncoder11 = device0.createCommandEncoder({});
let renderBundle6 = renderBundleEncoder4.finish();
let sampler3 = device0.createSampler({
  label: '\u0014\u0466\u0d9b\u{1f668}\u6c63\u{1f7b5}\u{1fd77}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 17.29,
  lodMaxClamp: 80.13,
  compare: 'greater',
  maxAnisotropy: 15,
});
try {
computePassEncoder1.setBindGroup(3, bindGroup0);
} catch {}
try {
commandEncoder10.clearBuffer(buffer1);
} catch {}
try {
commandEncoder8.resolveQuerySet(querySet2, 17, 8, buffer1, 19712);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 53}
*/
{
  source: video2,
  origin: { x: 2, y: 5 },
  flipY: true,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 12, y: 121, z: 8},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 2, depthOrArrayLayers: 0});
} catch {}
let pipeline7 = device0.createComputePipeline({
  label: '\udbb5\ue563\u1a37\ud8eb\u9d29\u62ab\u0f2f\udc67',
  layout: pipelineLayout0,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let shaderModule3 = device0.createShaderModule({
  label: '\u0ecc\u862a\ucedb\u097a\u0bf8\u{1fcb1}\u0762\u0f9b\ucaca\u4e45',
  code: `@group(2) @binding(954)
var<storage, read_write> type1: array<u32>;
@group(1) @binding(954)
var<storage, read_write> parameter3: array<u32>;
@group(0) @binding(954)
var<storage, read_write> local2: array<u32>;

@compute @workgroup_size(2, 3, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<f32>,
  @location(5) f1: vec3<i32>,
  @location(3) f2: vec4<f32>,
  @location(2) f3: vec2<f32>,
  @location(4) f4: vec4<u32>
}

@fragment
fn fragment0(@location(15) a0: vec4<i32>, @location(1) a1: vec4<f16>, @location(2) a2: vec2<u32>, @location(7) a3: vec4<f16>, @location(6) a4: vec4<f16>, @location(10) a5: i32, @location(11) a6: f32, @location(0) a7: f16, @location(9) a8: f16) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @builtin(position) f30: vec4<f32>,
  @location(10) f31: i32,
  @location(9) f32: f16,
  @location(15) f33: vec4<i32>,
  @location(0) f34: f16,
  @location(11) f35: f32,
  @location(7) f36: vec4<f16>,
  @location(1) f37: vec4<f16>,
  @location(6) f38: vec4<f16>,
  @location(2) f39: vec2<u32>
}

@vertex
fn vertex0(@location(5) a0: vec3<u32>, @location(7) a1: vec2<f16>, @location(13) a2: vec4<f32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout4 = device0.createBindGroupLayout({
  label: '\u5a82\u03a5\u15cb\u4c19\u07d0\u7b1a\u00bd\u9a20',
  entries: [
    {
      binding: 416,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 803,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' },
    },
  ],
});
let bindGroup2 = device0.createBindGroup({label: '\u{1fa7f}\u0367\u0466', layout: bindGroupLayout3, entries: []});
let texture4 = device0.createTexture({
  label: '\u09e9\u78dd\u6a3b',
  size: [165, 120, 124],
  mipLevelCount: 6,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder2.end();
} catch {}
try {
computePassEncoder1.setPipeline(pipeline2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 2,
  origin: {x: 17, y: 2, z: 0},
  aspect: 'all',
}, new ArrayBuffer(32), /* required buffer size: 17_710 */
{offset: 310, bytesPerRow: 391, rowsPerImage: 8}, {width: 98, height: 5, depthOrArrayLayers: 6});
} catch {}
try {
adapter1.label = '\u054f\u{1f6af}\u5d03\u32f9\u38c6';
} catch {}
let pipelineLayout1 = device0.createPipelineLayout({
  label: '\uc635\u{1fb8c}\ua257\u6390',
  bindGroupLayouts: [bindGroupLayout0, bindGroupLayout4, bindGroupLayout2],
});
let commandBuffer4 = commandEncoder7.finish({label: '\u63c8\u0ecb'});
let sampler4 = device0.createSampler({
  label: '\u{1fdf8}\u{1fc27}\u60a2\u1c04\u{1fef5}',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 70.09,
  lodMaxClamp: 79.59,
  maxAnisotropy: 6,
});
try {
computePassEncoder0.setBindGroup(0, bindGroup0);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup1);
} catch {}
gc();
let img1 = await imageWithData(154, 241, '#67bf127d', '#db60f657');
let texture5 = device0.createTexture({
  size: {width: 660, height: 480, depthOrArrayLayers: 124},
  mipLevelCount: 9,
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'],
});
let textureView14 = texture3.createView({});
let computePassEncoder3 = commandEncoder8.beginComputePass({label: '\u{1fafa}\u0161\u5924\u2225\u0b71\u5896\u44c2\ub64d\ubefa'});
let sampler5 = device0.createSampler({
  label: '\u0763\ua507\ubaac',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 64.90,
  lodMaxClamp: 95.17,
});
try {
computePassEncoder0.setBindGroup(0, bindGroup2);
} catch {}
let renderBundleEncoder5 = device0.createRenderBundleEncoder({
  label: '\u308f\uc974\u{1ff15}\u{1fce6}\u{1f863}\u0547',
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  sampleCount: 1,
  depthReadOnly: true,
});
try {
commandEncoder9.clearBuffer(buffer1, 9584);
} catch {}
let imageData2 = new ImageData(76, 52);
let commandEncoder12 = device0.createCommandEncoder({label: '\u1258\u0ef8\u0a6a\u4b72\ue717\u517a\u9b11'});
let querySet3 = device0.createQuerySet({label: '\udeb6\ua497\u3531', type: 'occlusion', count: 2025});
let textureView15 = texture1.createView({label: '\u{1fe4c}\u{1f64f}', aspect: 'all', baseMipLevel: 3, mipLevelCount: 3});
let computePassEncoder4 = commandEncoder12.beginComputePass();
let renderBundleEncoder6 = device0.createRenderBundleEncoder({
  label: '\u154f\u{1f698}\u9824\u015d\ua986',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  sampleCount: 1,
  stencilReadOnly: true,
});
let externalTexture5 = device0.importExternalTexture({label: '\u1eae\u1ed6', source: video2, colorSpace: 'srgb'});
try {
computePassEncoder4.end();
} catch {}
try {
renderBundleEncoder5.setBindGroup(2, bindGroup0, new Uint32Array(512), 59, 0);
} catch {}
try {
renderBundleEncoder6.setIndexBuffer(buffer0, 'uint16', 21_624, 4_092);
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
let promise3 = device0.createRenderPipelineAsync({
  label: '\uc703\u6cc9\u0b49\u0a64\uf94a\u4992\ua8bf\u0b0e',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'rg16float', writeMask: GPUColorWrite.GREEN}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 64,
        attributes: [
          {format: 'unorm16x4', offset: 4, shaderLocation: 7},
          {format: 'uint32x4', offset: 8, shaderLocation: 5},
        ],
      },
      {arrayStride: 36, attributes: []},
      {arrayStride: 540, stepMode: 'instance', attributes: []},
      {arrayStride: 336, attributes: []},
      {arrayStride: 724, stepMode: 'instance', attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 116, attributes: []},
      {
        arrayStride: 168,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x4', offset: 24, shaderLocation: 13}],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'ccw'},
});
try {
  await promise1;
} catch {}
let renderBundle7 = renderBundleEncoder6.finish();
try {
computePassEncoder3.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder5.setBindGroup(1, bindGroup2);
} catch {}
try {
commandEncoder12.clearBuffer(buffer1);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb'],
  alphaMode: 'opaque',
});
} catch {}
try {
  await promise2;
} catch {}
let computePassEncoder5 = commandEncoder11.beginComputePass({label: '\u{1fec1}\u0e1f\u0158\ue84f\u3905\u069a'});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({
  label: '\u0960\u024c\u3c8a\u065c\u04a0\u7c3e\u08b7\u{1fc8a}\uf20c\udace',
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
});
let renderBundle8 = renderBundleEncoder0.finish({label: '\u436a\u0dc6'});
let sampler6 = device0.createSampler({
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 11.86,
  lodMaxClamp: 64.17,
  maxAnisotropy: 14,
});
try {
commandEncoder10.clearBuffer(buffer1);
} catch {}
let commandEncoder13 = device0.createCommandEncoder({label: '\u0753\u{1fc45}\ue830\u{1fe25}\uda6b\ubc4b\ua05f\ucaee\u7d38\u5076\u{1febb}'});
let textureView16 = texture2.createView({label: '\u64c2\u4f3c\u{1fbae}\udae7', mipLevelCount: 3});
let computePassEncoder6 = commandEncoder13.beginComputePass({label: '\ubf06\uca6f\uac76\u087c\u0b97'});
try {
renderBundleEncoder7.setBindGroup(0, bindGroup1, []);
} catch {}
try {
renderBundleEncoder7.setIndexBuffer(buffer0, 'uint32', 122_076, 62_012);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(4_294_967_295, undefined, 0, 1_120_522_402);
} catch {}
let pipeline8 = device0.createComputePipeline({
  label: '\u{1f7ce}\u0b64\u0fac\ucea2\u{1f7cf}',
  layout: pipelineLayout1,
  compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}},
});
let pipeline9 = device0.createRenderPipeline({
  label: '\u8fc2\u07f8\ua97f\u4499\ucb0c\u05e2',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16float', writeMask: 0}, {
  format: 'rgba8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rg16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgb10a2unorm'}],
},
  vertex: {
    module: shaderModule2,
    buffers: [
      {arrayStride: 0, attributes: []},
      {arrayStride: 832, stepMode: 'vertex', attributes: []},
      {arrayStride: 28, attributes: []},
      {arrayStride: 76, stepMode: 'instance', attributes: []},
      {arrayStride: 20, attributes: []},
      {arrayStride: 172, attributes: []},
      {arrayStride: 496, attributes: []},
      {
        arrayStride: 172,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 32, shaderLocation: 13},
          {format: 'sint32x3', offset: 44, shaderLocation: 4},
        ],
      },
    ],
  },
});
let imageData3 = new ImageData(120, 24);
let texture6 = device0.createTexture({
  label: '\ub4aa\u3756\u7826',
  size: {width: 330, height: 240, depthOrArrayLayers: 124},
  mipLevelCount: 9,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16uint', 'rgba16uint', 'rgba16uint'],
});
let textureView17 = texture6.createView({
  label: '\u{1fde1}\u8e77\u1151\u0a40\u48bb\u0f40',
  baseMipLevel: 6,
  baseArrayLayer: 19,
  arrayLayerCount: 62,
});
try {
computePassEncoder3.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder7.setBindGroup(0, bindGroup2, []);
} catch {}
try {
buffer0.unmap();
} catch {}
let pipeline10 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule2, entryPoint: 'compute0'}});
let textureView18 = texture6.createView({
  label: '\ufeb7\u04eb\u8961\u{1fd30}\u6ec3\u91f1\u0cd2\u84da\uc1d8\u8752\u010c',
  mipLevelCount: 6,
  baseArrayLayer: 123,
});
let renderBundle9 = renderBundleEncoder4.finish({});
let externalTexture6 = device0.importExternalTexture({
  label: '\u09a5\u{1f94c}\u0f9f\ub2b9\ua320\u1e80\u{1f7d4}\u6032\u3a0b\u6345\u223d',
  source: video1,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder5.setBindGroup(1, bindGroup0, new Uint32Array(2238), 202, 0);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline9);
} catch {}
try {
computePassEncoder6.insertDebugMarker('\u0110');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 13}
*/
{
  source: imageData0,
  origin: { x: 6, y: 12 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 3,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 20, height: 20, depthOrArrayLayers: 0});
} catch {}
let pipeline11 = device0.createRenderPipeline({
  label: '\u0c20\u6fc9\ue768\u{1ff4a}\u{1fcf1}\ua95e\u5b78\u4abb\u00cb\u7196',
  layout: pipelineLayout0,
  multisample: {count: 4},
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'src'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-src'},
  },
  writeMask: GPUColorWrite.ALPHA,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {compare: 'less', failOp: 'zero', depthFailOp: 'increment-wrap', passOp: 'replace'},
    stencilBack: {compare: 'not-equal', failOp: 'replace', passOp: 'keep'},
    stencilReadMask: 4242611015,
    stencilWriteMask: 1723160738,
    depthBiasSlopeScale: 675.3912497097724,
  },
  vertex: {
    module: shaderModule3,
    buffers: [
      {arrayStride: 560, stepMode: 'instance', attributes: []},
      {arrayStride: 1388, stepMode: 'instance', attributes: []},
      {arrayStride: 204, stepMode: 'instance', attributes: []},
      {arrayStride: 228, attributes: []},
      {arrayStride: 220, attributes: []},
      {arrayStride: 628, stepMode: 'instance', attributes: []},
      {arrayStride: 120, attributes: []},
      {
        arrayStride: 268,
        attributes: [
          {format: 'uint32', offset: 16, shaderLocation: 5},
          {format: 'snorm8x2', offset: 2, shaderLocation: 13},
          {format: 'float16x4', offset: 36, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let canvas1 = document.createElement('canvas');
let buffer2 = device0.createBuffer({
  label: '\u9cf2\u3aeb\u0958\u5ffa\u652a\u{1fddf}\u{1f955}\u0454\udd31',
  size: 145819,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder14 = device0.createCommandEncoder({});
let textureView19 = texture6.createView({
  label: '\u0be7\uffa7\u055c\u0d9d\uda5e\u0288\udf77\u09b2\u332f\u13b2',
  dimension: '2d',
  baseMipLevel: 5,
  mipLevelCount: 3,
  baseArrayLayer: 56,
});
let sampler7 = device0.createSampler({
  label: '\udb9f\ub599\u0df3\u32e0\ud625\u04bc\u6abc\u6e6f\u0171',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 74.34,
  compare: 'equal',
});
let externalTexture7 = device0.importExternalTexture({label: '\uc9c9\u{1ffb3}\u6c7e\u0132\u8a16\u8d1b\u3b77\u72b6', source: video2, colorSpace: 'srgb'});
try {
renderBundleEncoder7.setIndexBuffer(buffer0, 'uint16', 62_032, 54_036);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline9);
} catch {}
let promise4 = buffer2.mapAsync(GPUMapMode.READ, 0, 84176);
try {
commandEncoder9.clearBuffer(buffer1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 5,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
}, new Int8Array(new ArrayBuffer(32)), /* required buffer size: 6_660 */
{offset: 696, bytesPerRow: 142, rowsPerImage: 42}, {width: 9, height: 0, depthOrArrayLayers: 2});
} catch {}
canvas1.width = 326;
let canvas2 = document.createElement('canvas');
let imageData4 = new ImageData(236, 180);
try {
canvas1.getContext('webgpu');
} catch {}
let bindGroupLayout5 = device0.createBindGroupLayout({label: '\u{1f9cf}\u{1feee}\u0070\u27bb\u{1fbb0}', entries: []});
let commandEncoder15 = device0.createCommandEncoder({label: '\u{1f67c}\ub636\u0394\u{1fb9c}\u0ebc'});
let renderBundleEncoder8 = device0.createRenderBundleEncoder({
  label: '\u3867\u1e6c\u{1f859}\u02ed\u2adf\u773a\u5232\ubcdf\u4fec\u{1fcb3}\u7886',
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder6.setPipeline(pipeline10);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
let arrayBuffer0 = buffer1.getMappedRange();
try {
commandEncoder15.resolveQuerySet(querySet1, 134, 64, buffer1, 3328);
} catch {}
let gpuCanvasContext1 = canvas2.getContext('webgpu');
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
try {
commandEncoder9.copyTextureToTexture({
  texture: texture1,
  mipLevel: 4,
  origin: {x: 4, y: 2, z: 16},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 6,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
  await promise4;
} catch {}
let videoFrame0 = new VideoFrame(img1, {timestamp: 0});
let bindGroup3 = device0.createBindGroup({
  label: '\uaeb3\u0804\u83f8\u929b\uea95\ud2b2\u{1f787}\u01ed\u65f5\u2b3d',
  layout: bindGroupLayout5,
  entries: [],
});
let commandEncoder16 = device0.createCommandEncoder({});
let sampler8 = device0.createSampler({
  label: '\ud71f\uc527\u6379\u80f2\ucb74\u0716\u0910',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 45.22,
  lodMaxClamp: 74.65,
  maxAnisotropy: 16,
});
try {
computePassEncoder3.setBindGroup(3, bindGroup1, new Uint32Array(4221), 3257, 0);
} catch {}
try {
commandEncoder14.clearBuffer(buffer2, 116908, 10848);
} catch {}
let pipeline12 = device0.createComputePipeline({
  label: '\u3313\u0d28\u3a94\u0a86\u0f95',
  layout: pipelineLayout0,
  compute: {module: shaderModule1, entryPoint: 'compute0'},
});
let commandBuffer5 = commandEncoder12.finish({label: '\ubd23\u{1f99d}'});
let textureView20 = texture2.createView({label: '\u02c3\u0268\u424f\u{1fa5a}\u078e\u01ab\u{1f9f7}', baseMipLevel: 3, mipLevelCount: 2});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  stencilReadOnly: true,
});
let externalTexture8 = device0.importExternalTexture({
  label: '\u8ed2\u0a5a\uf076\u4c79\u9586\ucc8a\u0232\ud4b8\u9dc8\u0923\u{1fc8a}',
  source: videoFrame0,
  colorSpace: 'display-p3',
});
try {
commandEncoder10.copyBufferToBuffer(buffer1, 82400, buffer2, 133704, 10328);
} catch {}
try {
commandEncoder9.copyTextureToTexture({
  texture: texture4,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 7},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 2,
  origin: {x: 4, y: 4, z: 0},
  aspect: 'all',
},
{width: 19, height: 14, depthOrArrayLayers: 26});
} catch {}
try {
commandEncoder15.clearBuffer(buffer1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 4, y: 6, z: 44},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 1_062_284 */
{offset: 929, bytesPerRow: 2057, rowsPerImage: 327}, {width: 250, height: 189, depthOrArrayLayers: 2});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 10, height: 7, depthOrArrayLayers: 1}
*/
{
  source: canvas0,
  origin: { x: 13, y: 6 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 6,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap2 = await createImageBitmap(video2);
let pipelineLayout2 = device0.createPipelineLayout({
  label: '\ue363\u1533\u080b\u{1fc25}\u{1fdd9}\ub2dc\u0715\u0148\u0d7c',
  bindGroupLayouts: [bindGroupLayout2, bindGroupLayout0, bindGroupLayout1, bindGroupLayout5],
});
let querySet4 = device0.createQuerySet({label: '\uc4fa\u{1fa35}\u095e\u0559', type: 'occlusion', count: 1389});
try {
renderBundleEncoder9.setBindGroup(3, bindGroup3);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer0, 'uint32', 556, 11_443);
} catch {}
try {
commandEncoder6.clearBuffer(buffer2, 81728, 57712);
} catch {}
try {
commandEncoder9.insertDebugMarker('\u1fe2');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 53}
*/
{
  source: imageBitmap2,
  origin: { x: 4, y: 0 },
  flipY: true,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 5, y: 54, z: 25},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
let pipeline13 = await promise3;
let commandEncoder17 = device0.createCommandEncoder({label: '\ue228\u0f21\u03b7\uf137\u0447\u57ab'});
let querySet5 = device0.createQuerySet({label: '\u0817\u11d0\u0db1\u3324\u0db7\u{1fe2a}\u5875\u426b\u{1fea1}', type: 'occlusion', count: 225});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({
  label: '\u038b\u01ed\u2a7a\u665b\u0fb1',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  sampleCount: 1,
  stencilReadOnly: true,
});
let renderBundle10 = renderBundleEncoder8.finish({label: '\u00ed\u0e8a\udf4c\u5c9f\u07ba\u0407\u{1fbe3}\ub895\u{1ffb2}'});
try {
computePassEncoder1.setBindGroup(3, bindGroup3);
} catch {}
try {
renderBundleEncoder3.setBindGroup(2, bindGroup2);
} catch {}
try {
renderBundleEncoder9.setBindGroup(1, bindGroup1, new Uint32Array(2782), 2038, 0);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder6.copyTextureToTexture({
  texture: texture1,
  mipLevel: 5,
  origin: {x: 1, y: 1, z: 7},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder9.resolveQuerySet(querySet4, 49, 94, buffer0, 13312);
} catch {}
let bindGroup4 = device0.createBindGroup({
  label: '\u5146\u6250\uc365\ufcfd\uca26\u6203\u89a8\u{1f857}\u{1f9a0}\u093f\u096e',
  layout: bindGroupLayout3,
  entries: [],
});
let textureView21 = texture5.createView({baseMipLevel: 5, baseArrayLayer: 23, arrayLayerCount: 85});
let renderBundle11 = renderBundleEncoder5.finish({label: '\u0c54\u{1f7c7}\u0931\u0afa\u{1ff61}\uad11\u02c3\u02ce'});
let sampler9 = device0.createSampler({
  label: '\u09fb\u146f\u0f35\u6ea4\ua8ff',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 14.04,
  lodMaxClamp: 44.97,
});
try {
renderBundleEncoder3.setPipeline(pipeline1);
} catch {}
try {
commandEncoder9.copyBufferToTexture({
  /* bytesInLastRow: 480 widthInBlocks: 240 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 207028 */
  offset: 9940,
  bytesPerRow: 512,
  rowsPerImage: 226,
  buffer: buffer1,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 12, y: 24, z: 2},
  aspect: 'all',
}, {width: 240, height: 159, depthOrArrayLayers: 2});
} catch {}
try {
commandEncoder16.copyTextureToTexture({
  texture: texture5,
  mipLevel: 2,
  origin: {x: 33, y: 39, z: 11},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 5,
  origin: {x: 2, y: 2, z: 0},
  aspect: 'all',
},
{width: 6, height: 7, depthOrArrayLayers: 1});
} catch {}
let pipelineLayout3 = device0.createPipelineLayout({label: '\u0998\u0ee2\u{1fecc}\u{1f8d3}\u{1ffb0}', bindGroupLayouts: []});
let commandEncoder18 = device0.createCommandEncoder({label: '\u5b6c\uebbf\u0b1d\u738b\u3bfc\u74bd\u45f0\ub247\u{1fac3}'});
let texture7 = gpuCanvasContext0.getCurrentTexture();
let computePassEncoder7 = commandEncoder18.beginComputePass({label: '\u13d9\u5a68'});
let renderBundle12 = renderBundleEncoder5.finish({label: '\u005a\u7ff9\u099b\u9292\u{1ffe3}'});
try {
computePassEncoder0.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer0, 'uint16', 185_088, 52_351);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline9);
} catch {}
try {
device0.queue.submit([commandBuffer4]);
} catch {}
let pipeline14 = await device0.createRenderPipelineAsync({
  layout: 'auto',
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'zero', dstFactor: 'src'},
    alpha: {operation: 'add', srcFactor: 'dst-alpha', dstFactor: 'one-minus-constant'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg16float'}, {format: 'rgba16uint', writeMask: 0}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'greater-equal', failOp: 'replace', depthFailOp: 'replace', passOp: 'zero'},
    stencilBack: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'replace', passOp: 'decrement-clamp'},
    stencilReadMask: 2552825968,
    stencilWriteMask: 1973500447,
    depthBias: 0,
    depthBiasClamp: 777.780743500947,
  },
  vertex: {
    module: shaderModule3,
    buffers: [
      {arrayStride: 584, stepMode: 'instance', attributes: []},
      {arrayStride: 240, stepMode: 'vertex', attributes: []},
      {arrayStride: 236, attributes: []},
      {arrayStride: 736, stepMode: 'instance', attributes: []},
      {arrayStride: 828, attributes: []},
      {arrayStride: 276, stepMode: 'instance', attributes: []},
      {arrayStride: 1312, attributes: []},
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 0, shaderLocation: 13},
          {format: 'uint32', offset: 0, shaderLocation: 5},
          {format: 'snorm16x2', offset: 0, shaderLocation: 7},
        ],
      },
    ],
  },
});
let commandBuffer6 = commandEncoder14.finish({label: '\u{1fb48}\u00d8\u9813\u94b7\u0c04\u{1fab9}'});
let texture8 = device0.createTexture({
  label: '\ud2fe\u{1f62c}\ud673\u6b6c\u5c44\u30a3\u{1fdd1}\u6ba7',
  size: [165, 120, 164],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView22 = texture0.createView({
  label: '\uccf5\u2de4\u023c\uc830\u7c0e\u{1f6ad}\uc70a\u0b52\u2c4c\ueacf\u095b',
  dimension: '2d',
  aspect: 'all',
  mipLevelCount: 1,
  baseArrayLayer: 87,
});
let computePassEncoder8 = commandEncoder6.beginComputePass({label: '\u03ab\u050b\ua7f1\u02a1'});
let sampler10 = device0.createSampler({
  label: '\u{1fe52}\u1f94\ua5fb\uc876\ua652\u{1f99b}\u0b28\u5e46\u{1f993}\u5449',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 16.49,
  lodMaxClamp: 69.89,
  maxAnisotropy: 7,
});
try {
renderBundleEncoder9.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup0, new Uint32Array(889), 428, 0);
} catch {}
try {
commandEncoder10.copyBufferToBuffer(buffer1, 233776, buffer2, 32068, 33208);
} catch {}
try {
commandEncoder15.copyTextureToTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 82, y: 93, z: 14},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 6,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 3, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder16.clearBuffer(buffer1);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 46928, new DataView(new ArrayBuffer(33345)), 4613);
} catch {}
let pipeline15 = device0.createComputePipeline({
  label: '\u057e\u{1fc4f}\u{1f63e}',
  layout: pipelineLayout0,
  compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}},
});
let textureView23 = texture6.createView({
  label: '\u00b3\uea64\ue6e2\u07c2\u{1faed}\u043b\u0396\u63bb\u{1f928}',
  dimension: '2d',
  baseMipLevel: 7,
  baseArrayLayer: 32,
});
try {
buffer0.unmap();
} catch {}
try {
commandEncoder16.copyTextureToTexture({
  texture: texture5,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 66},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let textureView24 = texture7.createView({dimension: '2d-array', format: 'rgba8unorm-srgb'});
let renderBundle13 = renderBundleEncoder7.finish({label: '\u{1fc35}\u0edf\u373d'});
let sampler11 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 10.28,
  lodMaxClamp: 45.08,
  maxAnisotropy: 1,
});
try {
renderBundleEncoder3.setBindGroup(3, bindGroup3);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder15.copyTextureToTexture({
  texture: texture4,
  mipLevel: 4,
  origin: {x: 2, y: 0, z: 32},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 6, y: 72, z: 2},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 25});
} catch {}
try {
commandEncoder16.clearBuffer(buffer2, 140340, 3180);
} catch {}
canvas0.height = 1117;
let commandEncoder19 = device0.createCommandEncoder({});
let texture9 = gpuCanvasContext1.getCurrentTexture();
let computePassEncoder9 = commandEncoder10.beginComputePass();
let renderBundle14 = renderBundleEncoder7.finish({label: '\u723e\ub20a\u3075\u3bf0\uc02b'});
let externalTexture9 = device0.importExternalTexture({
  label: '\ub7f3\u0079\u7046\u5c62\u09f4\u1250\u08c7\ue4c5\u0ec7\uec9a\ue066',
  source: videoFrame0,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder3.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(0, undefined, 0, 285_210_013);
} catch {}
let pipeline16 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  multisample: {mask: 0xe5edd7d0},
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.RED}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba16uint'}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 16, stepMode: 'instance', attributes: []},
      {arrayStride: 24, attributes: []},
      {arrayStride: 196, attributes: []},
      {arrayStride: 336, stepMode: 'vertex', attributes: []},
      {arrayStride: 136, attributes: []},
      {arrayStride: 28, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 60,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 0, shaderLocation: 7},
          {format: 'uint32', offset: 0, shaderLocation: 5},
          {format: 'unorm8x4', offset: 4, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
let commandEncoder20 = device0.createCommandEncoder({});
let texture10 = device0.createTexture({
  label: '\u{1fb90}\u0e01\u64f6\u407f\uafc7',
  size: [330, 240, 124],
  mipLevelCount: 7,
  dimension: '2d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg16uint', 'rg16uint'],
});
let externalTexture10 = device0.importExternalTexture({source: videoFrame0});
try {
computePassEncoder8.end();
} catch {}
try {
computePassEncoder6.setPipeline(pipeline3);
} catch {}
try {
renderBundleEncoder10.setBindGroup(2, bindGroup2, new Uint32Array(9972), 2833, 0);
} catch {}
try {
commandEncoder17.copyBufferToBuffer(buffer1, 92232, buffer2, 68240, 44876);
} catch {}
try {
commandEncoder16.copyTextureToTexture({
  texture: texture1,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 4,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder17.resolveQuerySet(querySet4, 35, 201, buffer1, 25856);
} catch {}
let bindGroup5 = device0.createBindGroup({layout: bindGroupLayout3, entries: []});
let textureView25 = texture10.createView({label: '\u{1fdb4}\u0f67', dimension: '2d', baseMipLevel: 4, mipLevelCount: 2, baseArrayLayer: 50});
try {
commandEncoder15.resolveQuerySet(querySet4, 288, 132, buffer0, 81664);
} catch {}
let pipeline17 = device0.createComputePipeline({
  label: '\u{1f91e}\u888f\u959d\uf2c6\ue27d\uf95f\u8e72\u7111',
  layout: pipelineLayout1,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let canvas3 = document.createElement('canvas');
let shaderModule4 = device0.createShaderModule({
  label: '\u{1facc}\u3f5f\uabd3\u{1f9e7}',
  code: `@group(1) @binding(954)
var<storage, read_write> function0: array<u32>;

@compute @workgroup_size(1, 3, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @builtin(sample_mask) f0: u32,
  @location(6) f1: f32,
  @location(0) f2: vec2<f32>,
  @location(2) f3: vec2<f32>,
  @location(3) f4: vec2<f32>,
  @location(4) f5: vec4<u32>
}

@fragment
fn fragment0(@location(15) a0: f16, @builtin(sample_mask) a1: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(15) f40: f16,
  @builtin(position) f41: vec4<f32>
}

@vertex
fn vertex0(@location(15) a0: vec3<f16>, @location(5) a1: u32, @location(7) a2: vec4<i32>, @builtin(instance_index) a3: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout6 = device0.createBindGroupLayout({
  label: '\u0b40\u{1fe2c}\udfc0\u{1f7ec}\u0d33\u1c08\u{1fe59}',
  entries: [
    {
      binding: 137,
      visibility: 0,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 663,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {
      binding: 388,
      visibility: 0,
      buffer: { type: 'uniform', minBindingSize: 142554546, hasDynamicOffset: true },
    },
  ],
});
let querySet6 = device0.createQuerySet({label: '\u0a3e\u47f9\uec58\u005f', type: 'occlusion', count: 1302});
let computePassEncoder10 = commandEncoder9.beginComputePass({label: '\ue06a\u1ae8\u0638\u0aff\u9466'});
let renderBundle15 = renderBundleEncoder2.finish({label: '\ub7d0\u01e6\u{1fee6}\u{1fb5a}\u77ea\u87f5\u{1ff24}\ub0b4\u3452\udc33\u025b'});
try {
computePassEncoder6.end();
} catch {}
try {
computePassEncoder1.setPipeline(pipeline10);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline16);
} catch {}
try {
commandEncoder20.resolveQuerySet(querySet0, 1325, 8, buffer0, 29696);
} catch {}
let commandEncoder21 = device0.createCommandEncoder();
let commandBuffer7 = commandEncoder6.finish({label: '\u2910\u{1fde6}\u5e6d\u0323\ua505\u9bf8\u{1f85b}\u7a96\u9ffc\u{1fdf1}'});
let texture11 = device0.createTexture({
  size: {width: 1320, height: 960, depthOrArrayLayers: 152},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm'],
});
let textureView26 = texture9.createView({label: '\uee2d\u01ff\u{1fef0}\ud071\u16b8\u0413\u{1ff00}\uedee\u{1fc98}\u48d4', arrayLayerCount: 1});
let externalTexture11 = device0.importExternalTexture({
  label: '\u0777\u06a9\u6422\u{1fd19}\u6542\uffbb\u9a6c\u6d45\u{1fc7f}\u6a2d\u348d',
  source: videoFrame0,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder10.setPipeline(pipeline1);
} catch {}
try {
commandEncoder19.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 7184 */
  offset: 7184,
  buffer: buffer1,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
let promise5 = device0.createComputePipelineAsync({
  label: '\u0ea4\u72b5\uf216\u0d31\u2684\u53ad\u0266',
  layout: pipelineLayout3,
  compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}},
});
let commandEncoder22 = device0.createCommandEncoder({label: '\u0ad1\u{1fd4f}\u8f17\uecbc\uc6ac'});
let textureView27 = texture2.createView({baseMipLevel: 2, mipLevelCount: 3, baseArrayLayer: 0});
let renderBundle16 = renderBundleEncoder4.finish({label: '\ub23e\u{1fe8b}\u0364\u{1f770}\u9a42\u6d08\u{1fc62}\u{1f74f}\u05d0'});
try {
renderBundleEncoder9.setVertexBuffer(1, undefined, 0);
} catch {}
try {
buffer0.destroy();
} catch {}
try {
commandEncoder20.copyBufferToBuffer(buffer1, 309028, buffer2, 53752, 1460);
} catch {}
let bindGroup6 = device0.createBindGroup({label: '\u805c\u7f93\u0d41', layout: bindGroupLayout5, entries: []});
let querySet7 = device0.createQuerySet({label: '\u2094\u0350\u0a23\u76a2\u4ca0', type: 'occlusion', count: 678});
let textureView28 = texture8.createView({label: '\u82eb\u8c1d\u{1f961}', baseMipLevel: 4});
try {
computePassEncoder1.setPipeline(pipeline8);
} catch {}
try {
commandEncoder22.copyTextureToTexture({
  texture: texture4,
  mipLevel: 4,
  origin: {x: 2, y: 0, z: 26},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 6,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 3, height: 5, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder16.clearBuffer(buffer2, 132416, 12448);
} catch {}
let querySet8 = device0.createQuerySet({label: '\u{1f7e0}\u0d3f\u{1fab7}\u0806\udba6\u6fbd\u0668\u0bfa', type: 'occlusion', count: 2485});
let texture12 = device0.createTexture({
  label: '\u0889\u0b8c\u{1f602}\u{1f8b2}',
  size: {width: 165, height: 120, depthOrArrayLayers: 124},
  mipLevelCount: 8,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
try {
computePassEncoder9.setPipeline(pipeline6);
} catch {}
try {
commandEncoder22.resolveQuerySet(querySet2, 2, 7, buffer1, 74752);
} catch {}
try {
commandEncoder16.pushDebugGroup('\uf36e');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
}, new Float64Array(arrayBuffer0), /* required buffer size: 166_016 */
{offset: 368, bytesPerRow: 174, rowsPerImage: 34}, {width: 0, height: 0, depthOrArrayLayers: 29});
} catch {}
document.body.prepend(img0);
let promise6 = navigator.gpu.requestAdapter({});
let bindGroupLayout7 = device0.createBindGroupLayout({
  label: '\u{1fd85}\u{1f63c}\uf0e0',
  entries: [
    {
      binding: 358,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 105711978, hasDynamicOffset: true },
    },
    {binding: 107, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
try {
renderBundleEncoder9.setPipeline(pipeline9);
} catch {}
try {
commandEncoder21.copyTextureToTexture({
  texture: texture4,
  mipLevel: 5,
  origin: {x: 1, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 5,
  origin: {x: 1, y: 5, z: 0},
  aspect: 'all',
},
{width: 0, height: 2, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder21.clearBuffer(buffer2, 87996, 25864);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let pipeline18 = await device0.createRenderPipelineAsync({
  label: '\u65cb\u2718\u{1fcea}\udc04\uedaf\ua4a3\u83bb\u0456',
  layout: pipelineLayout1,
  multisample: {count: 4, mask: 0xe674ab6d},
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-constant', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: 0,
}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rg16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'rgba16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 60, attributes: []},
      {arrayStride: 116, attributes: []},
      {arrayStride: 216, stepMode: 'instance', attributes: []},
      {arrayStride: 356, attributes: []},
      {arrayStride: 44, stepMode: 'instance', attributes: []},
      {arrayStride: 216, attributes: []},
      {arrayStride: 28, attributes: []},
      {
        arrayStride: 892,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 8, shaderLocation: 13},
          {format: 'unorm8x2', offset: 20, shaderLocation: 7},
          {format: 'uint32x4', offset: 320, shaderLocation: 5},
        ],
      },
    ],
  },
});
let offscreenCanvas0 = new OffscreenCanvas(538, 740);
let texture13 = gpuCanvasContext1.getCurrentTexture();
let textureView29 = texture11.createView({label: '\u{1f9ea}\u35f2\ud7c3', format: 'bgra8unorm', baseMipLevel: 4});
try {
renderBundleEncoder9.setBindGroup(3, bindGroup1);
} catch {}
try {
renderBundleEncoder10.setIndexBuffer(buffer0, 'uint32', 31_776, 94_424);
} catch {}
try {
commandEncoder13.copyTextureToTexture({
  texture: texture5,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 5,
  origin: {x: 5, y: 3, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder22.resolveQuerySet(querySet4, 82, 77, buffer0, 24064);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 36172, new DataView(new ArrayBuffer(8911)), 7313, 120);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 1_150 */
{offset: 73, bytesPerRow: 213}, {width: 6, height: 6, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData0,
  origin: { x: 2, y: 16 },
  flipY: false,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise7 = device0.createComputePipelineAsync({
  label: '\u0ee1\u7a2f\u0722\uff6a\u0c54\u1f5b\u33bd\u9c6a\uf153\uc75a',
  layout: pipelineLayout2,
  compute: {module: shaderModule4, entryPoint: 'compute0', constants: {}},
});
let gpuCanvasContext2 = offscreenCanvas0.getContext('webgpu');
try {
externalTexture6.label = '\u{1fbe1}\ua558\u{1f8c1}';
} catch {}
let commandEncoder23 = device0.createCommandEncoder();
let computePassEncoder11 = commandEncoder16.beginComputePass({label: '\uc781\u0701\u2dc1\u{1f947}\u9880\u{1fc3e}\u18f0\u39fb\u4af3\ub044'});
let sampler12 = device0.createSampler({
  label: '\u0bb3\uf0c2',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  compare: 'never',
});
try {
computePassEncoder5.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder9.setIndexBuffer(buffer0, 'uint16', 13_424, 102_544);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline1);
} catch {}
try {
commandEncoder21.pushDebugGroup('\u1eb5');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, new BigUint64Array(arrayBuffer0), /* required buffer size: 5_871_932 */
{offset: 563, bytesPerRow: 311, rowsPerImage: 203}, {width: 5, height: 0, depthOrArrayLayers: 94});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 26}
*/
{
  source: videoFrame0,
  origin: { x: 6, y: 35 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 2,
  origin: {x: 64, y: 22, z: 5},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 10, height: 25, depthOrArrayLayers: 0});
} catch {}
let pipeline19 = await device0.createRenderPipelineAsync({
  label: '\u{1fc48}\ub6a3\u9c26\u0cc4\u0eed\u{1feba}',
  layout: pipelineLayout3,
  multisample: {mask: 0x6683b024},
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE,
}, {format: 'rgba16uint'}],
},
  vertex: {
    module: shaderModule3,
    buffers: [
      {arrayStride: 424, stepMode: 'instance', attributes: []},
      {arrayStride: 368, attributes: []},
      {arrayStride: 188, attributes: []},
      {arrayStride: 500, attributes: []},
      {arrayStride: 64, attributes: []},
      {arrayStride: 564, attributes: [{format: 'unorm10-10-10-2', offset: 128, shaderLocation: 7}]},
      {arrayStride: 116, stepMode: 'instance', attributes: []},
      {
        arrayStride: 852,
        attributes: [
          {format: 'uint32x2', offset: 568, shaderLocation: 5},
          {format: 'float32', offset: 48, shaderLocation: 13},
        ],
      },
    ],
  },
});
let textureView30 = texture8.createView({
  label: '\u396f\u{1fd50}\u5101\u{1fb88}\u526d\u9eca\u0fa5\uef7d',
  format: 'rg8unorm',
  baseMipLevel: 1,
  mipLevelCount: 1,
});
let sampler13 = device0.createSampler({
  label: '\u0f1a\u{1ff17}\u{1fa27}\u2f02\u6005\u078f\u1903\u7fc0\u7e43',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 14.85,
  maxAnisotropy: 17,
});
try {
computePassEncoder5.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer0, 'uint16', 33_806, 16_380);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 740, new BigUint64Array(64665), 37005);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 12},
  aspect: 'all',
}, new ArrayBuffer(8), /* required buffer size: 737_097 */
{offset: 201, bytesPerRow: 193, rowsPerImage: 164}, {width: 11, height: 47, depthOrArrayLayers: 24});
} catch {}
let imageData5 = new ImageData(68, 140);
try {
window.someLabel = device0.queue.label;
} catch {}
let commandEncoder24 = device0.createCommandEncoder({});
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 1449});
let computePassEncoder12 = commandEncoder22.beginComputePass();
let renderBundleEncoder11 = device0.createRenderBundleEncoder({
  label: '\u0e07\u72ab\u0215\u0e52\u0d1c\uc918\ucbbd',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
});
let renderBundle17 = renderBundleEncoder2.finish();
let externalTexture12 = device0.importExternalTexture({label: '\u24b0\u{1fc60}', source: videoFrame0, colorSpace: 'display-p3'});
try {
renderBundleEncoder9.setBindGroup(1, bindGroup3, new Uint32Array(6913), 2114, 0);
} catch {}
try {
buffer2.unmap();
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer1, 139124, buffer2, 114260, 25056);
} catch {}
try {
commandEncoder13.copyTextureToTexture({
  texture: texture5,
  mipLevel: 1,
  origin: {x: 132, y: 0, z: 8},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 1,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
},
{width: 50, height: 225, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder13.resolveQuerySet(querySet8, 187, 5, buffer1, 16640);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap0,
  origin: { x: 4, y: 3 },
  flipY: false,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline20 = await promise5;
try {
canvas3.getContext('webgl');
} catch {}
let commandEncoder25 = device0.createCommandEncoder({label: '\u0309\u09f1\u71d6\u47c2\u039c\u249f\u02ae'});
let texture14 = device0.createTexture({
  label: '\u0ecb\u2937\u78a7',
  size: {width: 1320},
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgb10a2unorm', 'rgb10a2unorm'],
});
let sampler14 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 5.236,
  lodMaxClamp: 13.65,
});
try {
renderBundleEncoder9.setPipeline(pipeline9);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(4_294_967_295, undefined, 53_060_171, 582_990_334);
} catch {}
try {
commandEncoder13.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let querySet10 = device0.createQuerySet({label: '\u{1f610}\u4ff9\ud3b8\ucd55\ud500\u4f1b', type: 'occlusion', count: 3489});
let textureView31 = texture14.createView({dimension: '1d'});
let sampler15 = device0.createSampler({
  label: '\ucc21\ua934\u3532\u{1fa51}\u092a\u0a52',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 63.87,
  lodMaxClamp: 67.71,
});
try {
renderBundleEncoder3.setBindGroup(2, bindGroup0);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(4_294_967_295, undefined);
} catch {}
try {
buffer1.unmap();
} catch {}
let promise8 = buffer2.mapAsync(GPUMapMode.READ, 83448, 21680);
try {
commandEncoder15.resolveQuerySet(querySet0, 307, 43, buffer0, 66304);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'],
  colorSpace: 'display-p3',
});
} catch {}
let promise9 = device0.queue.onSubmittedWorkDone();
offscreenCanvas0.height = 61;
let textureView32 = texture9.createView({label: '\ue012\u3f2c\uc843\ucfc6\u0add\ua3a6\u2b04'});
let externalTexture13 = device0.importExternalTexture({
  label: '\u{1f772}\u0b22\u044a\u564e\uede0\u0166\uc597\u731c\u4f52\u0211\u0656',
  source: video3,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder10.setVertexBuffer(4_294_967_295, undefined, 0, 182_427_603);
} catch {}
try {
commandEncoder13.clearBuffer(buffer1);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 61956, new Float32Array(37054));
} catch {}
let pipeline21 = await device0.createComputePipelineAsync({
  label: '\u0795\ud3fb\u{1f9a4}',
  layout: pipelineLayout0,
  compute: {module: shaderModule4, entryPoint: 'compute0', constants: {}},
});
let bindGroupLayout8 = device0.createBindGroupLayout({
  label: '\u0119\ucb78',
  entries: [
    {
      binding: 8,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 44,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 432,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let buffer3 = device0.createBuffer({
  label: '\u4e77\u0a56\u{1f691}\u573d\ubf7e\ude76',
  size: 94365,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
});
try {
commandEncoder17.clearBuffer(buffer1);
} catch {}
try {
commandEncoder25.resolveQuerySet(querySet0, 192, 64, buffer1, 110592);
} catch {}
let textureView33 = texture13.createView({label: '\u0029\u0a2b\u3f93\u0119\u{1f970}', dimension: '2d-array', format: 'rgba8unorm-srgb'});
let computePassEncoder13 = commandEncoder20.beginComputePass({});
let renderBundle18 = renderBundleEncoder0.finish({label: '\u31d0\u041d\u4ee9\ucb42\u{1fe54}\u3a57\u01c4\u{1ff85}'});
let sampler16 = device0.createSampler({
  label: '\u0c80\ub9ad\u61eb\u06e2\u5c84\uade4\u{1fe98}\u75ed\u{1fa64}\u0f79',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 2.146,
  maxAnisotropy: 8,
});
try {
  await device0.popErrorScope();
} catch {}
try {
commandEncoder25.resolveQuerySet(querySet10, 1023, 140, buffer1, 23552);
} catch {}
let pipeline22 = device0.createRenderPipeline({
  label: '\u{1f938}\u4cbf\uc5d3\u47a5\u0c1a\u6c09\u07e8\u01f2\u64e6\u4fc7',
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'dst-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-src', dstFactor: 'one-minus-src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 156, stepMode: 'instance', attributes: []},
      {arrayStride: 356, stepMode: 'instance', attributes: []},
      {arrayStride: 128, attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 1028, stepMode: 'vertex', attributes: []},
      {arrayStride: 196, stepMode: 'instance', attributes: []},
      {arrayStride: 760, attributes: []},
      {
        arrayStride: 228,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 36, shaderLocation: 14},
          {format: 'sint8x4', offset: 12, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list'},
});
let commandEncoder26 = device0.createCommandEncoder({label: '\ufbb5\udb09\u0e43\u0a62\u0dd6\ub78b'});
let textureView34 = texture2.createView({label: '\u{1fc1d}\u235f\u7902', baseMipLevel: 4});
let computePassEncoder14 = commandEncoder26.beginComputePass({});
try {
renderBundleEncoder3.setBindGroup(1, bindGroup2, new Uint32Array(7552), 3515, 0);
} catch {}
try {
texture1.destroy();
} catch {}
try {
commandEncoder15.copyTextureToTexture({
  texture: texture4,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 18},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 1,
  origin: {x: 3, y: 46, z: 10},
  aspect: 'all',
},
{width: 5, height: 4, depthOrArrayLayers: 3});
} catch {}
try {
commandEncoder13.clearBuffer(buffer3, 11960, 28748);
} catch {}
let commandEncoder27 = device0.createCommandEncoder();
let textureView35 = texture5.createView({
  label: '\u0333\uaec3\uf169\u013b\u0ae5\uc8fe\u0eb1\u8a46',
  dimension: '2d',
  format: 'rg8uint',
  baseMipLevel: 6,
  baseArrayLayer: 83,
});
let computePassEncoder15 = commandEncoder21.beginComputePass();
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 5228 widthInBlocks: 1307 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 48984 */
  offset: 48984,
  buffer: buffer3,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1307, height: 1, depthOrArrayLayers: 0});
} catch {}
let externalTexture14 = device0.importExternalTexture({label: '\ufd8d\u{1f8d8}\u{1f8dc}\u302b\u0e04\u05cf\u0a56\ucbc3\u{1f8a9}\u0735', source: video2});
let pipeline23 = device0.createRenderPipeline({
  label: '\u{1fdaa}\u9288\u3c37',
  layout: pipelineLayout0,
  multisample: {mask: 0x584a4726},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'constant', dstFactor: 'dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE,
}, {format: 'rgba8sint', writeMask: 0}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.GREEN}, {format: 'rg16uint'}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'dst'},
    alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {arrayStride: 196, stepMode: 'instance', attributes: []},
      {arrayStride: 124, stepMode: 'instance', attributes: []},
      {arrayStride: 424, stepMode: 'instance', attributes: []},
      {arrayStride: 192, attributes: []},
      {arrayStride: 232, stepMode: 'instance', attributes: []},
      {arrayStride: 280, stepMode: 'instance', attributes: []},
      {arrayStride: 60, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 164,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 8, shaderLocation: 4},
          {format: 'uint32x2', offset: 40, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw'},
});
document.body.prepend(canvas2);
let commandEncoder28 = device0.createCommandEncoder();
let textureView36 = texture6.createView({
  label: '\u0c12\u80ff\u{1ffc4}\u{1ff33}\u{1f97b}\u360c\u{1fcdc}\u8ca3\u0a2e\u{1f997}\u0b8b',
  baseMipLevel: 4,
  mipLevelCount: 1,
  baseArrayLayer: 55,
  arrayLayerCount: 1,
});
let renderBundle19 = renderBundleEncoder10.finish({label: '\ue72b\u2598\u{1ff59}\u{1fc0f}\u5b2e\u695e\u0df6\u{1f788}'});
try {
renderBundleEncoder3.setBindGroup(0, bindGroup5);
} catch {}
try {
renderBundleEncoder11.setPipeline(pipeline1);
} catch {}
try {
commandEncoder15.clearBuffer(buffer2, 33504, 57948);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([commandBuffer1, commandBuffer5, commandBuffer2]);
} catch {}
document.body.prepend(video1);
let offscreenCanvas1 = new OffscreenCanvas(156, 103);
let imageBitmap3 = await createImageBitmap(imageData4);
let bindGroup7 = device0.createBindGroup({label: '\u7216\u{1ffc7}\u0833', layout: bindGroupLayout5, entries: []});
let texture15 = device0.createTexture({
  label: '\u{1fcea}\u9b7d\u299f',
  size: [330, 240, 506],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundle20 = renderBundleEncoder8.finish({label: '\u{1fcfa}\u6fcf\u71ec\u{1f9ca}\u8b48'});
let sampler17 = device0.createSampler({
  label: '\u{1f82c}\u0dd3\u9a37\u79ff\ubf30',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 58.91,
  lodMaxClamp: 84.99,
});
try {
renderBundleEncoder11.setIndexBuffer(buffer0, 'uint32', 11_280, 15_337);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(5, undefined, 63_792_611, 393_047_619);
} catch {}
try {
commandEncoder27.resolveQuerySet(querySet7, 70, 159, buffer0, 9728);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 57860, new Float32Array(2210), 58, 92);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let video4 = await videoWithData();
let textureView37 = texture9.createView({label: '\u49da\u{1feb0}\ue2ae\u{1f6ae}\uc947', dimension: '2d-array'});
let renderBundle21 = renderBundleEncoder7.finish({label: '\u01f4\u02a6\u07cf\u061e\ue54f'});
let sampler18 = device0.createSampler({
  label: '\u{1fd65}\u{1fabe}\u0324\u1a03\u0c4b\u2e09\u6949\u{1fe5b}\u0342\u2f07\u578e',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 90.45,
  lodMaxClamp: 97.84,
  compare: 'equal',
  maxAnisotropy: 14,
});
try {
commandEncoder23.copyTextureToBuffer({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3740 */
  offset: 3740,
  bytesPerRow: 256,
  buffer: buffer1,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder24.clearBuffer(buffer2, 128208, 1576);
} catch {}
try {
commandEncoder13.resolveQuerySet(querySet0, 161, 384, buffer1, 32768);
} catch {}
let pipeline24 = device0.createComputePipeline({
  label: '\u04bf\udbaa\u700f',
  layout: pipelineLayout3,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let offscreenCanvas2 = new OffscreenCanvas(809, 463);
let videoFrame1 = new VideoFrame(imageBitmap0, {timestamp: 0});
let querySet11 = device0.createQuerySet({
  label: '\u9fd8\u0a63\ufe1d\u0f4e\u0c9f\u58ce\u8c36\u48ad\u0811\u{1fe49}',
  type: 'occlusion',
  count: 3683,
});
let textureView38 = texture7.createView({
  label: '\u7ef8\u7a10\ub005\u{1fa9b}\u0034\ubaf4\u{1fba1}\u5e4d\u0585',
  dimension: '2d-array',
  format: 'rgba8unorm-srgb',
});
let renderBundle22 = renderBundleEncoder11.finish({label: '\u{1f6a7}\u{1f628}\u5041\u{1ff59}\u091b\ufe26\uf4c4'});
try {
computePassEncoder10.setBindGroup(0, bindGroup5, new Uint32Array(2379), 1534, 0);
} catch {}
try {
computePassEncoder14.setPipeline(pipeline17);
} catch {}
try {
commandEncoder28.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder23.resolveQuerySet(querySet3, 66, 157, buffer1, 13568);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 0,
  origin: {x: 10, y: 19, z: 24},
  aspect: 'all',
}, new Uint32Array(arrayBuffer0), /* required buffer size: 143_666 */
{offset: 22, bytesPerRow: 92, rowsPerImage: 154}, {width: 4, height: 22, depthOrArrayLayers: 11});
} catch {}
let bindGroupLayout9 = device0.createBindGroupLayout({
  label: '\uc1a8\ue13e\u6890\u390a\u51b5\ub755\u792e\u323e\u0467\ua45f',
  entries: [{binding: 900, visibility: 0, externalTexture: {}}],
});
let buffer4 = device0.createBuffer({
  label: '\u{1f955}\u5d6b\ud63e',
  size: 174603,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder29 = device0.createCommandEncoder();
let querySet12 = device0.createQuerySet({
  label: '\u0dd4\u2d02\u0811\u4ab7\u{1fab5}\ubc25\u{1f60d}\uad35\u757c\u9d37',
  type: 'occlusion',
  count: 196,
});
let commandBuffer8 = commandEncoder15.finish({label: '\u07c8\uf615\u054a\u33a6\u03da\udcd6\u0c87'});
let textureView39 = texture6.createView({dimension: '2d', aspect: 'all', baseMipLevel: 1, mipLevelCount: 6, baseArrayLayer: 95});
try {
computePassEncoder13.setBindGroup(2, bindGroup2);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer0, 'uint32', 82_652, 5_381);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
commandEncoder25.clearBuffer(buffer2, 84084, 37360);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 64 */
{offset: 58}, {width: 3, height: 1, depthOrArrayLayers: 1});
} catch {}
document.body.prepend(video3);
video2.height = 72;
let shaderModule5 = device0.createShaderModule({
  label: '\u034b\u2902\u{1fab7}\u{1f730}\u04cf\u7763\u41a7\ucd60\u{1fa94}\u0c1f\u{1f876}',
  code: `

@compute @workgroup_size(2, 1, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(4) f0: vec4<u32>,
  @location(0) f1: vec4<f32>,
  @location(7) f2: vec3<f32>,
  @location(2) f3: vec3<f32>,
  @location(3) f4: vec3<f32>
}

@fragment
fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(front_facing) a1: bool, @builtin(sample_mask) a2: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(7) a0: vec2<f32>, @location(2) a1: vec3<i32>, @location(9) a2: u32, @location(13) a3: vec3<i32>, @location(4) a4: vec2<u32>, @location(8) a5: f16, @builtin(instance_index) a6: u32, @location(1) a7: vec4<f32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
});
let commandEncoder30 = device0.createCommandEncoder({label: '\u6503\u00a4\u0808\uf4fc\u22fc\u{1ff32}\u{1f897}\u{1f809}'});
let computePassEncoder16 = commandEncoder13.beginComputePass({});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({
  label: '\u039f\u{1fc71}\u05cc\u03f1\u{1fda4}\u23b7\u8821\u{1f917}\u9ad5\u85b2\u0d67',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
});
let externalTexture15 = device0.importExternalTexture({label: '\u04d9\u2190\u0bf2\u2ae0\ud616\u0103', source: video2, colorSpace: 'srgb'});
try {
renderBundleEncoder3.setIndexBuffer(buffer0, 'uint32', 91_300, 2_580);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 15752, new Float32Array(15007), 11491, 464);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 10, height: 7, depthOrArrayLayers: 10}
*/
{
  source: imageData3,
  origin: { x: 14, y: 2 },
  flipY: false,
}, {
  texture: texture8,
  mipLevel: 4,
  origin: {x: 0, y: 2, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline25 = await device0.createComputePipelineAsync({
  label: '\u66d5\ufe24\u{1f62c}\u7551\u7b13\u09a0',
  layout: pipelineLayout2,
  compute: {module: shaderModule5, entryPoint: 'compute0'},
});
let renderBundle23 = renderBundleEncoder11.finish({});
try {
computePassEncoder14.setBindGroup(0, bindGroup1);
} catch {}
try {
computePassEncoder14.setPipeline(pipeline12);
} catch {}
try {
renderBundleEncoder3.setIndexBuffer(buffer3, 'uint16', 1_072, 1_546);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 41032, new BigUint64Array(41637), 11724);
} catch {}
try {
computePassEncoder12.setBindGroup(1, bindGroup5, new Uint32Array(4064), 1729, 0);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm-srgb', 'bgra8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 22308, new Int16Array(25358));
} catch {}
let bindGroup8 = device0.createBindGroup({label: '\u{1ff0a}\u2310', layout: bindGroupLayout3, entries: []});
let commandBuffer9 = commandEncoder23.finish();
let textureView40 = texture8.createView({label: '\u0acb\u8192\ua2f0\u0e2a\u88da\u260b\u1f00', aspect: 'all', baseMipLevel: 2, mipLevelCount: 2});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({
  label: '\u67eb\u0aeb\u99cb\u{1fefd}\u277a\u0392\u0d21\u{1fe3b}\u679e\ube68\u0cea',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle24 = renderBundleEncoder0.finish({label: '\udbe5\u{1ff42}\udad6\u{1f60c}\u{1fab5}\u078b\u336f\u212b\uabdb\u70ea'});
try {
computePassEncoder0.setBindGroup(0, bindGroup8);
} catch {}
try {
computePassEncoder5.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(0, buffer4);
} catch {}
try {
commandEncoder17.clearBuffer(buffer1);
} catch {}
try {
commandEncoder24.resolveQuerySet(querySet3, 37, 110, buffer1, 20992);
} catch {}
canvas2.height = 1879;
let renderBundle25 = renderBundleEncoder8.finish({label: '\u{1f742}\u014c\uf96e\u0375\u8fe0'});
try {
renderBundleEncoder13.setIndexBuffer(buffer3, 'uint16', 15_542, 2_489);
} catch {}
try {
texture5.destroy();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 2,
  origin: {x: 1, y: 2, z: 1},
  aspect: 'all',
}, new ArrayBuffer(937_787), /* required buffer size: 937_787 */
{offset: 323, bytesPerRow: 219, rowsPerImage: 50}, {width: 36, height: 31, depthOrArrayLayers: 86});
} catch {}
let pipeline26 = device0.createRenderPipeline({
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'src-alpha', dstFactor: 'one-minus-constant'},
    alpha: {operation: 'subtract', srcFactor: 'one', dstFactor: 'src-alpha-saturated'},
  },
}, {format: 'rgba8sint'}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg16uint', writeMask: GPUColorWrite.ALL}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one', dstFactor: 'dst-alpha'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'constant'},
  },
  writeMask: GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 160, stepMode: 'instance', attributes: []},
      {arrayStride: 564, attributes: []},
      {arrayStride: 796, attributes: []},
      {arrayStride: 16, attributes: []},
      {arrayStride: 312, stepMode: 'instance', attributes: []},
      {arrayStride: 132, stepMode: 'instance', attributes: []},
      {arrayStride: 76, attributes: []},
      {
        arrayStride: 16,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x2', offset: 0, shaderLocation: 13},
          {format: 'sint16x2', offset: 0, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front'},
});
let gpuCanvasContext3 = offscreenCanvas1.getContext('webgpu');
let textureView41 = texture13.createView({label: '\u{1fdb6}\u0d5c\u4310\u{1f747}', format: 'rgba8unorm'});
let computePassEncoder17 = commandEncoder17.beginComputePass({label: '\u9d4e\u{1f705}\ud994\u81ee\u3a1c\u6cdf\u2c72'});
try {
renderBundleEncoder9.setBindGroup(1, bindGroup0);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline16);
} catch {}
try {
renderBundleEncoder3.setVertexBuffer(7, buffer4, 39_604, 8_729);
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer4, 7908, buffer2, 112832, 23156);
} catch {}
try {
commandEncoder24.clearBuffer(buffer1);
} catch {}
try {
device0.queue.submit([commandBuffer8]);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 7156, new BigUint64Array(46281), 4930, 8744);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 53}
*/
{
  source: img0,
  origin: { x: 0, y: 4 },
  flipY: true,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 33, y: 86, z: 14},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
let canvas4 = document.createElement('canvas');
let commandEncoder31 = device0.createCommandEncoder({label: '\u9c12\u1858\u{1f9b8}'});
let commandBuffer10 = commandEncoder30.finish({label: '\u{1f9e9}\u5b07\u0611\ue514\uda05\u244f\u6a69\u{1fbfc}'});
let renderBundle26 = renderBundleEncoder3.finish({});
try {
computePassEncoder1.setBindGroup(0, bindGroup0, []);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup1, new Uint32Array(2094), 627, 0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(3, buffer4, 0, 912);
} catch {}
try {
commandEncoder27.clearBuffer(buffer2, 122896, 14968);
} catch {}
let commandEncoder32 = device0.createCommandEncoder({label: '\u6747\ucaf9\u0f8e\u0b4c'});
let textureView42 = texture0.createView({
  label: '\ua25e\u{1fc43}\u498d\u{1f966}\u0997\u7fe6\u012d',
  dimension: '2d-array',
  mipLevelCount: 1,
  baseArrayLayer: 43,
  arrayLayerCount: 15,
});
try {
renderBundleEncoder12.setVertexBuffer(1, buffer4, 0, 19_536);
} catch {}
try {
  await device0.popErrorScope();
} catch {}
try {
commandEncoder31.copyBufferToBuffer(buffer4, 66440, buffer1, 230496, 72512);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture6,
  mipLevel: 5,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 46_889 */
{offset: 781, bytesPerRow: 116, rowsPerImage: 79}, {width: 7, height: 3, depthOrArrayLayers: 6});
} catch {}
let buffer5 = device0.createBuffer({
  size: 391960,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let renderBundle27 = renderBundleEncoder6.finish({label: '\u03fb\u0fe9\u253b\uc69a\u0cff\u{1f8e7}\u4463\u40a3\u0b5e'});
try {
computePassEncoder1.setBindGroup(2, bindGroup0);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(5, buffer4, 0, 75_255);
} catch {}
try {
renderBundleEncoder12.insertDebugMarker('\u{1fb36}');
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
try {
  await promise8;
} catch {}
let img2 = await imageWithData(115, 68, '#747ab91b', '#1507bcfb');
let commandEncoder33 = device0.createCommandEncoder();
let querySet13 = device0.createQuerySet({label: '\uedc2\uc75f\u1699\u{1fa02}\uc890\u4f20\uda87\u5ef1\u5bd8', type: 'occlusion', count: 2560});
let texture16 = device0.createTexture({
  size: [165],
  dimension: '1d',
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg16float'],
});
try {
commandEncoder32.copyBufferToTexture({
  /* bytesInLastRow: 4736 widthInBlocks: 1184 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 26536 */
  offset: 21800,
  buffer: buffer1,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 75, y: 0, z: 0},
  aspect: 'all',
}, {width: 1184, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder27.clearBuffer(buffer1);
} catch {}
try {
commandEncoder28.resolveQuerySet(querySet6, 81, 236, buffer0, 14080);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 74344, new BigUint64Array(9300), 6229);
} catch {}
let bindGroup9 = device0.createBindGroup({
  label: '\u6cd0\u74d8\uf475\u8439\ud597\u56ce\uf799\u0fd0\u6c73\u04f8',
  layout: bindGroupLayout9,
  entries: [{binding: 900, resource: externalTexture14}],
});
let textureView43 = texture10.createView({dimension: '2d', baseMipLevel: 0, mipLevelCount: 3, baseArrayLayer: 51});
let computePassEncoder18 = commandEncoder27.beginComputePass({label: '\u{1ffbe}\u682f\u6d76\u093b\u08f8\u85e9\u0a17'});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({
  label: '\u008a\u0feb\u02ac\u70ac\u{1f7e9}\uc25b\uf55b\u9b3e\u{1f934}',
  colorFormats: ['rgba8unorm'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle28 = renderBundleEncoder4.finish();
try {
computePassEncoder12.setBindGroup(0, bindGroup6, new Uint32Array(3310), 1594, 0);
} catch {}
try {
buffer0.unmap();
} catch {}
try {
offscreenCanvas2.getContext('webgl');
} catch {}
let renderBundle29 = renderBundleEncoder9.finish({label: '\ue0b5\u3330\u{1fd1a}\u006b\u07be\u{1febb}\u{1f9cf}\u196d\udaa2'});
let sampler19 = device0.createSampler({
  label: '\u{1faac}\u{1f87b}\u{1f656}\u28f5',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 41.94,
  lodMaxClamp: 88.67,
  maxAnisotropy: 4,
});
try {
computePassEncoder1.setBindGroup(1, bindGroup6, new Uint32Array(5618), 4149, 0);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline20);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline13);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder31.copyTextureToTexture({
  texture: texture1,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 3,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer7, commandBuffer6, commandBuffer3]);
} catch {}
let pipeline27 = await device0.createRenderPipelineAsync({
  label: '\u0d26\u581f',
  layout: pipelineLayout0,
  multisample: {count: 4, mask: 0x32360184},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'zero', dstFactor: 'src-alpha-saturated'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: 0}, {format: 'rg16uint', writeMask: 0}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 152, stepMode: 'instance', attributes: []},
      {arrayStride: 2048, stepMode: 'instance', attributes: []},
      {arrayStride: 692, attributes: []},
      {arrayStride: 36, attributes: []},
      {arrayStride: 44, stepMode: 'instance', attributes: []},
      {arrayStride: 496, stepMode: 'instance', attributes: []},
      {arrayStride: 244, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint16x4', offset: 52, shaderLocation: 4},
          {format: 'uint16x2', offset: 664, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'},
});
let shaderModule6 = device0.createShaderModule({
  label: '\u4880\u07c2\u9b8f\ucf97\u9bde',
  code: `@group(1) @binding(954)
var<storage, read_write> field2: array<u32>;

@compute @workgroup_size(6, 1, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S5 {
  @location(8) f0: vec2<f16>,
  @location(13) f1: f16,
  @location(7) f2: vec4<f32>,
  @location(6) f3: vec3<u32>,
  @location(12) f4: vec3<u32>,
  @location(3) f5: f32
}
struct FragmentOutput0 {
  @location(0) f0: vec4<f32>,
  @location(5) f1: vec4<f32>,
  @location(1) f2: vec4<i32>,
  @location(2) f3: vec4<f32>,
  @location(3) f4: vec3<u32>,
  @location(4) f5: vec4<u32>
}

@fragment
fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(front_facing) a1: bool, @location(5) a2: vec4<f32>, @location(4) a3: vec2<i32>, @location(10) a4: vec2<u32>, @location(0) a5: vec3<u32>, @location(14) a6: vec4<f32>, a7: S5) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S4 {
  @location(12) f0: vec3<f32>,
  @location(7) f1: vec3<f32>,
  @builtin(instance_index) f2: u32,
  @location(4) f3: f32,
  @location(5) f4: f16
}
struct VertexOutput0 {
  @location(8) f42: vec2<f16>,
  @location(5) f43: vec4<f32>,
  @location(15) f44: f32,
  @location(3) f45: f32,
  @location(7) f46: vec4<f32>,
  @builtin(position) f47: vec4<f32>,
  @location(9) f48: vec2<f16>,
  @location(12) f49: vec3<u32>,
  @location(13) f50: f16,
  @location(14) f51: vec4<f32>,
  @location(6) f52: vec3<u32>,
  @location(10) f53: vec2<u32>,
  @location(0) f54: vec3<u32>,
  @location(4) f55: vec2<i32>
}

@vertex
fn vertex0(@location(13) a0: vec4<u32>, @location(9) a1: vec3<f32>, a2: S4, @location(6) a3: vec4<f32>, @location(10) a4: u32, @location(1) a5: vec4<f16>, @location(3) a6: vec2<f32>, @builtin(vertex_index) a7: u32, @location(14) a8: f16, @location(11) a9: vec4<i32>, @location(15) a10: f16, @location(2) a11: vec2<i32>, @location(8) a12: vec2<f16>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  hints: {},
});
let bindGroup10 = device0.createBindGroup({layout: bindGroupLayout5, entries: []});
let texture17 = device0.createTexture({
  label: '\ue3be\u63fb',
  size: [1320, 960, 159],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint', 'rg8uint'],
});
let externalTexture16 = device0.importExternalTexture({
  label: '\ub823\u{1fdc8}\ucd96\u5f9f\u007f\u9a16\u0b63\udb26\ufa85',
  source: videoFrame0,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder14.setBindGroup(3, bindGroup2);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
try {
commandEncoder29.copyBufferToBuffer(buffer5, 259952, buffer1, 184992, 128844);
} catch {}
try {
commandEncoder29.copyBufferToTexture({
  /* bytesInLastRow: 116 widthInBlocks: 58 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 349286 */
  offset: 28914,
  bytesPerRow: 256,
  rowsPerImage: 171,
  buffer: buffer5,
}, {
  texture: texture15,
  mipLevel: 1,
  origin: {x: 24, y: 9, z: 46},
  aspect: 'all',
}, {width: 58, height: 55, depthOrArrayLayers: 8});
} catch {}
try {
commandEncoder25.copyTextureToBuffer({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 234, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 638 widthInBlocks: 319 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4998 */
  offset: 4360,
  buffer: buffer3,
}, {width: 319, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder28.clearBuffer(buffer2, 76784, 23916);
} catch {}
try {
commandEncoder32.resolveQuerySet(querySet3, 88, 45, buffer0, 91392);
} catch {}
let pipeline28 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}}});
let bindGroupLayout10 = device0.createBindGroupLayout({
  label: '\u{1f75f}\u5d02\u86ef\u0340\u{1f9eb}\uce31\ufa76\uaf5d\u093b',
  entries: [
    {
      binding: 117,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 144,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {binding: 608, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
  ],
});
let commandEncoder34 = device0.createCommandEncoder({label: '\u{1fc10}\u392f\u{1fe3f}\u09d5\ucff4\u0a9c\ucfa8'});
let commandBuffer11 = commandEncoder29.finish({});
try {
computePassEncoder17.setPipeline(pipeline8);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(3, buffer4);
} catch {}
try {
commandEncoder34.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3372 */
  offset: 3372,
  bytesPerRow: 512,
  rowsPerImage: 210,
  buffer: buffer3,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder32.copyTextureToBuffer({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 77, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2030 widthInBlocks: 1015 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 13758 */
  offset: 13758,
  bytesPerRow: 2048,
  buffer: buffer1,
}, {width: 1015, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture2,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Int32Array(arrayBuffer0), /* required buffer size: 282_743 */
{offset: 507, bytesPerRow: 330, rowsPerImage: 270}, {width: 43, height: 46, depthOrArrayLayers: 4});
} catch {}
let pipeline29 = await device0.createComputePipelineAsync({
  label: '\ub4d0\ua753\u5066\u{1f63f}\u0f8f\u{1fe22}',
  layout: pipelineLayout3,
  compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}},
});
let pipeline30 = await device0.createRenderPipelineAsync({
  label: '\u1672\u7f7a\u{1fb7f}',
  layout: pipelineLayout0,
  multisample: {mask: 0x70daa1c2},
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'zero', dstFactor: 'dst'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}, {format: 'rgba8sint', writeMask: 0}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rg16uint'}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one-minus-src-alpha'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-dst'},
  },
}],
},
  vertex: {
    module: shaderModule6,
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'float32', offset: 12, shaderLocation: 8},
          {format: 'uint8x4', offset: 204, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 948, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 140,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x4', offset: 20, shaderLocation: 2},
          {format: 'uint16x4', offset: 32, shaderLocation: 10},
          {format: 'snorm8x4', offset: 60, shaderLocation: 6},
        ],
      },
      {arrayStride: 228, stepMode: 'instance', attributes: []},
      {arrayStride: 556, stepMode: 'instance', attributes: []},
      {
        arrayStride: 76,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 28, shaderLocation: 7},
          {format: 'sint32x3', offset: 12, shaderLocation: 11},
          {format: 'unorm8x4', offset: 8, shaderLocation: 9},
        ],
      },
      {arrayStride: 112, stepMode: 'instance', attributes: []},
      {arrayStride: 348, attributes: []},
      {
        arrayStride: 216,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 68, shaderLocation: 14},
          {format: 'float32x4', offset: 24, shaderLocation: 4},
          {format: 'snorm8x2', offset: 28, shaderLocation: 3},
          {format: 'float32x4', offset: 12, shaderLocation: 1},
          {format: 'unorm8x2', offset: 26, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 124, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
try {
adapter1.label = '\u360d\uea44\u0517\u03b4\u51e4\u0127\u{1fbc1}';
} catch {}
let buffer6 = device0.createBuffer({
  label: '\u4f82\u0cbc\u9549\u1e69\u0d37',
  size: 27370,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
});
let commandEncoder35 = device0.createCommandEncoder({label: '\u{1fdeb}\u8d30\uae61\u{1f825}'});
try {
computePassEncoder17.end();
} catch {}
try {
computePassEncoder14.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup7);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(6, buffer5, 0, 110_988);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm', 'bgra8unorm-srgb'],
  colorSpace: 'srgb',
});
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 82}
*/
{
  source: imageData4,
  origin: { x: 12, y: 24 },
  flipY: false,
}, {
  texture: texture8,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 36},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 21, height: 58, depthOrArrayLayers: 0});
} catch {}
let pipeline31 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule5, entryPoint: 'compute0', constants: {}}});
let commandEncoder36 = device0.createCommandEncoder({label: '\ua7a2\u06ce\u{1fc97}\ua3e5\ubfcd\u44a7'});
let querySet14 = device0.createQuerySet({label: '\u0bf6\ud45a\u0436\ud276\u{1fba4}\uc716\ub932', type: 'occlusion', count: 1397});
let texture18 = device0.createTexture({
  label: '\u0dd6\u0f11\ucd0a\ud213\u{1f8c2}\u4860\u125b\u{1f838}\uda32\uc4dd\u7ef1',
  size: {width: 165, height: 120, depthOrArrayLayers: 124},
  mipLevelCount: 3,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let externalTexture17 = device0.importExternalTexture({source: video0, colorSpace: 'srgb'});
try {
computePassEncoder16.setPipeline(pipeline7);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(5, buffer6, 0, 10_184);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let canvas5 = document.createElement('canvas');
let commandBuffer12 = commandEncoder33.finish({});
let textureView44 = texture11.createView({label: '\u03b6\u3634\ue4cb\ud8e8\u{1fcca}', format: 'bgra8unorm', baseMipLevel: 5, mipLevelCount: 1});
let renderBundle30 = renderBundleEncoder3.finish({label: '\ub29c\u9818\u{1faa4}'});
try {
computePassEncoder5.dispatchWorkgroups(2);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture4,
  mipLevel: 3,
  origin: {x: 0, y: 6, z: 2},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 0, depthOrArrayLayers: 16});
} catch {}
try {
commandEncoder34.clearBuffer(buffer3, 16880, 23104);
} catch {}
let bindGroup11 = device0.createBindGroup({layout: bindGroupLayout5, entries: []});
let querySet15 = device0.createQuerySet({label: '\uf959\u2d76\u0dc4\u0c28\u30d4', type: 'occlusion', count: 2814});
let textureView45 = texture2.createView({label: '\u95a5\uff64\u{1f9ba}\u{1f860}\u0218\ue1ee\ua499', format: 'rg8unorm', baseMipLevel: 5});
try {
computePassEncoder0.dispatchWorkgroupsIndirect(buffer0, 186064);
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer3, 60644, buffer6, 4752, 276);
} catch {}
try {
commandEncoder17.copyTextureToBuffer({
  texture: texture17,
  mipLevel: 1,
  origin: {x: 107, y: 17, z: 64},
  aspect: 'all',
}, {
  /* bytesInLastRow: 290 widthInBlocks: 145 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 223166 */
  offset: 46236,
  bytesPerRow: 512,
  rowsPerImage: 527,
  buffer: buffer1,
}, {width: 145, height: 346, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder17.resolveQuerySet(querySet15, 78, 464, buffer0, 14336);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 10, height: 7, depthOrArrayLayers: 10}
*/
{
  source: offscreenCanvas0,
  origin: { x: 106, y: 26 },
  flipY: true,
}, {
  texture: texture8,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
let promise11 = adapter1.requestAdapterInfo();
let texture19 = device0.createTexture({
  label: '\u5900\uf69a\u0871\u1fa1',
  size: [165, 120, 124],
  mipLevelCount: 4,
  format: 'depth24plus',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
renderBundleEncoder12.setBindGroup(3, bindGroup4, []);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(7, buffer5);
} catch {}
try {
commandEncoder19.copyTextureToTexture({
  texture: texture18,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 83},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 1,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
},
{width: 31, height: 21, depthOrArrayLayers: 1});
} catch {}
let texture20 = device0.createTexture({
  label: '\uc595\u{1ffd7}\udf84\u7e21\u9caf\u{1f734}\u{1f9ee}\u0c5c',
  size: {width: 1320},
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
});
let sampler20 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 28.77,
});
try {
computePassEncoder0.dispatchWorkgroups(3, 5);
} catch {}
try {
computePassEncoder15.end();
} catch {}
try {
commandEncoder35.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 13658 */
  offset: 13658,
  bytesPerRow: 256,
  buffer: buffer4,
}, {
  texture: texture2,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder34.clearBuffer(buffer1);
} catch {}
let pipeline32 = await device0.createRenderPipelineAsync({
  label: '\uf45c\u088c\u08af\u087e\u{1f785}',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule4,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'zero'},
  },
  writeMask: 0,
}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rg16float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba16uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule4,
    buffers: [
      {arrayStride: 156, attributes: [{format: 'uint16x2', offset: 12, shaderLocation: 5}]},
      {arrayStride: 236, stepMode: 'instance', attributes: []},
      {arrayStride: 108, stepMode: 'instance', attributes: []},
      {arrayStride: 624, attributes: []},
      {arrayStride: 192, stepMode: 'instance', attributes: []},
      {arrayStride: 220, stepMode: 'instance', attributes: []},
      {arrayStride: 1088, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint8x2', offset: 236, shaderLocation: 7},
          {format: 'float16x2', offset: 172, shaderLocation: 15},
        ],
      },
    ],
  },
});
try {
  await promise9;
} catch {}
let computePassEncoder19 = commandEncoder32.beginComputePass({label: '\u{1f9fe}\u0740\u761e\u8ed3\u0582\u0d29\uf92a\u4865\ud51a\u{1f6cc}\u4d37'});
try {
computePassEncoder12.setPipeline(pipeline0);
} catch {}
try {
commandEncoder34.copyTextureToTexture({
  texture: texture15,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 14},
  aspect: 'all',
},
{
  texture: texture15,
  mipLevel: 0,
  origin: {x: 14, y: 130, z: 56},
  aspect: 'all',
},
{width: 32, height: 66, depthOrArrayLayers: 29});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 134780, new DataView(new ArrayBuffer(10126)), 2347, 308);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 383 */
{offset: 383, bytesPerRow: 110}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
canvas2.height = 1397;
let pipelineLayout4 = device0.createPipelineLayout({label: '\u0e96\u8758', bindGroupLayouts: []});
let texture21 = device0.createTexture({
  label: '\u7bfd\u2fe8\ubb7e\uda48',
  size: {width: 660, height: 480, depthOrArrayLayers: 124},
  mipLevelCount: 7,
  dimension: '2d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rg8uint'],
});
let textureView46 = texture16.createView({label: '\u662d\u9547\u0da9\u{1fed3}\u{1fc4a}\u5adb\u0fe8', dimension: '1d'});
let computePassEncoder20 = commandEncoder24.beginComputePass({label: '\ubaad\u0e6d'});
try {
renderBundleEncoder14.setBindGroup(2, bindGroup11);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 1,
  origin: {x: 4, y: 5, z: 12},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 854 */
{offset: 854, bytesPerRow: 298}, {width: 138, height: 72, depthOrArrayLayers: 0});
} catch {}
let textureView47 = texture21.createView({label: '\u0d83\udaa9', dimension: '2d', baseMipLevel: 2, mipLevelCount: 4, baseArrayLayer: 48});
try {
renderBundleEncoder12.setBindGroup(3, bindGroup7, new Uint32Array(4470), 3935, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let pipeline33 = device0.createComputePipeline({
  label: '\u72e5\ue9de\u{1ffd2}\u664f\uc1bc\u8568\u792e',
  layout: pipelineLayout4,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let texture22 = device0.createTexture({
  size: [1320, 960, 124],
  mipLevelCount: 11,
  format: 'depth16unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['depth16unorm', 'depth16unorm', 'depth16unorm'],
});
let textureView48 = texture6.createView({
  label: '\u075a\u347f\u{1fcef}\uc4f4\ue4a4\u{1ff85}\uf5fd',
  dimension: '2d',
  baseMipLevel: 2,
  mipLevelCount: 4,
  baseArrayLayer: 122,
});
let computePassEncoder21 = commandEncoder28.beginComputePass({label: '\u071e\u0c68\u48a5\uc028'});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({
  label: '\u{1fbda}\u1902\u511c\u2f0d\u{1f70d}\u{1fa09}\u5d4a\u7cce\u63a7\ufadb',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  stencilReadOnly: true,
});
let renderBundle31 = renderBundleEncoder15.finish({label: '\u{1fef1}\u0bf7\u02aa\ue187\u0150'});
try {
commandEncoder17.resolveQuerySet(querySet11, 887, 328, buffer1, 13824);
} catch {}
let bindGroup12 = device0.createBindGroup({layout: bindGroupLayout1, entries: []});
let renderBundle32 = renderBundleEncoder2.finish({label: '\u8d7a\u0c28\uea68\u1405\uecb3\u{1fcd8}\u0b7f\u0705\u381b\ud628\u2ff3'});
let sampler21 = device0.createSampler({
  label: '\u{1f7c4}\ued47\u62c1\u5cbc\udb7b\u2e7d',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 11.26,
  lodMaxClamp: 83.75,
  compare: 'equal',
});
try {
computePassEncoder10.setBindGroup(1, bindGroup5);
} catch {}
try {
computePassEncoder16.setBindGroup(1, bindGroup7, new Uint32Array(6099), 2877, 0);
} catch {}
try {
buffer4.unmap();
} catch {}
try {
commandEncoder17.copyTextureToBuffer({
  texture: texture17,
  mipLevel: 1,
  origin: {x: 7, y: 17, z: 16},
  aspect: 'all',
}, {
  /* bytesInLastRow: 898 widthInBlocks: 449 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 224366 */
  offset: 8428,
  bytesPerRow: 1024,
  rowsPerImage: 337,
  buffer: buffer1,
}, {width: 449, height: 211, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder31.clearBuffer(buffer2, 121136, 1528);
} catch {}
try {
computePassEncoder16.insertDebugMarker('\u733e');
} catch {}
try {
canvas5.getContext('bitmaprenderer');
} catch {}
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], sampleCount: 4});
try {
commandEncoder34.copyTextureToBuffer({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2534 widthInBlocks: 1267 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 13346 */
  offset: 13346,
  rowsPerImage: 4,
  buffer: buffer6,
}, {width: 1267, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder21.copyTextureToTexture({
  texture: texture1,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 1,
  origin: {x: 10, y: 30, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 1,
  origin: {x: 1, y: 23, z: 17},
  aspect: 'all',
}, new ArrayBuffer(731_542), /* required buffer size: 731_542 */
{offset: 756, bytesPerRow: 548, rowsPerImage: 319}, {width: 151, height: 58, depthOrArrayLayers: 5});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 164}
*/
{
  source: video3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 0, y: 28, z: 10},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandBuffer13 = commandEncoder17.finish({label: '\ub4f0\u442f\ua521\u56b8\u3ff3\ue41c\u5979'});
let textureView49 = texture7.createView({label: '\u4eaa\u4da9\u0fd2\u{1f686}\u{1f8e6}\uef7f\u{1f66a}\u098f\u0774', dimension: '2d-array'});
let computePassEncoder22 = commandEncoder35.beginComputePass({label: '\u5912\ud21a\ufaa3\u{1fce1}\u5f5e\ua792'});
let externalTexture18 = device0.importExternalTexture({label: '\ub945\u{1f89e}\ud123\u{1fea4}\u97cf\ufb4b\u{1fe35}\u727b', source: videoFrame0});
try {
computePassEncoder10.setBindGroup(3, bindGroup2, new Uint32Array(4996), 1816, 0);
} catch {}
try {
computePassEncoder5.dispatchWorkgroups(3, 5, 5);
} catch {}
try {
renderBundleEncoder16.setBindGroup(1, bindGroup10, new Uint32Array(4415), 3504, 0);
} catch {}
try {
commandEncoder21.copyBufferToBuffer(buffer3, 67596, buffer1, 78508, 14980);
} catch {}
try {
commandEncoder36.copyTextureToTexture({
  texture: texture1,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 1,
  origin: {x: 62, y: 22, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder21.popDebugGroup();
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 5, height: 3, depthOrArrayLayers: 1}
*/
{
  source: img1,
  origin: { x: 22, y: 116 },
  flipY: true,
}, {
  texture: texture2,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext4 = canvas4.getContext('webgpu');
let img3 = await imageWithData(218, 120, '#fd447adf', '#a9bd3c9b');
let texture23 = device0.createTexture({
  label: '\u0acf\u0f3e\u{1f69f}\u17dc\u{1fb1b}\u{1fe1c}',
  size: {width: 1320, height: 960, depthOrArrayLayers: 1668},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm', 'rg8unorm'],
});
let externalTexture19 = device0.importExternalTexture({
  label: '\u8453\u{1f67e}\udefd\u808f\u{1fd1f}\u0ac9\u6856',
  source: videoFrame0,
  colorSpace: 'display-p3',
});
try {
computePassEncoder19.end();
} catch {}
try {
commandEncoder31.copyBufferToBuffer(buffer4, 7296, buffer1, 214072, 15436);
} catch {}
try {
commandEncoder21.copyBufferToTexture({
  /* bytesInLastRow: 330 widthInBlocks: 165 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 13392 */
  offset: 13392,
  bytesPerRow: 512,
  buffer: buffer4,
}, {
  texture: texture22,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 45},
  aspect: 'depth-only',
}, {width: 165, height: 120, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer10]);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder37 = device0.createCommandEncoder({label: '\u{1f687}\u250b\u37c7\u{1ff99}\u0740\u0ce3\u06c1\uee91\u0fb6\u3197'});
let textureView50 = texture5.createView({
  label: '\u{1fe0f}\uafcf\uff3e\u1c20\u5fe2\u3ba1\u0fa4\u{1f81a}\u0e14\u07ad\ufd02',
  dimension: '2d',
  mipLevelCount: 2,
  baseArrayLayer: 26,
});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({
  label: '\u555a\u8ae1\u{1ff81}\ub395\u2372\ubfac\u50fa\u6f38\u398c\u{1f746}',
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder10.setPipeline(pipeline10);
} catch {}
let arrayBuffer1 = buffer2.getMappedRange(99288, 5024);
try {
commandEncoder37.copyTextureToBuffer({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 32760 */
  offset: 32760,
  buffer: buffer3,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder31.copyTextureToTexture({
  texture: texture1,
  mipLevel: 9,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder25.resolveQuerySet(querySet6, 88, 354, buffer0, 21504);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder38 = device0.createCommandEncoder({label: '\uba41\u6a7a\ube4d\ue95a\u579c\u0f55\u1470\u99bd\ucad8\uab9d'});
try {
commandEncoder31.copyBufferToBuffer(buffer5, 110504, buffer1, 70820, 199944);
} catch {}
try {
commandEncoder38.resolveQuerySet(querySet8, 1533, 243, buffer0, 9216);
} catch {}
try {
device0.queue.submit([commandBuffer11]);
} catch {}
let video5 = await videoWithData();
let buffer7 = device0.createBuffer({size: 73852, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX});
let textureView51 = texture9.createView({label: '\u{1f950}\u2f8b\u{1faab}', dimension: '2d-array'});
try {
computePassEncoder9.setBindGroup(2, bindGroup7);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup8, new Uint32Array(3347), 1065, 0);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
commandEncoder25.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 6972 */
  offset: 6968,
  rowsPerImage: 86,
  buffer: buffer1,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder21.clearBuffer(buffer6, 2836, 22720);
} catch {}
try {
commandEncoder19.insertDebugMarker('\uc395');
} catch {}
let adapter2 = await navigator.gpu.requestAdapter({powerPreference: 'high-performance'});
let canvas6 = document.createElement('canvas');
let imageData6 = new ImageData(4, 164);
let texture24 = device0.createTexture({
  label: '\u5274\u{1f70c}\udb86\u5a4d\u44ef\u0584\ub27c\u12e3\u{1fbc5}\u1473',
  size: {width: 330, height: 240, depthOrArrayLayers: 124},
  mipLevelCount: 2,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let externalTexture20 = device0.importExternalTexture({label: '\u2597\ua261\u0363\uf03f', source: videoFrame1, colorSpace: 'srgb'});
try {
renderBundleEncoder12.setBindGroup(2, bindGroup0);
} catch {}
try {
renderBundleEncoder13.setBindGroup(0, bindGroup11, new Uint32Array(7909), 1027, 0);
} catch {}
try {
renderBundleEncoder14.setIndexBuffer(buffer7, 'uint16', 3_490, 21_799);
} catch {}
let pipeline34 = device0.createRenderPipeline({
  layout: pipelineLayout1,
  multisample: {count: 4},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-src-alpha'},
    alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16uint'}, {format: 'rgb10a2unorm', writeMask: 0}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'never', failOp: 'invert', depthFailOp: 'replace', passOp: 'replace'},
    stencilBack: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'zero', passOp: 'invert'},
    stencilReadMask: 1434173741,
    stencilWriteMask: 1501353868,
    depthBiasSlopeScale: 191.36899271865985,
  },
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 200, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 224, attributes: []},
      {arrayStride: 308, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 212,
        stepMode: 'vertex',
        attributes: [{format: 'uint32x3', offset: 56, shaderLocation: 13}],
      },
      {arrayStride: 424, attributes: []},
      {arrayStride: 276, attributes: []},
      {
        arrayStride: 88,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 0, shaderLocation: 4}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let textureView52 = texture15.createView({});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({
  label: '\u2337\uf9ce\u17de\u{1fd42}\u3af4\u3ac4\u05f1\u025e\udf96\u6c1d\u4f62',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder13.setVertexBuffer(1, buffer4);
} catch {}
try {
commandEncoder25.copyBufferToTexture({
  /* bytesInLastRow: 82 widthInBlocks: 41 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 306930 */
  offset: 6048,
  bytesPerRow: 256,
  rowsPerImage: 51,
  buffer: buffer1,
}, {
  texture: texture8,
  mipLevel: 2,
  origin: {x: 0, y: 4, z: 3},
  aspect: 'all',
}, {width: 41, height: 3, depthOrArrayLayers: 24});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 13}
*/
{
  source: canvas3,
  origin: { x: 8, y: 15 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 3,
  origin: {x: 25, y: 2, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 22, depthOrArrayLayers: 0});
} catch {}
let pipeline35 = await device0.createComputePipelineAsync({
  label: '\u{1f7c9}\uae52\u636e\u585c\u0991\u{1f671}\ue9be\u0298',
  layout: pipelineLayout3,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let adapter3 = await navigator.gpu.requestAdapter({});
try {
computePassEncoder20.setBindGroup(0, bindGroup12, new Uint32Array(5008), 1117, 0);
} catch {}
let commandEncoder39 = device0.createCommandEncoder({label: '\u0982\u92da\ue5f8\u0527'});
let texture25 = device0.createTexture({
  label: '\u34de\u468b\ub214',
  size: {width: 1320, height: 960, depthOrArrayLayers: 124},
  mipLevelCount: 3,
  format: 'rg8snorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg8snorm'],
});
let externalTexture21 = device0.importExternalTexture({
  label: '\u66bc\u{1f61e}\u{1f6c2}\u0794\u0749\udb16\u021e',
  source: videoFrame1,
  colorSpace: 'display-p3',
});
let gpuCanvasContext5 = canvas6.getContext('webgpu');
let img4 = await imageWithData(287, 177, '#0df0efc5', '#0a7f181f');
let bindGroup13 = device0.createBindGroup({label: '\u584b\u9929\u0f25\u{1fd9e}\uc80d', layout: bindGroupLayout5, entries: []});
let commandEncoder40 = device0.createCommandEncoder({label: '\uf435\u0978\u{1f7cd}\u0128\u1689\u4b10\u0946\u0ff5\u{1fc11}\u0908'});
let textureView53 = texture25.createView({label: '\u9753\u856e\u04e3\uac72', dimension: '2d', baseMipLevel: 2, baseArrayLayer: 111});
try {
renderBundleEncoder17.setVertexBuffer(0, buffer4);
} catch {}
try {
commandEncoder37.copyBufferToTexture({
  /* bytesInLastRow: 430 widthInBlocks: 215 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 93314 */
  offset: 15060,
  bytesPerRow: 512,
  buffer: buffer3,
}, {
  texture: texture5,
  mipLevel: 0,
  origin: {x: 94, y: 4, z: 6},
  aspect: 'all',
}, {width: 215, height: 153, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder25.copyTextureToTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder40.resolveQuerySet(querySet4, 2, 14, buffer0, 74752);
} catch {}
let videoFrame2 = new VideoFrame(videoFrame0, {timestamp: 0});
let commandEncoder41 = device0.createCommandEncoder({label: '\uc469\ue4f1\u0055'});
let textureView54 = texture23.createView({label: '\u{1fcd3}\u0976\u0c2c\uc310\u0b16', baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1});
try {
renderBundleEncoder12.setBindGroup(2, bindGroup13, []);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(2, buffer7, 23_016, 19_379);
} catch {}
try {
commandEncoder31.pushDebugGroup('\u6963');
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
document.body.prepend(video4);
let video6 = await videoWithData();
try {
commandEncoder36.copyTextureToTexture({
  texture: texture5,
  mipLevel: 2,
  origin: {x: 13, y: 26, z: 15},
  aspect: 'all',
},
{
  texture: texture21,
  mipLevel: 2,
  origin: {x: 8, y: 22, z: 0},
  aspect: 'all',
},
{width: 47, height: 69, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder39.clearBuffer(buffer1);
} catch {}
try {
commandEncoder39.resolveQuerySet(querySet0, 47, 412, buffer0, 35840);
} catch {}
try {
commandEncoder41.pushDebugGroup('\u06a8');
} catch {}
let pipeline36 = await device0.createRenderPipelineAsync({
  label: '\u5867\u010d\u86f2\u06f5\ud69e\u9d9f\u0c40\u0210',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: 0}, {format: 'rg16float', writeMask: 0}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'equal',
    stencilFront: {compare: 'greater-equal', failOp: 'decrement-clamp', depthFailOp: 'increment-wrap', passOp: 'invert'},
    stencilBack: {failOp: 'increment-clamp', depthFailOp: 'increment-wrap', passOp: 'increment-wrap'},
    stencilReadMask: 2270440290,
    stencilWriteMask: 1040403974,
    depthBiasSlopeScale: -20.176123613513752,
    depthBiasClamp: 403.2108505522622,
  },
  vertex: {
    module: shaderModule5,
    buffers: [
      {
        arrayStride: 188,
        stepMode: 'vertex',
        attributes: [{format: 'uint32x4', offset: 40, shaderLocation: 9}],
      },
      {arrayStride: 60, attributes: []},
      {
        arrayStride: 420,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint32x4', offset: 48, shaderLocation: 2},
          {format: 'uint32x2', offset: 96, shaderLocation: 4},
        ],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 372, attributes: []},
      {arrayStride: 96, attributes: []},
      {arrayStride: 516, stepMode: 'instance', attributes: []},
      {
        arrayStride: 212,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 20, shaderLocation: 7},
          {format: 'unorm16x2', offset: 4, shaderLocation: 8},
          {format: 'unorm8x4', offset: 8, shaderLocation: 1},
          {format: 'sint32x4', offset: 28, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'ccw', cullMode: 'back'},
});
try {
gpuCanvasContext4.unconfigure();
} catch {}
let video7 = await videoWithData();
let textureView55 = texture21.createView({baseMipLevel: 4, mipLevelCount: 2, baseArrayLayer: 79, arrayLayerCount: 13});
let renderBundle33 = renderBundleEncoder2.finish({label: '\u0af8\ub4cd\u1be2'});
let sampler22 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 89.18,
  lodMaxClamp: 91.80,
  maxAnisotropy: 8,
});
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer1, /* required buffer size: 570 */
{offset: 570}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 124}
*/
{
  source: videoFrame1,
  origin: { x: 0, y: 3 },
  flipY: true,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 65, y: 32, z: 29},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline37 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule2, entryPoint: 'compute0'}});
let commandEncoder42 = device0.createCommandEncoder({label: '\ucdca\u{1fab3}\uc3e2\u0996'});
let sampler23 = device0.createSampler({
  label: '\ub4e1\ua476\u4ccc\ud4c2\u{1f7dc}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMaxClamp: 94.66,
});
try {
renderBundleEncoder16.setVertexBuffer(3, buffer4, 0, 13_957);
} catch {}
try {
commandEncoder42.clearBuffer(buffer6, 18640, 7336);
} catch {}
try {
commandEncoder37.resolveQuerySet(querySet6, 985, 105, buffer0, 112896);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm'],
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 4,
  origin: {x: 0, y: 1, z: 3},
  aspect: 'all',
}, new ArrayBuffer(360_391), /* required buffer size: 360_391 */
{offset: 16, bytesPerRow: 85, rowsPerImage: 157}, {width: 15, height: 1, depthOrArrayLayers: 28});
} catch {}
let pipeline38 = await promise7;
video6.width = 84;
let commandEncoder43 = device0.createCommandEncoder({label: '\u{1fbb3}\u0261\uc515\u0563'});
try {
computePassEncoder5.dispatchWorkgroups(2, 1, 2);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(7, buffer4);
} catch {}
try {
commandEncoder32.copyTextureToTexture({
  texture: texture23,
  mipLevel: 1,
  origin: {x: 120, y: 155, z: 75},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 10},
  aspect: 'all',
},
{width: 11, height: 19, depthOrArrayLayers: 26});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 33048, new Int16Array(52533), 35733);
} catch {}
let texture26 = device0.createTexture({
  size: {width: 660, height: 480, depthOrArrayLayers: 1754},
  mipLevelCount: 10,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint', 'rg8uint'],
});
let textureView56 = texture12.createView({
  label: '\u45a3\u28e5\u1539\u2fe1\u0375\u09e1',
  baseMipLevel: 2,
  mipLevelCount: 2,
  baseArrayLayer: 34,
  arrayLayerCount: 67,
});
try {
computePassEncoder0.dispatchWorkgroups(5, 2, 3);
} catch {}
try {
computePassEncoder14.end();
} catch {}
try {
renderBundleEncoder17.setBindGroup(1, bindGroup10);
} catch {}
try {
commandEncoder32.copyBufferToBuffer(buffer3, 91776, buffer7, 48632, 680);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 502 */
{offset: 502, bytesPerRow: 1686}, {width: 393, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline39 = device0.createComputePipeline({
  label: '\ufe7e\uee88',
  layout: pipelineLayout0,
  compute: {module: shaderModule6, entryPoint: 'compute0', constants: {}},
});
let pipeline40 = device0.createRenderPipeline({
  label: '\ube7b\u0453',
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'one-minus-constant'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'zero'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint'}, {format: 'rg16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule6,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 2048, attributes: [{format: 'uint8x2', offset: 534, shaderLocation: 10}]},
      {arrayStride: 396, attributes: [{format: 'float16x4', offset: 144, shaderLocation: 15}]},
      {
        arrayStride: 208,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32x4', offset: 84, shaderLocation: 8},
          {format: 'unorm8x4', offset: 16, shaderLocation: 12},
          {format: 'uint32x4', offset: 32, shaderLocation: 13},
          {format: 'unorm8x4', offset: 4, shaderLocation: 14},
          {format: 'float32x4', offset: 4, shaderLocation: 3},
        ],
      },
      {arrayStride: 396, stepMode: 'instance', attributes: []},
      {
        arrayStride: 252,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 20, shaderLocation: 9}],
      },
      {arrayStride: 744, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x4', offset: 572, shaderLocation: 6}],
      },
      {
        arrayStride: 208,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 20, shaderLocation: 11},
          {format: 'float32x2', offset: 0, shaderLocation: 7},
          {format: 'float32', offset: 8, shaderLocation: 4},
          {format: 'unorm16x2', offset: 56, shaderLocation: 5},
          {format: 'sint8x2', offset: 98, shaderLocation: 2},
          {format: 'snorm8x4', offset: 0, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw'},
});
let bindGroup14 = device0.createBindGroup({
  label: '\uae41\u0464',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer3, offset: 70400, size: 3960}}],
});
let commandEncoder44 = device0.createCommandEncoder({label: '\u35dd\ua879\u0407\u5696\u080b\u{1fd9a}\u718b\u40e1\u{1fded}\u0fe9\u3f18'});
let renderBundle34 = renderBundleEncoder16.finish({label: '\u{1fe5a}\ufede\u{1f909}\u2975\u0dec\u2e82'});
try {
computePassEncoder20.end();
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(0, buffer7, 33_604);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder36.copyBufferToBuffer(buffer3, 49556, buffer6, 5076, 4752);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 9620, new DataView(new ArrayBuffer(29357)), 20286, 284);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture18,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 7},
  aspect: 'all',
}, new ArrayBuffer(179_717), /* required buffer size: 179_717 */
{offset: 481, bytesPerRow: 216, rowsPerImage: 86}, {width: 43, height: 56, depthOrArrayLayers: 10});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 53}
*/
{
  source: imageData6,
  origin: { x: 0, y: 21 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 1,
  origin: {x: 84, y: 51, z: 15},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 10, depthOrArrayLayers: 0});
} catch {}
let pipeline41 = device0.createComputePipeline({
  label: '\uefb5\u{1feaf}',
  layout: pipelineLayout2,
  compute: {module: shaderModule6, entryPoint: 'compute0', constants: {}},
});
let img5 = await imageWithData(296, 242, '#65a60779', '#4ab23c57');
let externalTexture22 = device0.importExternalTexture({label: '\u{1f730}\uaaa1\u{1f7ee}\u1ff9\u7ea4', source: videoFrame0, colorSpace: 'display-p3'});
try {
computePassEncoder13.setBindGroup(1, bindGroup11);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline19);
} catch {}
try {
commandEncoder25.copyBufferToTexture({
  /* bytesInLastRow: 232 widthInBlocks: 29 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 329104 */
  offset: 13224,
  bytesPerRow: 256,
  rowsPerImage: 95,
  buffer: buffer5,
}, {
  texture: texture6,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 33},
  aspect: 'all',
}, {width: 29, height: 94, depthOrArrayLayers: 13});
} catch {}
let canvas7 = document.createElement('canvas');
let promise12 = adapter1.requestAdapterInfo();
try {
canvas7.getContext('webgl2');
} catch {}
let commandEncoder45 = device0.createCommandEncoder({label: '\u6182\u6035\u9787\u{1f827}\u2cd7\u{1fec4}\u0d1b\u{1feec}\u0495'});
try {
renderBundleEncoder18.setBindGroup(2, bindGroup14);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(7, buffer7, 4_532, 23_435);
} catch {}
try {
texture6.destroy();
} catch {}
try {
commandEncoder45.copyBufferToBuffer(buffer5, 31028, buffer1, 293808, 9224);
} catch {}
try {
commandEncoder37.copyTextureToBuffer({
  texture: texture25,
  mipLevel: 1,
  origin: {x: 2, y: 18, z: 16},
  aspect: 'all',
}, {
  /* bytesInLastRow: 670 widthInBlocks: 335 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 210238 */
  offset: 53920,
  bytesPerRow: 1024,
  rowsPerImage: 185,
  buffer: buffer1,
}, {width: 335, height: 153, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder44.resolveQuerySet(querySet9, 165, 490, buffer1, 18176);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 50624, new Int16Array(37783), 8706, 784);
} catch {}
let pipeline42 = await device0.createRenderPipelineAsync({
  label: '\uedba\u91b9\u3b46\u02a6\ucd9f\u{1f6b5}\u0852',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: 0}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'stencil8',
    depthCompare: 'always',
    stencilFront: {compare: 'never', failOp: 'increment-wrap', depthFailOp: 'increment-wrap', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'less-equal', failOp: 'replace', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'},
    stencilReadMask: 777832100,
    stencilWriteMask: 431991958,
    depthBias: 1000425521,
    depthBiasSlopeScale: 420.6209877862781,
  },
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 0, attributes: [{format: 'snorm16x4', offset: 72, shaderLocation: 14}]},
      {arrayStride: 1568, stepMode: 'instance', attributes: []},
      {arrayStride: 344, attributes: []},
      {arrayStride: 432, stepMode: 'instance', attributes: []},
      {arrayStride: 516, attributes: []},
      {arrayStride: 124, stepMode: 'instance', attributes: []},
      {arrayStride: 1004, stepMode: 'instance', attributes: []},
      {
        arrayStride: 320,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 20, shaderLocation: 7}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'ccw', cullMode: 'front'},
});
let offscreenCanvas3 = new OffscreenCanvas(927, 467);
try {
renderBundleEncoder17.insertDebugMarker('\u{1f74b}');
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 0,
  origin: {x: 14, y: 2, z: 4},
  aspect: 'all',
}, new ArrayBuffer(56), /* required buffer size: 177_186 */
{offset: 658, bytesPerRow: 1140}, {width: 242, height: 155, depthOrArrayLayers: 1});
} catch {}
let querySet16 = device0.createQuerySet({label: '\u0047\u{1f823}', type: 'occlusion', count: 2457});
let texture27 = device0.createTexture({
  size: [165, 120, 806],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder16.setBindGroup(3, bindGroup13, []);
} catch {}
try {
computePassEncoder21.end();
} catch {}
try {
commandEncoder24.clearBuffer(buffer2, 125720, 2352);
} catch {}
try {
commandEncoder19.resolveQuerySet(querySet8, 890, 244, buffer1, 5888);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 63 },
  flipY: true,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let renderBundle35 = renderBundleEncoder18.finish({});
try {
computePassEncoder10.setBindGroup(0, bindGroup4, []);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let imageBitmap4 = await createImageBitmap(canvas1);
let externalTexture23 = device0.importExternalTexture({label: '\ub2f3\u1a93\u8082\u{1ffc1}', source: videoFrame1, colorSpace: 'srgb'});
try {
computePassEncoder5.dispatchWorkgroupsIndirect(buffer5, 50712);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup1);
} catch {}
try {
renderBundleEncoder17.setIndexBuffer(buffer3, 'uint32', 23_232, 15_300);
} catch {}
try {
texture18.destroy();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture21,
  mipLevel: 2,
  origin: {x: 11, y: 1, z: 9},
  aspect: 'all',
}, new ArrayBuffer(80), /* required buffer size: 274_668 */
{offset: 427, bytesPerRow: 271, rowsPerImage: 159}, {width: 130, height: 58, depthOrArrayLayers: 7});
} catch {}
let commandEncoder46 = device0.createCommandEncoder({label: '\u03c0\ud0db\u97c7\u0715'});
let sampler24 = device0.createSampler({
  label: '\ua57a\u50c8\u{1f724}\u0b40\u4b26\u0bd4\u5099\u6dd0\u05d7',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 76.24,
  lodMaxClamp: 87.04,
});
try {
computePassEncoder9.end();
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup14);
} catch {}
try {
renderBundleEncoder14.setVertexBuffer(4_294_967_295, undefined, 66_488_013);
} catch {}
try {
commandEncoder37.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3204 */
  offset: 3204,
  buffer: buffer4,
}, {
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder26.clearBuffer(buffer6, 14848, 9236);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 1872, new Int16Array(59503), 38516, 296);
} catch {}
let gpuCanvasContext6 = offscreenCanvas3.getContext('webgpu');
let querySet17 = device0.createQuerySet({label: '\u3361\u04fb\u4cfc\u{1fb2b}\uc52d\u3c60\u0701', type: 'occlusion', count: 3263});
let computePassEncoder23 = commandEncoder32.beginComputePass({label: '\u{1fb83}\uf551\u83a9\u{1f725}\u8a9b'});
let renderBundle36 = renderBundleEncoder10.finish({label: '\u7553\u{1fd6e}\u{1fbf4}\u{1f9f6}\u0586\u5e84\u{1fee0}\u0464\uffc3'});
try {
renderBundleEncoder13.setBindGroup(1, bindGroup3);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline22);
} catch {}
try {
renderBundleEncoder17.setVertexBuffer(4, buffer7);
} catch {}
try {
renderBundleEncoder17.setBindGroup(3, bindGroup8);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(6, buffer4, 26_796);
} catch {}
try {
  await device0.popErrorScope();
} catch {}
let imageBitmap5 = await createImageBitmap(offscreenCanvas0);
let commandEncoder47 = device0.createCommandEncoder({label: '\u3dd2\u8dca\u278c\uaf92\u0f03\u05d7\uea89'});
let textureView57 = texture16.createView({label: '\u{1ff72}\u326e\u5725\u0e53\u00b5\ufe44\u26db'});
try {
computePassEncoder5.end();
} catch {}
try {
computePassEncoder18.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder12.setBindGroup(1, bindGroup4);
} catch {}
let arrayBuffer2 = buffer2.getMappedRange(95112, 1044);
try {
commandEncoder47.copyTextureToTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 20, y: 14, z: 195},
  aspect: 'all',
},
{
  texture: texture15,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 43},
  aspect: 'all',
},
{width: 113, height: 61, depthOrArrayLayers: 11});
} catch {}
try {
computePassEncoder0.dispatchWorkgroups(5, 4, 2);
} catch {}
try {
commandEncoder43.copyTextureToTexture({
  texture: texture18,
  mipLevel: 2,
  origin: {x: 4, y: 1, z: 13},
  aspect: 'all',
},
{
  texture: texture10,
  mipLevel: 4,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 8, height: 3, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder19.clearBuffer(buffer3, 25232, 68404);
} catch {}
try {
commandEncoder21.resolveQuerySet(querySet16, 1059, 139, buffer1, 219392);
} catch {}
let pipeline43 = device0.createRenderPipeline({
  label: '\u9958\u0fb4\u1fbb',
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA}, {format: 'rg16float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba16uint', writeMask: 0}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'greater', failOp: 'replace', depthFailOp: 'zero', passOp: 'invert'},
    stencilBack: {failOp: 'zero', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'},
    stencilReadMask: 838055029,
    stencilWriteMask: 2831518099,
    depthBias: 992214869,
    depthBiasSlopeScale: 304.2738835024128,
  },
  vertex: {
    module: shaderModule0,
    buffers: [
      {arrayStride: 68, stepMode: 'instance', attributes: []},
      {arrayStride: 1272, attributes: []},
      {arrayStride: 240, stepMode: 'vertex', attributes: []},
      {arrayStride: 352, stepMode: 'vertex', attributes: []},
      {arrayStride: 328, stepMode: 'instance', attributes: []},
      {arrayStride: 224, stepMode: 'instance', attributes: []},
      {arrayStride: 540, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 1008,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 0, shaderLocation: 14},
          {format: 'sint16x2', offset: 44, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'},
});
try {
window.someLabel = externalTexture12.label;
} catch {}
let commandEncoder48 = device0.createCommandEncoder();
let texture28 = device0.createTexture({
  size: {width: 165, height: 120, depthOrArrayLayers: 124},
  mipLevelCount: 3,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder24 = commandEncoder21.beginComputePass();
let renderBundle37 = renderBundleEncoder14.finish();
try {
renderBundleEncoder13.setVertexBuffer(2, buffer5, 6_332);
} catch {}
try {
commandEncoder36.clearBuffer(buffer6, 3624, 2112);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 6}
*/
{
  source: img2,
  origin: { x: 6, y: 8 },
  flipY: false,
}, {
  texture: texture27,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder49 = device0.createCommandEncoder({label: '\u04bc\u6bb6\u3c55\uf378\udee9\u0050\u4263\u096e\u0792\u{1fdfa}\u0118'});
let textureView58 = texture15.createView({baseMipLevel: 1});
let renderBundle38 = renderBundleEncoder4.finish({label: '\u{1f9e4}\u231b\u5083'});
let sampler25 = device0.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 52.07,
  lodMaxClamp: 98.05,
});
try {
commandEncoder11.copyTextureToTexture({
  texture: texture1,
  mipLevel: 1,
  origin: {x: 28, y: 57, z: 94},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 4,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 11, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder10.resolveQuerySet(querySet17, 277, 6, buffer1, 48896);
} catch {}
let textureView59 = texture0.createView({
  label: '\u0405\u6869\ucbd7\u056c\u2a83\ud77d\u0eed',
  dimension: '2d',
  format: 'rg32sint',
  baseMipLevel: 1,
  baseArrayLayer: 103,
});
let computePassEncoder25 = commandEncoder45.beginComputePass();
try {
commandEncoder37.copyBufferToBuffer(buffer5, 309092, buffer2, 55920, 14120);
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 1448 widthInBlocks: 362 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 31208 */
  offset: 31208,
  buffer: buffer4,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 54, y: 0, z: 0},
  aspect: 'all',
}, {width: 362, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder39.copyTextureToTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder38.clearBuffer(buffer2, 5112, 39264);
} catch {}
try {
commandEncoder25.resolveQuerySet(querySet15, 1315, 233, buffer1, 124160);
} catch {}
let commandEncoder50 = device0.createCommandEncoder({label: '\u{1fffd}\u0f54\ueb52\u0b71'});
let querySet18 = device0.createQuerySet({label: '\u6ce9\u{1fe59}\ud2a8\u{1ff34}', type: 'occlusion', count: 3650});
let textureView60 = texture23.createView({label: '\u7885\u0491\u{1fb56}\u{1f680}\uf274\u{1feb6}\u82f0\u4115\u02b7\u0fd3\u0cf7'});
let renderBundle39 = renderBundleEncoder17.finish({label: '\ucb1e\u3993\u1e83\u0553\u4afc\u0b89'});
try {
computePassEncoder0.dispatchWorkgroupsIndirect(buffer5, 320040);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer7, 'uint32', 15_592, 8_352);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(0, buffer4);
} catch {}
try {
device0.queue.submit([commandBuffer13]);
} catch {}
try {
  await promise11;
} catch {}
let shaderModule7 = device0.createShaderModule({
  label: '\u0caa\u0642\u0587\u562a\u{1f901}\ufacd\u0039',
  code: `@group(0) @binding(954)
var<storage, read_write> field3: array<u32>;
@group(1) @binding(803)
var<storage, read_write> function1: array<u32>;
@group(1) @binding(416)
var<storage, read_write> function2: array<u32>;

@compute @workgroup_size(4, 3, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S7 {
  @location(11) f0: vec2<u32>,
  @location(8) f1: f16,
  @location(12) f2: f16,
  @location(4) f3: vec4<f16>,
  @builtin(sample_mask) f4: u32,
  @location(9) f5: vec3<f32>,
  @builtin(front_facing) f6: bool,
  @builtin(position) f7: vec4<f32>
}
struct FragmentOutput0 {
  @location(5) f0: vec4<f32>,
  @location(3) f1: vec4<u32>,
  @location(1) f2: vec4<i32>,
  @location(0) f3: f32,
  @location(4) f4: vec4<u32>,
  @location(2) f5: vec4<f32>
}

@fragment
fn fragment0(@location(10) a0: vec3<u32>, @location(14) a1: vec3<i32>, @location(3) a2: vec4<i32>, @location(0) a3: f16, a4: S7) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S6 {
  @location(14) f0: vec4<f32>,
  @builtin(vertex_index) f1: u32,
  @location(12) f2: vec2<f32>,
  @location(8) f3: vec3<u32>,
  @location(9) f4: f32,
  @location(3) f5: vec3<f16>,
  @location(0) f6: vec3<i32>,
  @location(13) f7: vec4<f16>,
  @location(11) f8: vec2<u32>,
  @location(4) f9: vec2<f16>,
  @location(2) f10: f16,
  @location(6) f11: vec3<f16>,
  @builtin(instance_index) f12: u32,
  @location(15) f13: f16,
  @location(1) f14: vec3<i32>,
  @location(7) f15: vec4<i32>
}
struct VertexOutput0 {
  @location(4) f56: vec4<f16>,
  @builtin(position) f57: vec4<f32>,
  @location(10) f58: vec3<u32>,
  @location(9) f59: vec3<f32>,
  @location(8) f60: f16,
  @location(12) f61: f16,
  @location(0) f62: f16,
  @location(11) f63: vec2<u32>,
  @location(14) f64: vec3<i32>,
  @location(3) f65: vec4<i32>
}

@vertex
fn vertex0(@location(5) a0: vec3<f32>, @location(10) a1: vec2<u32>, a2: S6) -> VertexOutput0 {
  return VertexOutput0();
}

`,
});
let commandEncoder51 = device0.createCommandEncoder({label: '\u{1fc7e}\u08e0\ud820\u8f96'});
let textureView61 = texture23.createView({baseMipLevel: 1});
try {
computePassEncoder12.setBindGroup(3, bindGroup5, new Uint32Array(6833), 5029, 0);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
try {
commandEncoder41.copyBufferToTexture({
  /* bytesInLastRow: 374 widthInBlocks: 187 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 210292 */
  offset: 30206,
  bytesPerRow: 512,
  rowsPerImage: 202,
  buffer: buffer5,
}, {
  texture: texture15,
  mipLevel: 0,
  origin: {x: 24, y: 10, z: 36},
  aspect: 'all',
}, {width: 187, height: 150, depthOrArrayLayers: 2});
} catch {}
try {
device0.queue.writeBuffer(buffer6, 1164, new Float32Array(54715), 15710, 396);
} catch {}
let commandEncoder52 = device0.createCommandEncoder({label: '\u0330\u1962\u1b5d\u062d\u0e8a\u{1f633}\u1c14\u{1fbc1}\u5923'});
let textureView62 = texture0.createView({
  label: '\u7330\u0f9e\u{1f846}\u1cf9\ua7c1\u1bcd\u0ad1\uff97\u{1ff9d}',
  aspect: 'all',
  baseArrayLayer: 22,
  arrayLayerCount: 39,
});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({label: '\u{1fe61}\ua8d0', colorFormats: ['r32float']});
try {
computePassEncoder18.setBindGroup(0, bindGroup7, new Uint32Array(1105), 736, 0);
} catch {}
try {
commandEncoder31.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 376796 */
  offset: 476,
  bytesPerRow: 512,
  rowsPerImage: 35,
  buffer: buffer5,
}, {
  texture: texture22,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 55},
  aspect: 'depth-only',
}, {width: 5, height: 0, depthOrArrayLayers: 22});
} catch {}
try {
commandEncoder52.clearBuffer(buffer1, 238652);
} catch {}
try {
computePassEncoder22.insertDebugMarker('\u{1ff29}');
} catch {}
let shaderModule8 = device0.createShaderModule({
  code: `@group(2) @binding(954)
var<storage, read_write> n2: array<u32>;
@group(0) @binding(954)
var<storage, read_write> local3: array<u32>;

@compute @workgroup_size(1, 4, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(4) f0: vec2<u32>,
  @location(3) f1: vec4<u32>,
  @location(5) f2: vec4<f32>,
  @location(0) f3: vec4<f32>,
  @location(2) f4: vec4<f32>,
  @location(1) f5: vec4<i32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(7) f66: f16,
  @location(4) f67: vec4<f32>,
  @location(0) f68: f32,
  @location(11) f69: vec3<i32>,
  @location(9) f70: vec2<f32>,
  @location(13) f71: f16,
  @location(5) f72: f16,
  @builtin(position) f73: vec4<f32>
}

@vertex
fn vertex0(@location(2) a0: f16, @location(5) a1: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let commandBuffer14 = commandEncoder34.finish();
try {
renderBundleEncoder12.setBindGroup(2, bindGroup5);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 2, height: 1, depthOrArrayLayers: 12}
*/
{
  source: video2,
  origin: { x: 1, y: 1 },
  flipY: true,
}, {
  texture: texture27,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData7 = new ImageData(156, 164);
let sampler26 = device0.createSampler({
  label: '\u2c11\u{1f9db}\u1fb0\u443f\u7199\u574d',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 44.36,
  lodMaxClamp: 62.20,
});
try {
device0.queue.submit([commandBuffer12]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture27,
  mipLevel: 1,
  origin: {x: 37, y: 0, z: 3},
  aspect: 'all',
}, new BigInt64Array(arrayBuffer1), /* required buffer size: 3_584_510 */
{offset: 496, bytesPerRow: 32, rowsPerImage: 301}, {width: 7, height: 29, depthOrArrayLayers: 373});
} catch {}
try {
  await promise10;
} catch {}
let bindGroup15 = device0.createBindGroup({label: '\u0be0\u{1fb59}\u02e8\ue563\ua745\u64f6\u0c17', layout: bindGroupLayout5, entries: []});
let commandEncoder53 = device0.createCommandEncoder({label: '\u5bd4\u{1fa86}\u0bf5\ue1c9\ueb46\u{1f961}\u05f2\u0f88'});
let texture29 = device0.createTexture({
  label: '\uccbd\u{1f7b6}\u83b1\uae98\u310e\u{1f7c7}\u7c06\ueb55',
  size: [1320, 960, 72],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgb10a2unorm', 'rgb10a2unorm', 'rgb10a2unorm'],
});
let textureView63 = texture13.createView({label: '\u256c\u6057\u0498\u0265\uc105\ud4d6\u{1fb61}\u{1ff45}'});
let renderBundle40 = renderBundleEncoder11.finish({label: '\ue2b1\u{1f638}\u07c0\ud60e\u{1ff8c}\ufcf9\u{1f6c2}\u0539\u85da\uf9dd\ue794'});
try {
computePassEncoder0.dispatchWorkgroups(5, 2, 4);
} catch {}
try {
computePassEncoder23.end();
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline13);
} catch {}
let arrayBuffer3 = buffer2.getMappedRange(104312, 788);
try {
commandEncoder11.clearBuffer(buffer7);
} catch {}
let commandEncoder54 = device0.createCommandEncoder();
let textureView64 = texture18.createView({label: '\u8372\u{1f883}\uf1fa', baseMipLevel: 2, baseArrayLayer: 27, arrayLayerCount: 73});
let computePassEncoder26 = commandEncoder39.beginComputePass();
let renderBundleEncoder20 = device0.createRenderBundleEncoder({
  label: '\uedc1\u{1f79b}\ufc12\u6239\uc815\u{1fad6}\uf20d\u0de5\u{1fcad}\ua5bf',
  colorFormats: ['rg16float', 'rgba16float'],
  depthReadOnly: true,
});
let externalTexture24 = device0.importExternalTexture({label: '\u4929\ud8fa\u0dd4\u0325\u0602\u6b1f\u09ad', source: videoFrame0, colorSpace: 'display-p3'});
try {
computePassEncoder0.setBindGroup(2, bindGroup13);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline1);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(5, buffer7, 0, 4_235);
} catch {}
try {
commandEncoder53.copyBufferToBuffer(buffer5, 336196, buffer3, 34052, 2996);
} catch {}
try {
commandEncoder48.resolveQuerySet(querySet18, 1317, 1284, buffer0, 111872);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 70, y: 27, z: 16},
  aspect: 'all',
}, new Int8Array(new ArrayBuffer(40)), /* required buffer size: 336_302 */
{offset: 467, bytesPerRow: 3575}, {width: 840, height: 94, depthOrArrayLayers: 1});
} catch {}
try {
  await promise12;
} catch {}
let querySet19 = device0.createQuerySet({
  label: '\ub9fc\ueeb5\ubc14\u80c9\u{1fb29}\u0201\uce44\u{1ffc6}\u3b63\u0b6a',
  type: 'occlusion',
  count: 3234,
});
let externalTexture25 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'});
try {
renderBundleEncoder13.draw(13, 824, 350, 31);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(4, buffer4, 69_828);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
commandEncoder11.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 1,
  origin: {x: 10, y: 14, z: 0},
  aspect: 'all',
},
{width: 84, height: 0, depthOrArrayLayers: 0});
} catch {}
let buffer8 = device0.createBuffer({
  label: '\u1984\u0dea\uce45\u{1fb33}',
  size: 135820,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let computePassEncoder27 = commandEncoder54.beginComputePass({label: '\u02f9\u046b\u{1fd33}\u{1f7cb}\uc97b\u061c'});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({label: '\u198f\u{1f9bc}', colorFormats: ['r32float'], depthReadOnly: false, stencilReadOnly: true});
let renderBundle41 = renderBundleEncoder10.finish({label: '\u4522\u946c\u0618\u{1f714}\ucd24\u0b3e\u{1f9af}\u0be5'});
try {
computePassEncoder13.end();
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer4, 0, 59_470);
} catch {}
try {
commandEncoder40.resolveQuerySet(querySet5, 81, 9, buffer0, 75008);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, new Float64Array(arrayBuffer3), /* required buffer size: 10 */
{offset: 10}, {width: 105, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let querySet20 = device0.createQuerySet({type: 'occlusion', count: 830});
let sampler27 = device0.createSampler({
  label: '\ucc0d\u0c91\u67c9\u8541',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 43.17,
  lodMaxClamp: 71.31,
  maxAnisotropy: 4,
});
try {
renderBundleEncoder12.setPipeline(pipeline16);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 67, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 788 */
{offset: 788, rowsPerImage: 284}, {width: 1180, height: 0, depthOrArrayLayers: 1});
} catch {}
let promise13 = device0.queue.onSubmittedWorkDone();
video3.width = 134;
let canvas8 = document.createElement('canvas');
try {
canvas8.getContext('2d');
} catch {}
let textureView65 = texture10.createView({baseMipLevel: 2, baseArrayLayer: 9, arrayLayerCount: 49});
try {
computePassEncoder0.setBindGroup(1, bindGroup5);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer5, 105_696);
} catch {}
try {
commandEncoder20.copyTextureToBuffer({
  texture: texture1,
  mipLevel: 0,
  origin: {x: 12, y: 1, z: 356},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2256 widthInBlocks: 282 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1192 */
  offset: 1192,
  bytesPerRow: 2304,
  buffer: buffer7,
}, {width: 282, height: 237, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture4,
  mipLevel: 1,
  origin: {x: 12, y: 18, z: 9},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 3,
  origin: {x: 7, y: 6, z: 0},
  aspect: 'all',
},
{width: 43, height: 6, depthOrArrayLayers: 11});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer3), /* required buffer size: 310 */
{offset: 310}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 124}
*/
{
  source: img5,
  origin: { x: 45, y: 24 },
  flipY: true,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 13, y: 12, z: 13},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 80, height: 76, depthOrArrayLayers: 0});
} catch {}
let commandEncoder55 = device0.createCommandEncoder({label: '\udc19\u{1fb1e}\u20ec\u3042\u{1fe80}\ucda2\u8562'});
let texture30 = device0.createTexture({
  label: '\u37d7\u0d56\ube4b\u24ad\ub7db\u0e07\uc736\uc965',
  size: {width: 330},
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView66 = texture28.createView({
  label: '\u8c1a\u084d\u4252\u6471\u005a\u{1ffa9}\u989a\u{1faf1}',
  dimension: '2d',
  aspect: 'all',
  baseMipLevel: 1,
  baseArrayLayer: 15,
});
let renderBundle42 = renderBundleEncoder21.finish({label: '\uf220\u88e2\u{1fd44}\ub329\u0128'});
try {
renderBundleEncoder13.drawIndexed(70, 33, 59, 243_222_174, 1_860_524_328);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(0, buffer6, 0);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 764, new DataView(new ArrayBuffer(22631)), 9098, 1600);
} catch {}
let pipeline44 = device0.createRenderPipeline({
  label: '\u0578\u{1fa54}\u09d0\u{1fc4f}\uaee4\u0ede',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16float'}, {format: 'rgba8sint', writeMask: GPUColorWrite.RED}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: 0}, {format: 'rg16uint'}, {format: 'rgb10a2unorm'}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {compare: 'less-equal', failOp: 'decrement-clamp', depthFailOp: 'invert', passOp: 'zero'},
    stencilBack: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'replace', passOp: 'decrement-clamp'},
    stencilReadMask: 2857268211,
    stencilWriteMask: 2045944289,
    depthBias: 1105792343,
    depthBiasSlopeScale: 289.929580927462,
    depthBiasClamp: 840.9784775621835,
  },
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 124, attributes: []},
      {arrayStride: 240, stepMode: 'instance', attributes: []},
      {arrayStride: 252, attributes: []},
      {arrayStride: 40, attributes: []},
      {arrayStride: 304, stepMode: 'instance', attributes: []},
      {arrayStride: 204, attributes: []},
      {arrayStride: 716, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 196,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 20, shaderLocation: 13},
          {format: 'sint16x4', offset: 40, shaderLocation: 4},
        ],
      },
    ],
  },
});
let commandEncoder56 = device0.createCommandEncoder({});
let querySet21 = device0.createQuerySet({type: 'occlusion', count: 3561});
try {
computePassEncoder12.setPipeline(pipeline28);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup4, new Uint32Array(2892), 1910, 0);
} catch {}
try {
renderBundleEncoder13.draw(44, 223, 191, 32);
} catch {}
try {
renderBundleEncoder13.drawIndexed(214, 68, 155, 307_585_004, 427_013_796);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer5, 75_628);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer0, 'uint16', 159_698, 8_524);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(4, buffer6, 1_916, 6_965);
} catch {}
try {
commandEncoder48.clearBuffer(buffer6, 14412, 2640);
} catch {}
try {
commandEncoder25.resolveQuerySet(querySet2, 41, 0, buffer1, 7680);
} catch {}
let pipeline45 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  multisample: {},
  fragment: {
  module: shaderModule4,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'dst'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'greater', failOp: 'invert', depthFailOp: 'keep', passOp: 'increment-wrap'},
    stencilBack: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'replace', passOp: 'decrement-wrap'},
    stencilReadMask: 2061404877,
    stencilWriteMask: 881517763,
    depthBias: 0,
    depthBiasSlopeScale: -18.327177513955633,
  },
  vertex: {
    module: shaderModule4,
    buffers: [
      {arrayStride: 328, stepMode: 'instance', attributes: []},
      {arrayStride: 96, attributes: []},
      {
        arrayStride: 1072,
        stepMode: 'instance',
        attributes: [{format: 'float32', offset: 28, shaderLocation: 15}],
      },
      {arrayStride: 136, attributes: []},
      {arrayStride: 372, stepMode: 'vertex', attributes: []},
      {arrayStride: 276, stepMode: 'vertex', attributes: []},
      {arrayStride: 288, stepMode: 'instance', attributes: []},
      {
        arrayStride: 664,
        attributes: [
          {format: 'uint8x4', offset: 76, shaderLocation: 5},
          {format: 'sint16x4', offset: 108, shaderLocation: 7},
        ],
      },
    ],
  },
});
try {
gpuCanvasContext5.unconfigure();
} catch {}
let externalTexture26 = device0.importExternalTexture({source: video0, colorSpace: 'srgb'});
try {
renderBundleEncoder13.drawIndexed(40, 78, 246, 940_001_078, 78_058_785);
} catch {}
try {
commandEncoder36.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 80 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 306964 */
  offset: 5236,
  bytesPerRow: 256,
  rowsPerImage: 191,
  buffer: buffer1,
}, {
  texture: texture24,
  mipLevel: 1,
  origin: {x: 10, y: 5, z: 20},
  aspect: 'all',
}, {width: 80, height: 33, depthOrArrayLayers: 7});
} catch {}
try {
commandEncoder41.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 2,
  origin: {x: 15, y: 2, z: 0},
  aspect: 'all',
}, arrayBuffer1, /* required buffer size: 469_310 */
{offset: 750, bytesPerRow: 991, rowsPerImage: 242}, {width: 202, height: 231, depthOrArrayLayers: 2});
} catch {}
document.body.prepend(img4);
let texture31 = device0.createTexture({
  label: '\uf6e1\u{1f996}\u38d3\u5b1e\u0557\u0279\u3eb6',
  size: [660],
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16float'],
});
let renderBundle43 = renderBundleEncoder17.finish({label: '\u0194\u{1fba5}\ueb61\u{1f906}\ucdd4'});
try {
computePassEncoder7.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder0.setBindGroup(3, bindGroup4, new Uint32Array(4587), 1883, 0);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline28);
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup2);
} catch {}
try {
renderBundleEncoder13.draw(7, 75, 85, 83);
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture23,
  mipLevel: 1,
  origin: {x: 416, y: 37, z: 32},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 20, y: 1, z: 7},
  aspect: 'all',
},
{width: 12, height: 92, depthOrArrayLayers: 17});
} catch {}
try {
computePassEncoder26.insertDebugMarker('\u{1fb9a}');
} catch {}
let pipeline46 = device0.createRenderPipeline({
  label: '\uabe0\ua7a5\u009c\u{1f9cb}\u{1fc9f}\uf959\u13dd\u84a8\u027a\u2166\ueb41',
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {
  format: 'rg16float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 40, stepMode: 'vertex', attributes: []},
      {arrayStride: 716, attributes: [{format: 'float32x3', offset: 176, shaderLocation: 7}]},
      {arrayStride: 0, attributes: []},
      {arrayStride: 220, stepMode: 'vertex', attributes: []},
      {arrayStride: 540, attributes: []},
      {arrayStride: 164, stepMode: 'instance', attributes: []},
      {arrayStride: 1028, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 168, shaderLocation: 13},
          {format: 'uint16x2', offset: 208, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'back'},
});
let querySet22 = device0.createQuerySet({label: '\u3cc0\u876f\ub63f\u0e21', type: 'occlusion', count: 1928});
let texture32 = device0.createTexture({
  label: '\u04e2\uf6bf\u0d76\ubf2b\u1cfa\u4882',
  size: {width: 165, height: 120, depthOrArrayLayers: 1507},
  mipLevelCount: 11,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm'],
});
try {
computePassEncoder16.setBindGroup(1, bindGroup6, new Uint32Array(1818), 889, 0);
} catch {}
try {
computePassEncoder0.dispatchWorkgroupsIndirect(buffer5, 353644);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup9);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer0, 6_312);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer0, 36_348);
} catch {}
try {
commandEncoder44.clearBuffer(buffer3, 7552, 43244);
} catch {}
try {
commandEncoder11.resolveQuerySet(querySet10, 934, 507, buffer1, 19968);
} catch {}
try {
commandEncoder31.popDebugGroup();
} catch {}
let promise14 = device0.queue.onSubmittedWorkDone();
let pipeline47 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  multisample: {count: 4, mask: 0x4ea23c4e},
  fragment: {
  module: shaderModule8,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'constant', dstFactor: 'src'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rgba8sint'}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: 0}, {format: 'rg16uint', writeMask: GPUColorWrite.RED}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'add', srcFactor: 'dst', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: 0,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilFront: {failOp: 'increment-wrap', depthFailOp: 'decrement-clamp', passOp: 'replace'},
    stencilBack: {compare: 'greater-equal', failOp: 'invert', depthFailOp: 'decrement-wrap', passOp: 'increment-wrap'},
    stencilReadMask: 4294967295,
    stencilWriteMask: 2462581447,
    depthBias: -1162158773,
  },
  vertex: {
    module: shaderModule8,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 224, attributes: []},
      {arrayStride: 196, stepMode: 'instance', attributes: []},
      {arrayStride: 160, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 68, stepMode: 'instance', attributes: []},
      {arrayStride: 80, attributes: []},
      {
        arrayStride: 272,
        attributes: [
          {format: 'uint8x4', offset: 52, shaderLocation: 5},
          {format: 'float32x3', offset: 4, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'ccw', cullMode: 'back'},
});
let querySet23 = device0.createQuerySet({label: '\ua103\u{1f917}\u7a1d\ue3e2\u0a6c\u12d3', type: 'occlusion', count: 2885});
let textureView67 = texture2.createView({label: '\u0e2f\u639f\ue95c\u08bd\u0d42\u0b6c\u3b4c\u0b87\u3c4c', baseMipLevel: 1, mipLevelCount: 4});
let computePassEncoder28 = commandEncoder49.beginComputePass({label: '\u{1fa54}\ucbbe\u5733\u8bcd\ue8dd\u{1f9e2}'});
try {
computePassEncoder12.setBindGroup(3, bindGroup6, new Uint32Array(8388), 1233, 0);
} catch {}
try {
computePassEncoder0.dispatchWorkgroups(3, 3);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder13.draw(152, 72, 88, 67);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer5, 27_632);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(1, buffer7, 2_468, 3_578);
} catch {}
try {
commandEncoder19.copyTextureToBuffer({
  texture: texture17,
  mipLevel: 2,
  origin: {x: 26, y: 38, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 482 widthInBlocks: 241 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 74490 */
  offset: 3352,
  bytesPerRow: 512,
  buffer: buffer1,
}, {width: 241, height: 139, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder48.resolveQuerySet(querySet6, 57, 208, buffer1, 317952);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 124}
*/
{
  source: img5,
  origin: { x: 24, y: 73 },
  flipY: false,
}, {
  texture: texture24,
  mipLevel: 1,
  origin: {x: 20, y: 43, z: 83},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 16, height: 3, depthOrArrayLayers: 0});
} catch {}
let pipeline48 = await device0.createRenderPipelineAsync({
  label: '\u{1ff49}\u{1f92f}\u{1f644}',
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'dst-alpha'},
  },
  writeMask: GPUColorWrite.RED,
}, {format: 'rgba8sint'}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.ALL}, {format: 'rg16uint', writeMask: GPUColorWrite.BLUE}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'dst'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-constant', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'never',
    stencilFront: {failOp: 'decrement-clamp', depthFailOp: 'decrement-wrap'},
    stencilBack: {compare: 'never', failOp: 'zero', passOp: 'increment-clamp'},
    stencilReadMask: 967058440,
    stencilWriteMask: 2074693987,
  },
  vertex: {
    module: shaderModule6,
    buffers: [
      {
        arrayStride: 440,
        stepMode: 'instance',
        attributes: [{format: 'uint32', offset: 24, shaderLocation: 13}],
      },
      {arrayStride: 68, attributes: []},
      {
        arrayStride: 900,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32x3', offset: 60, shaderLocation: 5},
          {format: 'float16x2', offset: 28, shaderLocation: 7},
          {format: 'unorm10-10-10-2', offset: 396, shaderLocation: 1},
          {format: 'unorm8x2', offset: 10, shaderLocation: 4},
          {format: 'unorm16x4', offset: 8, shaderLocation: 3},
          {format: 'float32x4', offset: 184, shaderLocation: 15},
          {format: 'snorm8x2', offset: 140, shaderLocation: 6},
          {format: 'float32x3', offset: 8, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 964,
        stepMode: 'instance',
        attributes: [{format: 'uint32x4', offset: 8, shaderLocation: 10}],
      },
      {arrayStride: 520, attributes: [{format: 'sint32', offset: 68, shaderLocation: 2}]},
      {arrayStride: 76, stepMode: 'instance', attributes: []},
      {arrayStride: 20, stepMode: 'instance', attributes: []},
      {
        arrayStride: 100,
        attributes: [
          {format: 'unorm8x4', offset: 24, shaderLocation: 12},
          {format: 'snorm16x2', offset: 28, shaderLocation: 9},
          {format: 'snorm16x2', offset: 28, shaderLocation: 8},
          {format: 'sint8x2', offset: 16, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw'},
});
let bindGroup16 = device0.createBindGroup({
  label: '\u6972\ua3a8\u0c18\u3982\u{1fff6}\u1e36\u{1f733}\u6f05\uec49\u{1f907}\u6deb',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer5, offset: 190208}}],
});
let textureView68 = texture22.createView({
  label: '\u0d71\u{1fb5c}',
  dimension: '2d',
  aspect: 'depth-only',
  baseMipLevel: 5,
  mipLevelCount: 5,
  baseArrayLayer: 27,
});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({label: '\u0304\u{1f7eb}\u{1fe74}', colorFormats: ['rgba8unorm'], sampleCount: 4, stencilReadOnly: true});
let sampler28 = device0.createSampler({
  label: '\u{1f9a2}\u6f67\u{1f85f}\u90e3\u0fc8\ue21e\u{1ff24}\ue42c\u{1fa54}',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'linear',
  lodMinClamp: 51.48,
  lodMaxClamp: 57.83,
});
try {
computePassEncoder0.setBindGroup(1, bindGroup12);
} catch {}
try {
renderBundleEncoder13.drawIndexed(24, 254, 141, 886_863_879, 864_458_316);
} catch {}
try {
commandEncoder19.copyBufferToTexture({
  /* bytesInLastRow: 220 widthInBlocks: 55 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 305684 */
  offset: 19000,
  bytesPerRow: 256,
  rowsPerImage: 68,
  buffer: buffer1,
}, {
  texture: texture18,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 10},
  aspect: 'all',
}, {width: 55, height: 32, depthOrArrayLayers: 17});
} catch {}
try {
commandEncoder11.clearBuffer(buffer1);
} catch {}
let pipeline49 = device0.createComputePipeline({
  label: '\u0f0e\u70c9\u0e2f\u011e\u51c6\ub94f\ua44e\uc5cf',
  layout: pipelineLayout2,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let commandEncoder57 = device0.createCommandEncoder({label: '\u{1f9f6}\ue92b\u0839\u79a7'});
let querySet24 = device0.createQuerySet({label: '\u{1f96d}\u0cc2\uca9d\u010d\uaaaf\u62bb\ue708\u5ccb', type: 'occlusion', count: 2824});
let texture33 = device0.createTexture({
  label: '\u022a\uc04f\ua163\u295b\u77fc\u023b',
  size: [330, 240, 564],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle44 = renderBundleEncoder23.finish({label: '\u01e3\ub4f0\u{1f70e}\u023b\u02e9\u01be\ucdd4\uc6b6\ud04d'});
try {
renderBundleEncoder13.draw(346, 222, 4, 234);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer5, 70_876);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline19);
} catch {}
try {
commandEncoder11.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 78, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 24, y: 57, z: 0},
  aspect: 'all',
},
{width: 146, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline50 = device0.createRenderPipeline({
  label: '\ud3f0\u65c7\u{1ff9b}\u09cc\u{1fda0}\u0717\u4cfb\u37e4',
  layout: pipelineLayout1,
  multisample: {count: 4, mask: 0xe1fc2ca},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilFront: {compare: 'less-equal', failOp: 'replace', depthFailOp: 'invert', passOp: 'invert'},
    stencilBack: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'replace', passOp: 'increment-wrap'},
    stencilReadMask: 279095205,
    stencilWriteMask: 764915010,
    depthBias: 1631045573,
    depthBiasSlopeScale: 20.730621103568126,
    depthBiasClamp: 905.8560969984113,
  },
  vertex: {
    module: shaderModule6,
    buffers: [
      {
        arrayStride: 68,
        stepMode: 'instance',
        attributes: [{format: 'float32x2', offset: 20, shaderLocation: 1}],
      },
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 0, shaderLocation: 15},
          {format: 'uint8x2', offset: 0, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 8},
        ],
      },
      {arrayStride: 856, stepMode: 'instance', attributes: []},
      {
        arrayStride: 52,
        attributes: [
          {format: 'float32x4', offset: 4, shaderLocation: 4},
          {format: 'uint8x2', offset: 10, shaderLocation: 13},
          {format: 'unorm8x2', offset: 2, shaderLocation: 14},
          {format: 'float16x4', offset: 0, shaderLocation: 7},
          {format: 'snorm8x4', offset: 20, shaderLocation: 6},
        ],
      },
      {arrayStride: 28, stepMode: 'instance', attributes: []},
      {arrayStride: 1580, stepMode: 'instance', attributes: []},
      {arrayStride: 296, attributes: []},
      {
        arrayStride: 212,
        stepMode: 'vertex',
        attributes: [
          {format: 'unorm8x4', offset: 20, shaderLocation: 9},
          {format: 'unorm8x4', offset: 116, shaderLocation: 3},
          {format: 'float32x4', offset: 52, shaderLocation: 12},
          {format: 'float32x3', offset: 28, shaderLocation: 5},
          {format: 'sint16x2', offset: 16, shaderLocation: 2},
          {format: 'sint16x2', offset: 0, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw'},
});
let videoFrame3 = new VideoFrame(videoFrame2, {timestamp: 0});
let commandEncoder58 = device0.createCommandEncoder();
let renderBundleEncoder24 = device0.createRenderBundleEncoder({
  label: '\ua6dc\u0338\u03bc\u05b9\u0623\u{1fa48}\u6d26\u02ee\u{1fc6f}',
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  depthReadOnly: true,
});
let sampler29 = device0.createSampler({
  label: '\u0737\uf18c\u1e03\u3d75\uaddf\u0a76\u676c\u{1fc6c}\u0438',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 82.50,
  maxAnisotropy: 19,
});
try {
computePassEncoder25.setBindGroup(3, bindGroup3);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline28);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer0, 117_808);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer0, 142_140);
} catch {}
try {
commandEncoder31.resolveQuerySet(querySet13, 98, 712, buffer0, 22528);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 2,
  origin: {x: 2, y: 3, z: 8},
  aspect: 'all',
}, new ArrayBuffer(72), /* required buffer size: 60_468 */
{offset: 94, bytesPerRow: 300, rowsPerImage: 97}, {width: 37, height: 8, depthOrArrayLayers: 3});
} catch {}
let pipeline51 = device0.createRenderPipeline({
  label: '\u{1f9ae}\u{1f95e}\u0d26\u1ab7\ua176',
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'zero'},
    alpha: {operation: 'add', srcFactor: 'dst-alpha', dstFactor: 'one-minus-src-alpha'},
  },
}, {format: 'rg16float', writeMask: GPUColorWrite.ALL}, {format: 'rgba16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilFront: {failOp: 'invert', depthFailOp: 'increment-wrap', passOp: 'increment-wrap'},
    stencilBack: {failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'decrement-clamp'},
    stencilReadMask: 1486019600,
    stencilWriteMask: 3746950333,
    depthBiasClamp: 0.0,
  },
  vertex: {
    module: shaderModule3,
    buffers: [
      {arrayStride: 496, stepMode: 'instance', attributes: []},
      {arrayStride: 164, stepMode: 'instance', attributes: []},
      {arrayStride: 156, attributes: []},
      {arrayStride: 296, attributes: [{format: 'uint8x2', offset: 30, shaderLocation: 5}]},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 176, attributes: [{format: 'float16x4', offset: 72, shaderLocation: 7}]},
      {arrayStride: 84, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 364,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x4', offset: 176, shaderLocation: 13}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let video8 = await videoWithData();
let bindGroup17 = device0.createBindGroup({
  label: '\ue533\u{1feef}\uccaf\u76b6\u828d\u0860\u4cc6\uae75\u{1fd39}\uf6c4\u{1fa1b}',
  layout: bindGroupLayout1,
  entries: [],
});
let texture34 = device0.createTexture({
  label: '\u12c1\u{1fb76}\u0069\u00e3\ua690\u39b4\u09b6\u5bae\u0b50\uda8d',
  size: [660, 480, 339],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm'],
});
let textureView69 = texture32.createView({label: '\u094d\u021a\uc71c\u836f\uc8a8\u{1f673}\u799c\u031b\u154a', baseMipLevel: 3, mipLevelCount: 1});
let sampler30 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 37.32,
  compare: 'greater-equal',
});
try {
renderBundleEncoder13.drawIndirect(buffer5, 174_604);
} catch {}
try {
commandEncoder28.resolveQuerySet(querySet14, 67, 0, buffer0, 239872);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 124}
*/
{
  source: imageData5,
  origin: { x: 5, y: 3 },
  flipY: false,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 21, y: 37, z: 36},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 35, height: 45, depthOrArrayLayers: 0});
} catch {}
let bindGroup18 = device0.createBindGroup({label: '\u0a55\ub43d\ua242\u3a8f\uda23\u7af4', layout: bindGroupLayout5, entries: []});
let buffer9 = device0.createBuffer({
  label: '\u{1f665}\ua7db\u1be2\u{1ff66}\u006c\u{1f741}\uc099',
  size: 367484,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let querySet25 = device0.createQuerySet({label: '\u1362\u0836\u070a\u0460\ude0d\ua707\ue190\u45b5\u475e', type: 'occlusion', count: 3758});
let textureView70 = texture1.createView({
  label: '\ufafb\u{1f650}\u058a\ub346\u3920\u0a9c\ucffd\u0c83\uf813',
  baseMipLevel: 5,
  mipLevelCount: 3,
  baseArrayLayer: 0,
});
let externalTexture27 = device0.importExternalTexture({label: '\uea06\u031e\u333a\u{1fd3a}\u0123\ud28d\uc811\u28b4', source: videoFrame2});
try {
renderBundleEncoder13.drawIndexed(123, 110, 1_121, 220_407_853, 125_307_955);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(4, buffer5, 101_392, 160_029);
} catch {}
try {
commandEncoder43.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 9516 */
  offset: 9516,
  buffer: buffer7,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
renderBundleEncoder13.insertDebugMarker('\u0211');
} catch {}
try {
device0.queue.writeBuffer(buffer1, 7140, new DataView(new ArrayBuffer(28202)), 22937, 232);
} catch {}
let device1 = await adapter1.requestDevice({
  label: '\u6c85\u0953\u0b3b\uc3c0\ufd78\u0cd9\u1bfa\u0f29\u2b86\u278d',
  defaultQueue: {label: '\ua40a\u3c61\u0272\u{1ff70}\u8b8e\u0f11\u1e7a\uacc0\u41ca'},
  requiredFeatures: [
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'bgra8unorm-storage',
  ],
});
let querySet26 = device1.createQuerySet({label: '\u0d0a\u4714\u0dfa\u283e\u04ae\u6083', type: 'occlusion', count: 1771});
let sampler31 = device1.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 4.361,
  maxAnisotropy: 15,
});
let externalTexture28 = device1.importExternalTexture({label: '\u0f28\u07e5', source: video8, colorSpace: 'srgb'});
let bindGroup19 = device0.createBindGroup({
  label: '\u{1febd}\u0725\u02db\ue168\u{1f656}\u0d46\u140d\u{1f672}\u08d7',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer3, offset: 29440, size: 20968}}],
});
let commandEncoder59 = device0.createCommandEncoder({});
let computePassEncoder29 = commandEncoder28.beginComputePass({label: '\ue9c2\u{1f99a}\u0113\u{1ffae}'});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({
  label: '\u{1f8cf}\u10d6\u{1f9bb}\ucf81\u072c\u{1ffa0}\u057b\u7cc4',
  colorFormats: ['r32float'],
  stencilReadOnly: true,
});
let renderBundle45 = renderBundleEncoder7.finish({label: '\u366e\u{1fd0c}\u{1f752}\u7ac5\uc67f\u8a06\u0282\u0869'});
let externalTexture29 = device0.importExternalTexture({
  label: '\uc2bb\uf4e0\u{1fb4d}\u{1f776}\u{1f949}\u{1fb04}\u{1fe01}\u0f04',
  source: video2,
  colorSpace: 'display-p3',
});
try {
computePassEncoder25.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder25.setBindGroup(1, bindGroup9);
} catch {}
try {
renderBundleEncoder25.setBindGroup(0, bindGroup7, new Uint32Array(775), 539, 0);
} catch {}
try {
commandEncoder25.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 11516 */
  offset: 11512,
  bytesPerRow: 256,
  buffer: buffer1,
}, {width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder56.clearBuffer(buffer9);
} catch {}
let pipeline52 = await device0.createComputePipelineAsync({
  label: '\u25ee\u097e',
  layout: pipelineLayout0,
  compute: {module: shaderModule1, entryPoint: 'compute0'},
});
let canvas9 = document.createElement('canvas');
canvas0.height = 1391;
let videoFrame4 = new VideoFrame(imageBitmap2, {timestamp: 0});
let sampler32 = device1.createSampler({
  label: '\u0bb2\u018a\u0636\u68a2\u1660\u00bf',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 90.10,
  compare: 'less-equal',
});
let gpuCanvasContext7 = canvas9.getContext('webgpu');
try {
gpuCanvasContext6.unconfigure();
} catch {}
try {
  await promise14;
} catch {}
canvas3.height = 959;
let imageBitmap6 = await createImageBitmap(imageData1);
let commandEncoder60 = device0.createCommandEncoder({label: '\uc330\ucab1\ub881\u5a00\u03cc'});
let renderBundle46 = renderBundleEncoder11.finish();
try {
renderBundleEncoder13.draw(10, 235, 408, 79);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer5, 108_216);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer6, 'uint16', 1_500, 4_719);
} catch {}
try {
commandEncoder24.copyBufferToBuffer(buffer3, 55000, buffer2, 101008, 31320);
} catch {}
try {
commandEncoder26.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1604 */
  offset: 1604,
  buffer: buffer3,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 32864, new DataView(new ArrayBuffer(52580)), 16556);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 25},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 423_628 */
{offset: 306, bytesPerRow: 500, rowsPerImage: 112}, {width: 161, height: 63, depthOrArrayLayers: 8});
} catch {}
let commandEncoder61 = device1.createCommandEncoder();
let sampler33 = device1.createSampler({
  label: '\u9fd6\u7d1f\u{1fb60}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 63.36,
  lodMaxClamp: 86.89,
});
let externalTexture30 = device1.importExternalTexture({label: '\u07c8\u{1fbc0}\u0b54', source: videoFrame2, colorSpace: 'srgb'});
try {
gpuCanvasContext4.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['bgra8unorm'],
});
} catch {}
let shaderModule9 = device0.createShaderModule({
  label: '\u8220\u02aa\u02d3\u078d\ud258\u07ea\u05d1\u0052\u04f9\u01fe\u{1f8ac}',
  code: `@group(2) @binding(954)
var<storage, read_write> parameter4: array<u32>;
@group(3) @binding(954)
var<storage, read_write> local4: array<u32>;
@group(1) @binding(954)
var<storage, read_write> parameter5: array<u32>;

@compute @workgroup_size(5, 4, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(6) f0: vec3<i32>,
  @location(5) f1: vec2<i32>,
  @location(0) f2: vec2<f32>
}

@fragment
fn fragment0(@location(12) a0: vec3<u32>, @location(7) a1: f16, @location(4) a2: vec2<f16>, @location(1) a3: vec3<u32>, @location(13) a4: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S8 {
  @location(4) f0: u32,
  @location(3) f1: vec2<f32>,
  @location(1) f2: vec4<i32>,
  @location(2) f3: vec2<f16>,
  @location(8) f4: vec4<f32>,
  @location(7) f5: vec2<f16>,
  @location(0) f6: u32,
  @location(9) f7: f16,
  @location(13) f8: vec2<i32>
}
struct VertexOutput0 {
  @location(13) f74: vec4<f32>,
  @location(11) f75: f16,
  @location(8) f76: vec2<f16>,
  @location(6) f77: vec2<f32>,
  @location(5) f78: vec2<f32>,
  @location(14) f79: i32,
  @location(15) f80: vec4<f32>,
  @builtin(position) f81: vec4<f32>,
  @location(10) f82: vec3<i32>,
  @location(4) f83: vec2<f16>,
  @location(12) f84: vec3<u32>,
  @location(7) f85: f16,
  @location(2) f86: vec2<u32>,
  @location(1) f87: vec3<u32>,
  @location(9) f88: vec4<f32>
}

@vertex
fn vertex0(@builtin(vertex_index) a0: u32, @location(6) a1: vec4<u32>, @location(5) a2: vec4<f16>, @builtin(instance_index) a3: u32, @location(12) a4: f32, @location(11) a5: vec3<i32>, @location(14) a6: vec4<u32>, a7: S8, @location(10) a8: u32, @location(15) a9: vec2<f32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
});
let buffer10 = device0.createBuffer({
  label: '\u{1f983}\u3402',
  size: 44824,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
  mappedAtCreation: false,
});
let textureView71 = texture6.createView({
  label: '\u07e6\u{1f712}\u071d\u1c4c\u1716\u0850\u51b8',
  dimension: '2d',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 21,
});
let computePassEncoder30 = commandEncoder55.beginComputePass({});
try {
computePassEncoder12.setPipeline(pipeline15);
} catch {}
try {
renderBundleEncoder13.drawIndexed(133, 53, 42, 907_727_212, 709_538_514);
} catch {}
try {
commandEncoder57.resolveQuerySet(querySet18, 165, 1032, buffer0, 121088);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 19700, new BigUint64Array(48794), 15801, 112);
} catch {}
let imageBitmap7 = await createImageBitmap(imageData3);
let imageData8 = new ImageData(24, 176);
let bindGroupLayout11 = pipeline14.getBindGroupLayout(2);
let buffer11 = device0.createBuffer({
  label: '\u0b92\u08ad\ubbe4\u0a57',
  size: 764208,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder62 = device0.createCommandEncoder({label: '\u0464\u0ba5\ucd24\u{1fb20}\u0363'});
let texture35 = device0.createTexture({
  label: '\u90ef\u{1ff1d}\u0288\u0924\u0878',
  size: [165, 120, 124],
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView72 = texture29.createView({baseMipLevel: 0});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({
  label: '\u49e4\u04ae',
  colorFormats: ['rg16float', 'rgba16float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let sampler34 = device0.createSampler({
  label: '\u856c\u0c83\u{1fa8e}\u{1fdf0}\ua2a6',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 84.53,
  maxAnisotropy: 6,
});
try {
renderBundleEncoder13.draw(3, 17, 86, 430);
} catch {}
try {
renderBundleEncoder13.drawIndexed(108, 151, 665, 1_163_080_590, 181_551_802);
} catch {}
try {
commandEncoder26.clearBuffer(buffer2, 130844, 13420);
} catch {}
try {
commandEncoder58.resolveQuerySet(querySet11, 1389, 871, buffer0, 55808);
} catch {}
try {
computePassEncoder1.insertDebugMarker('\u9257');
} catch {}
try {
device0.queue.submit([commandBuffer9]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture0,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 7},
  aspect: 'all',
}, new Int32Array(arrayBuffer2), /* required buffer size: 2_649_007 */
{offset: 603, bytesPerRow: 538, rowsPerImage: 203}, {width: 46, height: 51, depthOrArrayLayers: 25});
} catch {}
let pipeline53 = await device0.createRenderPipelineAsync({
  label: '\u5047\u921a\u0467\uf2aa\u0e0d\u9e6d',
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-src-alpha'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'src', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA,
}, {
  format: 'rgba8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'src'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: GPUColorWrite.ALL}, {format: 'rg16uint', writeMask: 0}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule6,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [{format: 'sint8x2', offset: 2, shaderLocation: 2}, {format: 'snorm8x2', offset: 0, shaderLocation: 1}],
      },
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 668,
        attributes: [
          {format: 'float16x4', offset: 52, shaderLocation: 15},
          {format: 'float32x4', offset: 92, shaderLocation: 12},
          {format: 'uint8x4', offset: 16, shaderLocation: 10},
        ],
      },
      {arrayStride: 1452, attributes: []},
      {arrayStride: 60, stepMode: 'instance', attributes: []},
      {
        arrayStride: 460,
        stepMode: 'vertex',
        attributes: [{format: 'float32x3', offset: 48, shaderLocation: 3}],
      },
      {
        arrayStride: 360,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 148, shaderLocation: 9},
          {format: 'unorm10-10-10-2', offset: 112, shaderLocation: 14},
          {format: 'uint32x3', offset: 152, shaderLocation: 13},
          {format: 'sint16x2', offset: 20, shaderLocation: 11},
          {format: 'float32x2', offset: 68, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 348,
        attributes: [
          {format: 'unorm16x4', offset: 32, shaderLocation: 5},
          {format: 'float32', offset: 0, shaderLocation: 8},
          {format: 'float16x4', offset: 8, shaderLocation: 7},
          {format: 'unorm8x2', offset: 10, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw'},
});
let commandEncoder63 = device0.createCommandEncoder({label: '\u0c3e\u0175'});
let commandBuffer15 = commandEncoder41.finish({});
try {
computePassEncoder16.end();
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer10, 576);
} catch {}
try {
commandEncoder44.resolveQuerySet(querySet23, 128, 40, buffer0, 73984);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 82}
*/
{
  source: imageData3,
  origin: { x: 2, y: 3 },
  flipY: true,
}, {
  texture: texture8,
  mipLevel: 1,
  origin: {x: 5, y: 22, z: 28},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 9, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline54 = await device0.createComputePipelineAsync({
  label: '\u028d\u87eb\u0786\u3e67\u25cb\ub8aa\u08ab\ua23c\u9a84\u0b9f',
  layout: pipelineLayout1,
  compute: {module: shaderModule8, entryPoint: 'compute0', constants: {}},
});
let canvas10 = document.createElement('canvas');
let textureView73 = texture35.createView({label: '\u0557\u08e1\u0c4d\uad8a\ua5f0\u{1fd24}', dimension: '2d', baseArrayLayer: 3});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({
  label: '\u6589\ud86e\u423f\u0da1\u003d\u8569\u4fea\u19af\u19a9',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  stencilReadOnly: true,
});
try {
renderBundleEncoder13.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer10, 620);
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline23);
} catch {}
try {
commandEncoder53.copyTextureToTexture({
  texture: texture17,
  mipLevel: 2,
  origin: {x: 86, y: 18, z: 10},
  aspect: 'all',
},
{
  texture: texture21,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 7, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder26.clearBuffer(buffer6, 20012, 7120);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
canvas8.height = 320;
let querySet27 = device1.createQuerySet({label: '\u46e4\u8d0f\u{1fa89}\u{1f8e5}\u0068\uabe6\ud845\u4923\u0c75', type: 'occlusion', count: 2200});
let computePassEncoder31 = commandEncoder61.beginComputePass({label: '\ud865\u0675\u0cff\u0fc6'});
try {
device1.pushErrorScope('internal');
} catch {}
let commandEncoder64 = device1.createCommandEncoder({label: '\u0b00\u4db6\u125a\u945a\ud1ff\u07bb\u0cf7\u{1fde1}'});
let renderBundleEncoder28 = device1.createRenderBundleEncoder({
  label: '\u0e29\u569f\u9e2d\u0ea2\u2e15\u{1fbd1}\u56eb\u014b\u{1f6dc}\ubf1a\u7e5b',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  stencilReadOnly: true,
});
try {
commandEncoder64.pushDebugGroup('\u{1f829}');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm'],
});
} catch {}
let querySet28 = device1.createQuerySet({label: '\ua862\uea62\u{1f68d}\u607d\u1ad5\u0a6d\u07b3', type: 'occlusion', count: 4096});
try {
commandEncoder64.popDebugGroup();
} catch {}
let commandEncoder65 = device1.createCommandEncoder();
let texture36 = device1.createTexture({
  label: '\u0222\u{1f6b7}\u6be8\uace0\u5d55\u{1fcae}\ued9d\u6282',
  size: {width: 1280, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView74 = texture36.createView({
  label: '\u0e1f\uf861\u0927\ubfb5\u574f\u{1fd0f}\u288f\u1931\u4da8\u9719',
  aspect: 'depth-only',
  baseMipLevel: 0,
});
let computePassEncoder32 = commandEncoder65.beginComputePass({label: '\u{1f729}\ude36\u6ce0\u09e0\ub2a7\uf1a8\ub70d\u0742'});
try {
renderBundleEncoder28.setVertexBuffer(2, undefined, 709_650_216);
} catch {}
let bindGroup20 = device0.createBindGroup({
  label: '\u030f\u04c7\u8b4e',
  layout: bindGroupLayout9,
  entries: [{binding: 900, resource: externalTexture18}],
});
try {
renderBundleEncoder20.setIndexBuffer(buffer6, 'uint16', 4_284, 1_192);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
texture32.destroy();
} catch {}
let promise15 = buffer8.mapAsync(GPUMapMode.WRITE, 118536, 16020);
try {
commandEncoder26.clearBuffer(buffer3, 50104, 33088);
} catch {}
try {
commandEncoder20.resolveQuerySet(querySet15, 1053, 241, buffer1, 6400);
} catch {}
let pipeline55 = await device0.createRenderPipelineAsync({
  label: '\u92a7\ude0c\u{1fa73}\u0bd4\u053d\u6fc8\ud6eb\uc822\u5de6\u{1f8d3}',
  layout: 'auto',
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'add', srcFactor: 'one', dstFactor: 'zero'},
    alpha: {operation: 'subtract', srcFactor: 'one', dstFactor: 'src'},
  },
  writeMask: 0,
}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'src', dstFactor: 'zero'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'src-alpha'},
  },
  writeMask: 0,
}, {format: 'rg16float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba16uint', writeMask: 0}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'never',
    stencilFront: {compare: 'greater', failOp: 'decrement-clamp', depthFailOp: 'invert', passOp: 'increment-clamp'},
    stencilBack: {compare: 'less', failOp: 'zero', depthFailOp: 'decrement-wrap', passOp: 'zero'},
    stencilReadMask: 3092431159,
    depthBias: 1445521359,
    depthBiasClamp: 906.7626686407846,
  },
  vertex: {
    module: shaderModule3,
    buffers: [
      {arrayStride: 192, stepMode: 'instance', attributes: []},
      {arrayStride: 176, attributes: []},
      {arrayStride: 1068, attributes: []},
      {arrayStride: 576, attributes: []},
      {
        arrayStride: 348,
        stepMode: 'vertex',
        attributes: [{format: 'float32x4', offset: 24, shaderLocation: 13}],
      },
      {arrayStride: 72, attributes: []},
      {arrayStride: 96, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 32,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 4, shaderLocation: 7},
          {format: 'uint32x4', offset: 0, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front'},
});
let sampler35 = device1.createSampler({
  label: '\ua537\u72f3\u0be0',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 73.00,
  lodMaxClamp: 80.45,
  compare: 'less',
  maxAnisotropy: 5,
});
canvas4.width = 1812;
let video9 = await videoWithData();
let commandEncoder66 = device1.createCommandEncoder();
let texture37 = device1.createTexture({
  label: '\u5394\u458a\uee43\uaf78\u07cf\u9be2\u4256',
  size: {width: 275},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['r32sint', 'r32sint'],
});
try {
gpuCanvasContext1.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let commandEncoder67 = device0.createCommandEncoder({label: '\u0fb7\u{1fcd2}\u0336\u6ee8\u277f'});
let computePassEncoder33 = commandEncoder26.beginComputePass({label: '\uc60c\u{1f948}\u55c1\u0e4e\u1b27\u2a61\u0905\u{1fd09}'});
let renderBundleEncoder29 = device0.createRenderBundleEncoder({
  label: '\u0e19\u5bbf\u8027\u867a',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
});
try {
commandEncoder47.resolveQuerySet(querySet14, 11, 282, buffer1, 768);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 6120, new DataView(new ArrayBuffer(2410)), 1240, 484);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 10,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, new Float32Array(arrayBuffer1), /* required buffer size: 441_132 */
{offset: 794, bytesPerRow: 146, rowsPerImage: 26}, {width: 1, height: 1, depthOrArrayLayers: 117});
} catch {}
let pipeline56 = await device0.createComputePipelineAsync({
  label: '\ud1ef\u72e6\u0abc\u2cd4\u{1f699}\u{1fb4b}',
  layout: pipelineLayout4,
  compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}},
});
try {
  await promise13;
} catch {}
let img6 = await imageWithData(274, 62, '#9c1fc034', '#2a123d0f');
let video10 = await videoWithData();
let imageData9 = new ImageData(92, 200);
let textureView75 = texture0.createView({label: '\u7d58\ub5b8\ud0b9\u46c8\u0436\u9be9', dimension: '2d', baseMipLevel: 1, baseArrayLayer: 74});
try {
renderBundleEncoder13.draw(293, 19, 333, 40);
} catch {}
try {
renderBundleEncoder19.setIndexBuffer(buffer0, 'uint32', 85_164, 5_817);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 1484, new Float32Array(51664), 15312, 2076);
} catch {}
document.body.prepend(video2);
gc();
let videoFrame5 = new VideoFrame(canvas2, {timestamp: 0});
let texture38 = gpuCanvasContext3.getCurrentTexture();
let textureView76 = texture36.createView({label: '\u067d\uf9c8\u33df\u{1fb21}\u0e76\u5ead\u08fc\u00cc', aspect: 'depth-only', baseMipLevel: 0});
try {
  await promise15;
} catch {}
let bindGroupLayout12 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 301,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' },
    },
  ],
});
try {
renderBundleEncoder19.setBindGroup(2, bindGroup2, new Uint32Array(4908), 3186, 0);
} catch {}
try {
renderBundleEncoder13.drawIndexed(1, 184, 927, 322_861_858, 855_146_200);
} catch {}
try {
commandEncoder44.copyBufferToBuffer(buffer4, 11920, buffer9, 87120, 130380);
} catch {}
try {
commandEncoder51.copyTextureToTexture({
  texture: texture23,
  mipLevel: 1,
  origin: {x: 43, y: 12, z: 36},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 3,
  origin: {x: 3, y: 1, z: 0},
  aspect: 'all',
},
{width: 14, height: 3, depthOrArrayLayers: 17});
} catch {}
try {
commandEncoder67.clearBuffer(buffer6, 23916, 1576);
} catch {}
try {
commandEncoder56.resolveQuerySet(querySet12, 32, 14, buffer1, 1536);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 3412, new BigUint64Array(22946), 9958, 1944);
} catch {}
let pipeline57 = await device0.createRenderPipelineAsync({
  label: '\u020e\u0247\u{1fa12}\ucb8c\u4f91\u9a91',
  layout: pipelineLayout1,
  multisample: {},
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'constant', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'add', srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha'},
  },
  writeMask: 0,
}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: 0,
}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'dst-alpha', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
}, {format: 'rgba16uint'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {failOp: 'increment-wrap', depthFailOp: 'decrement-clamp', passOp: 'increment-clamp'},
    stencilBack: {compare: 'less', depthFailOp: 'invert', passOp: 'increment-wrap'},
    stencilReadMask: 3809093873,
    stencilWriteMask: 2015205979,
    depthBiasSlopeScale: 144.3966152458437,
    depthBiasClamp: 888.310940748382,
  },
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 420,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 176, shaderLocation: 7},
          {format: 'sint32x2', offset: 64, shaderLocation: 2},
        ],
      },
      {arrayStride: 48, attributes: []},
      {arrayStride: 160, attributes: []},
      {
        arrayStride: 488,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint16x2', offset: 172, shaderLocation: 11},
          {format: 'float32x3', offset: 72, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 260,
        attributes: [
          {format: 'unorm8x4', offset: 0, shaderLocation: 1},
          {format: 'snorm8x4', offset: 64, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 376,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 12, shaderLocation: 3},
          {format: 'sint32x3', offset: 64, shaderLocation: 13},
        ],
      },
      {arrayStride: 956, attributes: [{format: 'unorm8x4', offset: 308, shaderLocation: 9}]},
      {
        arrayStride: 968,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint16x4', offset: 152, shaderLocation: 15},
          {format: 'sint32', offset: 20, shaderLocation: 14},
          {format: 'float16x2', offset: 12, shaderLocation: 5},
          {format: 'sint8x2', offset: 8, shaderLocation: 6},
          {format: 'unorm8x4', offset: 292, shaderLocation: 10},
          {format: 'uint32x3', offset: 192, shaderLocation: 12},
          {format: 'sint32x3', offset: 256, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front', unclippedDepth: false},
});
let commandEncoder68 = device1.createCommandEncoder({label: '\uef8a\u90a7\u0156\u5a65\u{1f684}\u0bee\u{1fec4}\u{1f798}\u{1fcca}\u11a9\u66d8'});
let querySet29 = device1.createQuerySet({type: 'occlusion', count: 1953});
let textureView77 = texture38.createView({
  label: '\u2d0e\u00c7\u08ee\uf0e6\u0562\u0051\u{1fa6c}\u{1f86b}\u0418\ubcd0\u27ce',
  dimension: '2d-array',
  mipLevelCount: 1,
});
let renderBundle47 = renderBundleEncoder28.finish({label: '\u7fd7\u0c33\ua277\u482d'});
let sampler36 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 88.39,
  lodMaxClamp: 93.95,
  maxAnisotropy: 14,
});
let buffer12 = device1.createBuffer({
  label: '\u0b5d\u5234\u6bc2\u9494\u0080\ua201\u{1f659}\u15ab\u3234\uc37b\u{1fb7b}',
  size: 6549,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX,
});
let textureView78 = texture38.createView({label: '\u{1f83a}\u6801\u5811\u0f55\u{1ff29}\u8229\ueae4\ud92e\u{1fd09}', aspect: 'all'});
let renderBundleEncoder30 = device1.createRenderBundleEncoder({
  label: '\u{1fa4b}\u0465\u{1f814}\u7fee\u65f2\u020c\u57ef\u0084',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
});
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
document.body.prepend(canvas5);
let commandEncoder69 = device1.createCommandEncoder();
let querySet30 = device1.createQuerySet({label: '\u7782\u80f2\u{1ffb6}\u041a\u8b99\udbf0\u9203\uef4e', type: 'occlusion', count: 3538});
let computePassEncoder34 = commandEncoder64.beginComputePass({label: '\u{1fdc2}\u303c\u{1fa95}\u008a\u{1fe45}\u0434'});
let externalTexture31 = device1.importExternalTexture({label: '\u4e30\u63f4\u08ed\ueb68\u{1fb46}\u7f5d', source: videoFrame3});
try {
commandEncoder66.clearBuffer(buffer12, 3392, 968);
} catch {}
let video11 = await videoWithData();
let bindGroupLayout13 = device1.createBindGroupLayout({label: '\u{1fa47}\ue69a\u542e\u74ee\uc093', entries: []});
let buffer13 = device1.createBuffer({
  label: '\u0a78\u0ded',
  size: 186992,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let texture39 = device1.createTexture({
  label: '\u{1fab7}\u24eb',
  size: {width: 1100, height: 12, depthOrArrayLayers: 58},
  mipLevelCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['depth32float', 'depth32float'],
});
let textureView79 = texture37.createView({label: '\ufbc4\uf23d\u6cf5\u0ce1\u5c0b\ucb29\u37bf', baseMipLevel: 0});
let computePassEncoder35 = commandEncoder69.beginComputePass({label: '\u0444\u{1fe5a}\u{1fccb}\uae56\uc7ae\u0f87\ud60f\u06a4\u36ff\u{1ff0a}\u{1fa06}'});
let renderBundle48 = renderBundleEncoder30.finish({});
let sampler37 = device1.createSampler({
  label: '\u0b60\ufcf3\u4d19\u0ab0\u07a3\u{1fd0c}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 13.09,
  lodMaxClamp: 65.53,
  compare: 'less-equal',
  maxAnisotropy: 1,
});
try {
commandEncoder66.copyBufferToTexture({
  /* bytesInLastRow: 1028 widthInBlocks: 257 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 60200 */
  offset: 60200,
  bytesPerRow: 1280,
  buffer: buffer13,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 257, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup21 = device0.createBindGroup({
  label: '\u0748\ue1fe\u748c\u{1fa21}\u{1f60c}\u05d8\u51ea\u0e19\u022e\u0cf3\u2d1e',
  layout: bindGroupLayout2,
  entries: [],
});
let texture40 = device0.createTexture({
  label: '\u8ee7\ubfab\u{1fcb2}\uf84f\u0d30\u2945\u06ab\u0175\u00ab\ua42b\u{1fe44}',
  size: [1320, 960, 360],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder36 = commandEncoder50.beginComputePass({label: '\u7160\u2c4e\uc99b\uec7a\u0517'});
let renderBundleEncoder31 = device0.createRenderBundleEncoder({
  label: '\ucb97\u0216\u384c\u31b6\u0ab3\u{1fef6}\u00c8',
  colorFormats: ['rgba8unorm'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let externalTexture32 = device0.importExternalTexture({label: '\ub6de\uee27\u{1f898}\u0d92', source: videoFrame5, colorSpace: 'srgb'});
try {
renderBundleEncoder13.draw(224, 247, 302, 77);
} catch {}
try {
renderBundleEncoder13.drawIndexed(229, 9, 300, 164_341_254, 373_795_119);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer0, 17_464);
} catch {}
let promise16 = device0.popErrorScope();
try {
device0.queue.writeBuffer(buffer3, 12516, new Int16Array(61749), 30215, 136);
} catch {}
let promise17 = device0.queue.onSubmittedWorkDone();
let imageData10 = new ImageData(56, 24);
try {
canvas10.getContext('webgl');
} catch {}
try {
device1.pushErrorScope('out-of-memory');
} catch {}
try {
device1.queue.writeBuffer(buffer12, 120, new Float32Array(53347), 26923, 392);
} catch {}
let commandEncoder70 = device0.createCommandEncoder({label: '\u{1f911}\u{1f879}'});
try {
computePassEncoder24.setPipeline(pipeline39);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer11, 70_224);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 178, y: 1, z: 23},
  aspect: 'all',
}, arrayBuffer1, /* required buffer size: 872_482 */
{offset: 738, bytesPerRow: 1720, rowsPerImage: 216}, {width: 356, height: 75, depthOrArrayLayers: 3});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 26}
*/
{
  source: video3,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture2,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 3, depthOrArrayLayers: 0});
} catch {}
gc();
let querySet31 = device0.createQuerySet({
  label: '\u25c6\udd7e\ub846\uf55f\u013a\u{1fde7}\uef81\u6557\uf136\u{1ff15}\u0472',
  type: 'occlusion',
  count: 582,
});
let textureView80 = texture16.createView({label: '\ud877\u{1f7d8}\u76a0\ueb89\ud930', arrayLayerCount: 1});
let renderBundle49 = renderBundleEncoder31.finish({label: '\u4d4e\u0c5f\u22b1\u7b66\u3c66\u0b5e\ucd19'});
let externalTexture33 = device0.importExternalTexture({
  label: '\ubf10\u1825\u0be2\u0798\u04e2\ucbb6\u5d96\u6dff\u0b6d\u{1fde6}',
  source: videoFrame4,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder13.drawIndexed(137, 221, 141, 439_271_784, 1_217_818_960);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData7,
  origin: { x: 27, y: 46 },
  flipY: true,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let querySet32 = device0.createQuerySet({
  label: '\u9b7a\ue750\u6e14\u0380\ude06\u{1f8da}\u8c4e\u4d5b\u{1f74d}\u0d97\u3039',
  type: 'occlusion',
  count: 421,
});
let commandBuffer16 = commandEncoder48.finish();
let texture41 = device0.createTexture({
  label: '\u000f\u37d0\u0198',
  size: [1320, 960, 124],
  mipLevelCount: 9,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba16float', 'rgba16float', 'rgba16float'],
});
try {
computePassEncoder3.setPipeline(pipeline31);
} catch {}
try {
renderBundleEncoder13.drawIndexed(192, 44, 46, 331_534_039, 147_578_088);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer5, 10_668);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(1, buffer6, 644);
} catch {}
try {
commandEncoder19.copyBufferToTexture({
  /* bytesInLastRow: 448 widthInBlocks: 56 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 92048 */
  offset: 44496,
  bytesPerRow: 512,
  buffer: buffer3,
}, {
  texture: texture40,
  mipLevel: 2,
  origin: {x: 1, y: 45, z: 0},
  aspect: 'all',
}, {width: 56, height: 93, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 1,
  origin: {x: 23, y: 0, z: 1},
  aspect: 'all',
}, new BigInt64Array(arrayBuffer1), /* required buffer size: 10_468_771 */
{offset: 499, bytesPerRow: 306, rowsPerImage: 315}, {width: 3, height: 191, depthOrArrayLayers: 109});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 124}
*/
{
  source: img6,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture24,
  mipLevel: 1,
  origin: {x: 9, y: 18, z: 4},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 8, depthOrArrayLayers: 0});
} catch {}
let pipeline58 = device0.createRenderPipeline({
  label: '\u02e9\u3abc',
  layout: pipelineLayout2,
  multisample: {count: 4, mask: 0xa5a6fcd3},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'dst-alpha'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rgba8sint', writeMask: 0}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg16uint', writeMask: GPUColorWrite.GREEN}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'dst'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 92, attributes: []},
      {arrayStride: 24, attributes: []},
      {arrayStride: 1160, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 40, stepMode: 'instance', attributes: []},
      {arrayStride: 1872, stepMode: 'instance', attributes: []},
      {arrayStride: 788, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 592,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x2', offset: 276, shaderLocation: 13},
          {format: 'sint16x2', offset: 84, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'ccw'},
});
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
canvas9.height = 1184;
let imageBitmap8 = await createImageBitmap(video7);
let bindGroup22 = device1.createBindGroup({layout: bindGroupLayout13, entries: []});
let computePassEncoder37 = commandEncoder68.beginComputePass({label: '\u4e44\u0c3a'});
let sampler38 = device1.createSampler({
  label: '\u0654\u0d16',
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 16.94,
  maxAnisotropy: 3,
});
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 13612 */
  offset: 13612,
  buffer: buffer13,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let renderBundle50 = renderBundleEncoder30.finish();
try {
commandEncoder66.copyBufferToTexture({
  /* bytesInLastRow: 768 widthInBlocks: 192 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 14860 */
  offset: 14860,
  buffer: buffer13,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 192, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise17;
} catch {}
let bindGroupLayout14 = device1.createBindGroupLayout({
  label: '\u666a\u{1fc37}\u1c8c\u{1ff44}\u{1fa36}\u76e2\u9090\u02b7\u387e\u48b6\u{1fd77}',
  entries: [
    {
      binding: 959,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 522,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
    },
  ],
});
let renderBundle51 = renderBundleEncoder28.finish({label: '\ubdb7\u{1f75d}\udbe2\u1f3a\u0541\u08f8\u44b2\uccb7'});
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 704 widthInBlocks: 176 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 4616 */
  offset: 4616,
  bytesPerRow: 768,
  buffer: buffer12,
}, {width: 176, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder66.clearBuffer(buffer13);
} catch {}
try {
device1.queue.writeBuffer(buffer13, 84344, new BigUint64Array(29598), 17570);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let img7 = await imageWithData(288, 260, '#46a90666', '#f925566e');
let computePassEncoder38 = commandEncoder66.beginComputePass({label: '\uf04c\u0617\u{1f812}\u3021\u6a99\u71d8\ua841'});
let renderBundleEncoder32 = device1.createRenderBundleEncoder({
  label: '\u05b0\ua6da\uf747\u{1f999}\u7e25\u0ff3\u01e2\u3167',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
});
let renderBundle52 = renderBundleEncoder28.finish({label: '\u8949\u0450\u{1fb3d}\u08d0\u{1f968}\u0d86\u{1f9e7}\ucc67\u1dff\u016d'});
try {
renderBundleEncoder32.setBindGroup(2, bindGroup22);
} catch {}
try {
renderBundleEncoder32.setVertexBuffer(6, buffer13, 0, 28_162);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 332, new BigUint64Array(46779), 28279, 36);
} catch {}
try {
  await promise16;
} catch {}
let pipelineLayout5 = device1.createPipelineLayout({
  label: '\u{1fc42}\ub42b\u03d2',
  bindGroupLayouts: [bindGroupLayout13, bindGroupLayout13, bindGroupLayout13, bindGroupLayout14],
});
let querySet33 = device1.createQuerySet({type: 'occlusion', count: 44});
let texture42 = device1.createTexture({
  label: '\u0298\uee1d\ufda2\uae67\u555d',
  size: [10, 10, 1],
  mipLevelCount: 4,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['depth32float', 'depth32float'],
});
let textureView81 = texture39.createView({
  label: '\u05c0\u{1fc43}\uc417\ua592\u4083\uacfb\uad9f\u49a9\u08bf\uba46',
  aspect: 'depth-only',
  format: 'depth32float',
  baseMipLevel: 2,
  mipLevelCount: 1,
  baseArrayLayer: 31,
  arrayLayerCount: 17,
});
let renderBundleEncoder33 = device1.createRenderBundleEncoder({
  label: '\u4ae7\u{1fd80}\u014b\u09be\u0de9\u0abf\u2f91\u86a2\u08bc\u05d5',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  stencilReadOnly: true,
});
let externalTexture34 = device1.importExternalTexture({source: videoFrame5, colorSpace: 'display-p3'});
try {
computePassEncoder31.setBindGroup(1, bindGroup22);
} catch {}
try {
device1.queue.submit([]);
} catch {}
let textureView82 = texture42.createView({label: '\u4140\ubab9\u{1f8af}\u45ff\u0d17\u{1f64b}\u9759\u0020', baseMipLevel: 3});
let renderBundleEncoder34 = device1.createRenderBundleEncoder({
  label: '\ua638\u65aa',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  stencilReadOnly: true,
});
try {
computePassEncoder34.setBindGroup(1, bindGroup22, new Uint32Array(2851), 1147, 0);
} catch {}
try {
computePassEncoder32.end();
} catch {}
try {
renderBundleEncoder34.setBindGroup(3, bindGroup22, new Uint32Array(9136), 6460, 0);
} catch {}
try {
commandEncoder65.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 36360 */
  offset: 36360,
  buffer: buffer13,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder65.copyTextureToTexture({
  texture: texture42,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture42,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
},
{width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer13, 10156, new Int16Array(52409), 7933);
} catch {}
let shaderModule10 = device1.createShaderModule({
  label: '\u{1f6a2}\u5418\u09ac\ubed2\u0001\u23ac',
  code: `@group(3) @binding(522)
var<storage, read_write> function3: array<u32>;

@compute @workgroup_size(8, 2, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S10 {
  @builtin(position) f0: vec4<f32>,
  @builtin(sample_mask) f1: u32
}
struct FragmentOutput0 {
  @location(1) f0: i32,
  @builtin(frag_depth) f1: f32,
  @location(0) f2: vec4<i32>,
  @location(3) f3: vec2<f32>,
  @location(2) f4: vec4<f32>
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32, @builtin(front_facing) a1: bool, a2: S10) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S9 {
  @builtin(vertex_index) f0: u32
}

@vertex
fn vertex0(@location(9) a0: vec4<f32>, @builtin(instance_index) a1: u32, a2: S9, @location(13) a3: f16, @location(10) a4: vec4<f16>, @location(4) a5: vec2<f32>, @location(5) a6: vec2<u32>, @location(15) a7: vec3<i32>, @location(1) a8: vec3<f32>, @location(12) a9: vec2<i32>, @location(0) a10: vec2<i32>, @location(3) a11: vec2<i32>, @location(6) a12: vec2<i32>, @location(14) a13: vec3<u32>, @location(2) a14: i32, @location(11) a15: vec4<f32>, @location(8) a16: vec4<u32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder71 = device1.createCommandEncoder({label: '\u0672\u69ad\u{1fe51}\ue2d2\u967d\u0ae4\u07dd\u6aac\u883d\u{1f7b8}'});
let commandBuffer17 = commandEncoder71.finish({label: '\u{1ff0a}\u4ee6\u{1fa76}\u8755\u{1fe9f}\u0d5f\u04cd\u136c\u19d7\u0575'});
let textureView83 = texture42.createView({label: '\u0f1c\u038b\u0466\u{1fc76}\u24cd', baseMipLevel: 1});
let renderBundleEncoder35 = device1.createRenderBundleEncoder({
  label: '\u038e\u{1f78f}\u2d6e\u53ca\u{1f96b}\u{1fae5}\u0b7b\u030e\u08aa\u00d1\u{1fc73}',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
});
let promise18 = device1.popErrorScope();
try {
device1.queue.writeBuffer(buffer12, 92, new Float32Array(52621), 39675, 128);
} catch {}
let pipeline59 = device1.createComputePipeline({layout: pipelineLayout5, compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}}});
gc();
let canvas11 = document.createElement('canvas');
let offscreenCanvas4 = new OffscreenCanvas(150, 230);
let renderBundle53 = renderBundleEncoder33.finish({label: '\u009f\u0c6b\u0610\ueece\u424c\u8386\u8f33\ud802\uc11a\u{1f99c}\u046d'});
let sampler39 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 25.99,
  lodMaxClamp: 31.47,
  maxAnisotropy: 3,
});
let externalTexture35 = device1.importExternalTexture({source: video3});
try {
computePassEncoder37.setBindGroup(0, bindGroup22);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(0, buffer12, 1_556, 251);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 740 widthInBlocks: 185 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 11376 */
  offset: 11376,
  buffer: buffer13,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 185, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder65.copyTextureToTexture({
  texture: texture42,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
},
{
  texture: texture42,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline60 = await device1.createRenderPipelineAsync({
  label: '\u38f8\uf0d5\u585c\u37fb\uab52\ua0f4\u0751',
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.GREEN}, {format: 'r32sint', writeMask: 0}, {format: 'rgb10a2unorm'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilFront: {compare: 'greater', failOp: 'increment-wrap', depthFailOp: 'zero', passOp: 'increment-clamp'},
    stencilBack: {compare: 'greater', failOp: 'replace', depthFailOp: 'invert', passOp: 'decrement-wrap'},
    stencilReadMask: 2625613984,
    stencilWriteMask: 1828532665,
    depthBias: -323557681,
    depthBiasClamp: 666.7198495020881,
  },
  vertex: {
    module: shaderModule10,
    buffers: [
      {arrayStride: 296, attributes: []},
      {arrayStride: 540, stepMode: 'instance', attributes: []},
      {arrayStride: 72, stepMode: 'vertex', attributes: [{format: 'sint16x4', offset: 0, shaderLocation: 3}]},
      {arrayStride: 0, attributes: []},
      {arrayStride: 932, stepMode: 'instance', attributes: []},
      {arrayStride: 88, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint8x4', offset: 88, shaderLocation: 12},
          {format: 'uint16x4', offset: 228, shaderLocation: 5},
          {format: 'sint32', offset: 24, shaderLocation: 15},
          {format: 'float32', offset: 112, shaderLocation: 10},
          {format: 'uint32x3', offset: 272, shaderLocation: 14},
          {format: 'snorm16x2', offset: 276, shaderLocation: 13},
          {format: 'sint32x4', offset: 320, shaderLocation: 2},
          {format: 'unorm8x4', offset: 248, shaderLocation: 4},
          {format: 'float16x4', offset: 112, shaderLocation: 9},
          {format: 'snorm16x2', offset: 452, shaderLocation: 1},
          {format: 'snorm16x2', offset: 328, shaderLocation: 11},
          {format: 'sint32x3', offset: 168, shaderLocation: 6},
          {format: 'sint8x2', offset: 152, shaderLocation: 0},
          {format: 'uint32x3', offset: 496, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', cullMode: 'back'},
});
canvas5.width = 400;
try {
offscreenCanvas4.getContext('webgl');
} catch {}
try {
renderBundleEncoder32.setBindGroup(0, bindGroup22);
} catch {}
try {
commandEncoder65.copyBufferToBuffer(buffer13, 66292, buffer12, 4084, 820);
} catch {}
try {
commandEncoder65.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1552 */
  offset: 1552,
  rowsPerImage: 211,
  buffer: buffer12,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder65.copyTextureToTexture({
  texture: texture42,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
},
{
  texture: texture42,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
canvas0.height = 138;
let imageData11 = new ImageData(144, 240);
let videoFrame6 = new VideoFrame(imageBitmap1, {timestamp: 0});
let bindGroupLayout15 = device0.createBindGroupLayout({
  label: '\u{1ffd5}\u20d6\u0a6e\u{1fa31}\u{1f7bd}\u7456\ud154\u02d4\u656e\u{1f96f}\u53fb',
  entries: [
    {binding: 454, visibility: 0, externalTexture: {}},
    {binding: 379, visibility: 0, sampler: { type: 'non-filtering' }},
  ],
});
try {
renderBundleEncoder13.draw(24, 87, 157, 45);
} catch {}
try {
renderBundleEncoder13.drawIndexed(37, 79, 731, 978_799_265, 280_873_818);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(2, buffer7);
} catch {}
try {
commandEncoder13.copyBufferToBuffer(buffer4, 18172, buffer9, 49664, 38888);
} catch {}
try {
commandEncoder24.copyTextureToTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder67.pushDebugGroup('\u4b4f');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 189, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer3, /* required buffer size: 359 */
{offset: 359, rowsPerImage: 261}, {width: 116, height: 0, depthOrArrayLayers: 1});
} catch {}
let querySet34 = device0.createQuerySet({label: '\u59e9\udbcb\u0d0f\u66d7', type: 'occlusion', count: 2026});
let textureView84 = texture33.createView({label: '\ub7ca\u0cfd\u056d\u5488\u2719\u095a\ua115\u{1fba7}\ud424\uf7b6\u9b1a', baseMipLevel: 1});
try {
computePassEncoder0.dispatchWorkgroups(5, 3, 1);
} catch {}
try {
renderBundleEncoder13.draw(282, 52, 66, 19);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer0, 18_740);
} catch {}
let pipeline61 = device0.createRenderPipeline({
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule8,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'zero'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'dst-alpha', dstFactor: 'one-minus-src-alpha'},
    alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'dst'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {
  format: 'rg16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'src'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'src-alpha'},
  },
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'equal',
    stencilFront: {compare: 'not-equal', failOp: 'decrement-wrap', depthFailOp: 'invert', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'less-equal', failOp: 'replace', depthFailOp: 'keep', passOp: 'zero'},
    stencilReadMask: 840621742,
    stencilWriteMask: 3386271520,
    depthBiasSlopeScale: 323.01382579662953,
    depthBiasClamp: 249.8745600173549,
  },
  vertex: {
    module: shaderModule8,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 56, stepMode: 'vertex', attributes: []},
      {arrayStride: 828, stepMode: 'vertex', attributes: []},
      {arrayStride: 456, stepMode: 'vertex', attributes: []},
      {arrayStride: 196, stepMode: 'instance', attributes: []},
      {arrayStride: 40, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 164, stepMode: 'instance', attributes: []},
      {
        arrayStride: 412,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 20, shaderLocation: 5},
          {format: 'float32x4', offset: 248, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'ccw', cullMode: 'front'},
});
try {
  await promise18;
} catch {}
let commandEncoder72 = device0.createCommandEncoder({label: '\u81b0\u0c11\u{1f88d}\u5d62\u6d6a\ueecf\u{1fbd9}\u9415\u{1fc14}'});
let texture43 = device0.createTexture({
  label: '\u9a54\ua743\u1d7d\u6cd7\u{1fb8d}\u0a32\u{1fd2a}',
  size: {width: 660, height: 480, depthOrArrayLayers: 222},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm'],
});
let textureView85 = texture3.createView({label: '\u0131\uf40c', aspect: 'all', baseArrayLayer: 0});
let computePassEncoder39 = commandEncoder13.beginComputePass({label: '\u3bda\u1855\u7467\u0566\u0119\u06cc'});
try {
renderBundleEncoder13.drawIndexed(266, 224, 614, 322_343_449, 1_133_304_860);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer5, 32_248);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(5, buffer5, 0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(859), /* required buffer size: 859 */
{offset: 859}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise19 = device0.queue.onSubmittedWorkDone();
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 806}
*/
{
  source: canvas2,
  origin: { x: 180, y: 108 },
  flipY: true,
}, {
  texture: texture27,
  mipLevel: 0,
  origin: {x: 14, y: 5, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 19, height: 18, depthOrArrayLayers: 0});
} catch {}
let pipeline62 = device0.createRenderPipeline({
  label: '\u0518\u2103\u55d6\u{1fcdc}\u0ccb\u{1f6c2}',
  layout: pipelineLayout3,
  multisample: {count: 4, mask: 0xa7794576},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rgba8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'dst'},
    alpha: {operation: 'subtract', srcFactor: 'src-alpha', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16uint', writeMask: GPUColorWrite.GREEN}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'not-equal', failOp: 'invert', depthFailOp: 'increment-clamp', passOp: 'increment-wrap'},
    stencilBack: {compare: 'not-equal', failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'invert'},
    stencilReadMask: 4210792329,
  },
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 480, attributes: []},
      {arrayStride: 344, attributes: []},
      {arrayStride: 56, attributes: []},
      {arrayStride: 64, stepMode: 'vertex', attributes: []},
      {arrayStride: 100, stepMode: 'instance', attributes: []},
      {arrayStride: 428, attributes: []},
      {arrayStride: 908, stepMode: 'instance', attributes: []},
      {
        arrayStride: 252,
        attributes: [
          {format: 'sint16x2', offset: 140, shaderLocation: 4},
          {format: 'uint32x4', offset: 12, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let computePassEncoder40 = commandEncoder10.beginComputePass({label: '\u{1f86d}\u07ea\u0893\ubaaf\u0b12\u0fb6'});
try {
computePassEncoder18.setBindGroup(1, bindGroup7, new Uint32Array(2166), 2081, 0);
} catch {}
try {
computePassEncoder3.dispatchWorkgroups(1, 1, 4);
} catch {}
try {
renderBundleEncoder13.draw(164, 53, 355, 155);
} catch {}
try {
renderBundleEncoder13.drawIndexed(507, 189, 64, 279_107_990, 692_315_630);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer5, 18_316);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame7 = new VideoFrame(videoFrame5, {timestamp: 0});
let commandBuffer18 = commandEncoder65.finish({label: '\ua646\u62eb\u{1fdab}\u739c\ud965\u08da\u296c\u8d36\u08a1'});
let sampler40 = device1.createSampler({
  label: '\u05e2\uf3aa\u7a0b\u{1ff86}\u0fef\u0bb2',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 69.67,
  lodMaxClamp: 94.51,
});
try {
computePassEncoder34.setBindGroup(0, bindGroup22, new Uint32Array(5993), 1968, 0);
} catch {}
let commandEncoder73 = device1.createCommandEncoder({label: '\u3995\u07a2\u0d5f\u{1f864}'});
let commandBuffer19 = commandEncoder73.finish({label: '\u695a\u953f\u{1f9ad}\u09ad'});
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer2, /* required buffer size: 428 */
{offset: 428}, {width: 13, height: 1, depthOrArrayLayers: 0});
} catch {}
let imageBitmap9 = await createImageBitmap(imageData9);
let commandEncoder74 = device0.createCommandEncoder({label: '\ud537\u0de3\u0859\u{1fc6b}\ud687\u02e9\ud58d\u002a'});
let commandBuffer20 = commandEncoder24.finish();
let textureView86 = texture11.createView({baseMipLevel: 6, mipLevelCount: 1, baseArrayLayer: 0});
let renderBundleEncoder36 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], sampleCount: 4, stencilReadOnly: true});
try {
computePassEncoder26.setPipeline(pipeline31);
} catch {}
try {
renderBundleEncoder13.drawIndexed(82, 26, 219, -2_000_020_566, 339_722_565);
} catch {}
try {
commandEncoder72.copyBufferToBuffer(buffer1, 261424, buffer10, 38880, 1200);
} catch {}
try {
commandEncoder20.clearBuffer(buffer1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 124}
*/
{
  source: imageBitmap5,
  origin: { x: 8, y: 3 },
  flipY: false,
}, {
  texture: texture24,
  mipLevel: 1,
  origin: {x: 25, y: 25, z: 55},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 5, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout16 = device1.createBindGroupLayout({
  label: '\uc586\udf18\u3d95\u00a8',
  entries: [{binding: 32, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}],
});
let commandEncoder75 = device1.createCommandEncoder({label: '\u2491\uc730\u04d5\u0420\udb92'});
let renderBundleEncoder37 = device1.createRenderBundleEncoder({
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  sampleCount: 1,
  depthReadOnly: true,
});
try {
computePassEncoder37.setPipeline(pipeline59);
} catch {}
try {
buffer12.unmap();
} catch {}
let pipeline63 = await device1.createComputePipelineAsync({
  label: '\ucbc2\u08d9\u{1f6d6}\u0b6c\u{1fb2d}\udf38\u124e',
  layout: pipelineLayout5,
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let bindGroup23 = device0.createBindGroup({
  label: '\ufeaa\u2876\ua533\u83c2\u25fa\u73c0\u{1f8a2}\u016b\u0000',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer5, offset: 283648}}],
});
let renderBundleEncoder38 = device0.createRenderBundleEncoder({
  label: '\u{1fe1e}\u0af4\u{1fbdc}\u0f65\u0b3b\u0f67\uebab\u6608',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
});
let externalTexture36 = device0.importExternalTexture({
  label: '\u{1fda2}\u07a9\u2ea2\u{1fb42}\u0595\u849a\u{1f9a2}',
  source: video6,
  colorSpace: 'display-p3',
});
try {
commandEncoder43.clearBuffer(buffer1);
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
document.body.prepend(img5);
video2.height = 202;
let video12 = await videoWithData();
let externalTexture37 = device1.importExternalTexture({
  label: '\u61e2\ude46\u461a\u9176\u79cc\ud540\u06d8\u0bc4\u138a\u8f6b',
  source: video3,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder35.setVertexBuffer(6, buffer12, 888, 532);
} catch {}
try {
commandEncoder75.copyBufferToBuffer(buffer13, 130420, buffer12, 388, 5628);
} catch {}
try {
commandEncoder75.clearBuffer(buffer13, 134632);
} catch {}
let computePassEncoder41 = commandEncoder72.beginComputePass();
try {
commandEncoder62.copyBufferToBuffer(buffer4, 153924, buffer1, 8504, 6444);
} catch {}
try {
canvas11.getContext('webgl2');
} catch {}
let textureView87 = texture38.createView({dimension: '2d-array'});
let computePassEncoder42 = commandEncoder75.beginComputePass({label: '\u03d9\u01df\u4620'});
let renderBundleEncoder39 = device1.createRenderBundleEncoder({
  label: '\u{1f85b}\u70be\ua1d4\u0207\u8e5a\u043e\u{1fa16}\udc34',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  sampleCount: 1,
  depthReadOnly: true,
});
try {
computePassEncoder38.setPipeline(pipeline63);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(2, buffer12, 320, 258);
} catch {}
let computePassEncoder43 = commandEncoder11.beginComputePass({});
let renderBundle54 = renderBundleEncoder9.finish({label: '\u{1fb28}\u1b26\u7b30\uc089\u0147\u{1fddd}\u6cc9\u2e7a\u50e3\u08e5'});
try {
computePassEncoder26.dispatchWorkgroups(1);
} catch {}
try {
renderBundleEncoder13.draw(70, 240, 40, 226);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer11, 4_296);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer3, 'uint16', 7_604, 2_689);
} catch {}
try {
renderBundleEncoder38.setPipeline(pipeline19);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 3,
  origin: {x: 2, y: 0, z: 2},
  aspect: 'all',
}, new ArrayBuffer(8), /* required buffer size: 541_783 */
{offset: 292, bytesPerRow: 189, rowsPerImage: 220}, {width: 3, height: 6, depthOrArrayLayers: 14});
} catch {}
let promise20 = device0.createComputePipelineAsync({
  label: '\u5884\ue51e',
  layout: pipelineLayout4,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let bindGroupLayout17 = device0.createBindGroupLayout({
  label: '\ufb92\u7e64\ub93d\u{1fa9d}\u63ff\u6603\u{1f7ec}',
  entries: [
    {
      binding: 834,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {binding: 464, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
    {
      binding: 91,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let textureView88 = texture22.createView({dimension: '2d', aspect: 'depth-only', baseMipLevel: 8, baseArrayLayer: 113, arrayLayerCount: 1});
let renderBundleEncoder40 = device0.createRenderBundleEncoder({
  label: '\u0ecf\u2463\u{1fec3}\ue309\u0363\u{1f81c}\u2529',
  colorFormats: ['rgba8unorm'],
  sampleCount: 4,
  depthReadOnly: true,
});
let renderBundle55 = renderBundleEncoder0.finish({});
try {
renderBundleEncoder13.draw(17, 467, 65, 22);
} catch {}
try {
renderBundleEncoder13.drawIndexed(435, 89, 51, 67_144_145, 63_002_999);
} catch {}
try {
renderBundleEncoder13.drawIndirect(buffer5, 756);
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline16);
} catch {}
try {
commandEncoder60.clearBuffer(buffer1);
} catch {}
let pipeline64 = await promise20;
let pipeline65 = device0.createRenderPipeline({
  label: '\u2374\u969e\u{1fdf4}\u{1fea5}\u{1fd48}\u{1f994}\u9564\u51fd\ucf25',
  layout: pipelineLayout0,
  multisample: {count: 4, mask: 0xe55191b3},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg16float', writeMask: 0}, {format: 'rgba16uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule0,
    buffers: [
      {arrayStride: 432, stepMode: 'instance', attributes: []},
      {arrayStride: 116, attributes: []},
      {arrayStride: 588, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 1008, attributes: []},
      {arrayStride: 464, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 72, shaderLocation: 14},
          {format: 'sint8x2', offset: 78, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'},
});
let offscreenCanvas5 = new OffscreenCanvas(722, 179);
let imageData12 = new ImageData(256, 88);
let commandEncoder76 = device1.createCommandEncoder({});
let computePassEncoder44 = commandEncoder76.beginComputePass();
let sampler41 = device1.createSampler({
  label: '\u00ef\uf9d2',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 88.71,
  lodMaxClamp: 99.56,
  maxAnisotropy: 13,
});
try {
renderBundleEncoder37.setVertexBuffer(4_294_967_295, undefined);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 240, new BigUint64Array(9769), 1631, 96);
} catch {}
let querySet35 = device0.createQuerySet({
  label: '\u78c1\u0767\u{1fc75}\u0d2f\ue26b\u09a0\u{1f753}\u{1fa51}\uac5a',
  type: 'occlusion',
  count: 90,
});
try {
computePassEncoder7.setPipeline(pipeline33);
} catch {}
try {
renderBundleEncoder20.setBindGroup(0, bindGroup0);
} catch {}
try {
renderBundleEncoder13.draw(107, 70, 127, 221);
} catch {}
try {
commandEncoder31.copyBufferToBuffer(buffer1, 38196, buffer10, 11588, 28272);
} catch {}
let pipeline66 = device0.createComputePipeline({
  label: '\ua3d9\u0cbe\uf06f\u00f4\u8fac\u9f95',
  layout: pipelineLayout0,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let video13 = await videoWithData();
let texture44 = device1.createTexture({
  size: [20, 20, 59],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView89 = texture38.createView({
  label: '\ue0d7\u8f76\u{1fd9c}\u2af4\u{1f613}\ub5a7\ua16a\u{1fe7d}',
  dimension: '2d-array',
  aspect: 'all',
});
try {
renderBundleEncoder32.setVertexBuffer(7, buffer12, 0, 97);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer2, /* required buffer size: 1_233 */
{offset: 981}, {width: 63, height: 1, depthOrArrayLayers: 1});
} catch {}
let imageBitmap10 = await createImageBitmap(imageBitmap2);
let bindGroup24 = device0.createBindGroup({
  label: '\u73c0\u7923\u6e7e\u4cde\u{1fabe}\u8044\u{1fdfb}\udbea\u2969\u571e\u7b8c',
  layout: bindGroupLayout11,
  entries: [],
});
try {
computePassEncoder3.dispatchWorkgroups(3, 1, 3);
} catch {}
let arrayBuffer4 = buffer8.getMappedRange(119864, 12708);
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(8), /* required buffer size: 40 */
{offset: 40}, {width: 944, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 82}
*/
{
  source: video8,
  origin: { x: 2, y: 5 },
  flipY: true,
}, {
  texture: texture8,
  mipLevel: 1,
  origin: {x: 0, y: 3, z: 15},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 8, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
try {
externalTexture35.label = '\u0a54\u{1f71c}\u0d90\u{1fb53}\u0340\u4072\u175d\ufeff\u416f';
} catch {}
let commandEncoder77 = device1.createCommandEncoder({label: '\u0adf\u{1fd09}\u{1fe5c}\uad49\u{1fb02}\u0ca9'});
let textureView90 = texture36.createView({baseArrayLayer: 0});
try {
renderBundleEncoder35.setIndexBuffer(buffer13, 'uint32', 71_656, 828);
} catch {}
try {
commandEncoder77.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 6768 */
  offset: 6768,
  buffer: buffer13,
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder77.clearBuffer(buffer12, 704, 664);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 276, new DataView(new ArrayBuffer(19077)), 4237, 5516);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(40), /* required buffer size: 903 */
{offset: 847}, {width: 14, height: 1, depthOrArrayLayers: 1});
} catch {}
let video14 = await videoWithData();
let commandEncoder78 = device0.createCommandEncoder();
let texture45 = device0.createTexture({
  label: '\u0f10\u{1f661}\u0fb3',
  size: {width: 1320},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['r16float'],
});
try {
renderBundleEncoder13.draw(212, 113, 279, 319);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer3, 'uint16', 8_490, 43_741);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline32);
} catch {}
try {
commandEncoder37.copyTextureToTexture({
  texture: texture1,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture40,
  mipLevel: 1,
  origin: {x: 29, y: 232, z: 14},
  aspect: 'all',
},
{width: 4, height: 2, depthOrArrayLayers: 5});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(new ArrayBuffer(8)), /* required buffer size: 495 */
{offset: 491}, {width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline67 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  multisample: {mask: 0x5037e7e8},
  fragment: {module: shaderModule9, entryPoint: 'fragment0', constants: {}, targets: [{format: 'r32float'}]},
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 344,
        attributes: [
          {format: 'uint8x2', offset: 20, shaderLocation: 10},
          {format: 'uint32', offset: 24, shaderLocation: 4},
          {format: 'float16x4', offset: 64, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 1116,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 84, shaderLocation: 3},
          {format: 'float32x2', offset: 264, shaderLocation: 7},
        ],
      },
      {arrayStride: 40, stepMode: 'instance', attributes: []},
      {
        arrayStride: 660,
        attributes: [
          {format: 'unorm8x4', offset: 20, shaderLocation: 15},
          {format: 'snorm8x4', offset: 324, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 48,
        stepMode: 'vertex',
        attributes: [{format: 'uint32x3', offset: 4, shaderLocation: 14}],
      },
      {arrayStride: 224, attributes: []},
      {arrayStride: 64, stepMode: 'instance', attributes: []},
      {
        arrayStride: 88,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x2', offset: 8, shaderLocation: 13},
          {format: 'uint16x4', offset: 0, shaderLocation: 0},
          {format: 'sint32x3', offset: 20, shaderLocation: 11},
          {format: 'uint16x4', offset: 16, shaderLocation: 6},
          {format: 'snorm16x2', offset: 0, shaderLocation: 12},
          {format: 'unorm8x4', offset: 8, shaderLocation: 8},
          {format: 'sint32', offset: 16, shaderLocation: 1},
          {format: 'float32', offset: 0, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', cullMode: 'back'},
});
let bindGroupLayout18 = device1.createBindGroupLayout({
  label: '\u69a2\ucb89\u13e8\uf062\u6bc8',
  entries: [
    {
      binding: 220,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d' },
    },
    {binding: 20, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
    {binding: 525, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }},
  ],
});
let bindGroup25 = device1.createBindGroup({
  label: '\u0d16\u{1fe9a}\u01a2\u09cf\u3707\u02dc\u{1f8ff}\u64cc\u0175\u{1ff19}\u0ccc',
  layout: bindGroupLayout13,
  entries: [],
});
let texture46 = device1.createTexture({
  size: [275, 3, 76],
  mipLevelCount: 6,
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture38 = device1.importExternalTexture({label: '\u{1f63c}\u0e69', source: videoFrame5, colorSpace: 'srgb'});
try {
computePassEncoder37.setBindGroup(1, bindGroup22, new Uint32Array(9353), 2174, 0);
} catch {}
try {
buffer13.unmap();
} catch {}
try {
commandEncoder77.copyBufferToTexture({
  /* bytesInLastRow: 332 widthInBlocks: 83 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 26692 */
  offset: 26692,
  buffer: buffer13,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 75, y: 0, z: 0},
  aspect: 'all',
}, {width: 83, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder42.pushDebugGroup('\u0c6c');
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(0), /* required buffer size: 350 */
{offset: 350, rowsPerImage: 15}, {width: 261, height: 0, depthOrArrayLayers: 1});
} catch {}
let textureView91 = texture17.createView({label: '\uf6a7\u{1f837}\uc4f4\u44ae\u0c03\u0239\u{1f7b2}\u{1f9e5}\u8d7c', arrayLayerCount: 1});
let computePassEncoder45 = commandEncoder42.beginComputePass({label: '\ud354\u9755\u{1fb3f}\u00f6\u74a4\u25ad\u39c4'});
let renderPassEncoder0 = commandEncoder19.beginRenderPass({
  label: '\u08fc\udb7e\uc80b\uab32',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: -571.5, g: -378.9, b: 59.33, a: -226.6, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet24,
});
try {
renderPassEncoder0.setBindGroup(0, bindGroup8);
} catch {}
try {
renderPassEncoder0.executeBundles([]);
} catch {}
try {
renderPassEncoder0.setScissorRect(18, 73, 113, 37);
} catch {}
try {
renderPassEncoder0.setViewport(53.07, 29.33, 21.70, 46.67, 0.2193, 0.6894);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder13.draw(121, 32, 172, 680_325_714);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline16);
} catch {}
try {
commandEncoder46.resolveQuerySet(querySet1, 61, 172, buffer0, 22272);
} catch {}
let pipeline68 = device0.createRenderPipeline({
  label: '\u{1fa49}\u0370',
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule7,
  entryPoint: 'fragment0',
  targets: [{format: 'r16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'constant', dstFactor: 'constant'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rg16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule7,
    buffers: [
      {arrayStride: 356, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 612, shaderLocation: 6},
          {format: 'sint32x4', offset: 100, shaderLocation: 7},
          {format: 'sint32x4', offset: 0, shaderLocation: 0},
          {format: 'float32', offset: 512, shaderLocation: 9},
          {format: 'float32', offset: 436, shaderLocation: 3},
          {format: 'float16x2', offset: 180, shaderLocation: 5},
          {format: 'float16x2', offset: 328, shaderLocation: 4},
          {format: 'snorm8x2', offset: 264, shaderLocation: 2},
          {format: 'unorm8x4', offset: 160, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 1428,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x2', offset: 408, shaderLocation: 13}],
      },
      {arrayStride: 184, attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 52, stepMode: 'instance', attributes: []},
      {
        arrayStride: 232,
        attributes: [
          {format: 'float16x4', offset: 56, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 16, shaderLocation: 15},
          {format: 'sint32', offset: 24, shaderLocation: 1},
          {format: 'uint32x3', offset: 4, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 740,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint16x2', offset: 16, shaderLocation: 10},
          {format: 'uint32x2', offset: 4, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'none'},
});
let bindGroupLayout19 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 841,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', minBindingSize: 175163690, hasDynamicOffset: false },
    },
    {
      binding: 244,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 474,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let commandEncoder79 = device0.createCommandEncoder({label: '\ucac6\uea46\ucb0c\u0caf'});
let computePassEncoder46 = commandEncoder46.beginComputePass({});
try {
computePassEncoder24.setPipeline(pipeline31);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer6, 'uint32', 2_568, 18_079);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer0, 33_584);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 13968, new BigUint64Array(28315), 16483, 708);
} catch {}
let bindGroupLayout20 = device1.createBindGroupLayout({entries: []});
let texture47 = device1.createTexture({
  size: {width: 137},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32sint', 'r32sint'],
});
let textureView92 = texture39.createView({label: '\u4628\u9d88\udb5b\u0d77\u1e29\u47e9\u9537', baseMipLevel: 3, baseArrayLayer: 43});
let computePassEncoder47 = commandEncoder77.beginComputePass({label: '\uf27d\ue86b\u7dd3\u0941\u{1fd88}\u8608'});
let renderBundle56 = renderBundleEncoder35.finish({label: '\uaa42\u019b\u0cd9'});
try {
renderBundleEncoder39.setBindGroup(1, bindGroup22);
} catch {}
try {
computePassEncoder42.popDebugGroup();
} catch {}
document.body.prepend(canvas9);
try {
offscreenCanvas5.getContext('2d');
} catch {}
let texture48 = device1.createTexture({
  label: '\u680d\u5a13\u0ce1\u5e69\u2baa',
  size: [137, 1, 6],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['r16sint'],
});
let sampler42 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 58.10,
  lodMaxClamp: 83.90,
});
try {
renderBundleEncoder32.setIndexBuffer(buffer13, 'uint32', 27_132, 14_814);
} catch {}
let pipeline69 = device1.createRenderPipeline({
  label: '\udc5c\u0d36\uc5e3\ueec6\u{1febc}\u10e8\u0080\u0cb3\u0e58',
  layout: pipelineLayout5,
  multisample: {mask: 0x64ca2b6d},
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rgba32sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-src'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilFront: {compare: 'greater', failOp: 'decrement-clamp', depthFailOp: 'decrement-wrap', passOp: 'invert'},
    stencilBack: {compare: 'greater-equal', failOp: 'zero', passOp: 'invert'},
    stencilWriteMask: 4294967295,
    depthBiasSlopeScale: 552.5372341257421,
    depthBiasClamp: -64.99838921644476,
  },
  vertex: {
    module: shaderModule10,
    buffers: [
      {arrayStride: 84, stepMode: 'vertex', attributes: [{format: 'sint8x4', offset: 4, shaderLocation: 6}]},
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 0, shaderLocation: 9}],
      },
      {
        arrayStride: 256,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10},
          {format: 'uint32x2', offset: 132, shaderLocation: 8},
          {format: 'sint32x3', offset: 12, shaderLocation: 0},
          {format: 'unorm8x4', offset: 60, shaderLocation: 11},
        ],
      },
      {arrayStride: 80, attributes: []},
      {arrayStride: 152, stepMode: 'instance', attributes: []},
      {
        arrayStride: 596,
        attributes: [
          {format: 'snorm16x4', offset: 44, shaderLocation: 1},
          {format: 'uint32x3', offset: 16, shaderLocation: 14},
          {format: 'sint32x2', offset: 64, shaderLocation: 2},
          {format: 'sint16x4', offset: 100, shaderLocation: 15},
        ],
      },
      {arrayStride: 244, attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x4', offset: 648, shaderLocation: 12},
          {format: 'uint32x3', offset: 184, shaderLocation: 5},
          {format: 'sint16x2', offset: 900, shaderLocation: 3},
          {format: 'float32x4', offset: 636, shaderLocation: 4},
          {format: 'unorm8x4', offset: 360, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
try {
  await promise19;
} catch {}
let bindGroup26 = device1.createBindGroup({
  label: '\u{1f852}\u8180\u5282\u{1f63e}\u{1f78b}',
  layout: bindGroupLayout16,
  entries: [{binding: 32, resource: externalTexture35}],
});
let commandEncoder80 = device1.createCommandEncoder();
let querySet36 = device1.createQuerySet({label: '\u018d\u0f08\ua762', type: 'occlusion', count: 625});
let texture49 = device1.createTexture({
  label: '\u59d2\ud3e7\u{1fb8e}\u043c\u{1f9bb}\u3ead\u3529\uaa6b\u0731\u{1fc3a}\u76f7',
  size: [40, 40, 376],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView93 = texture39.createView({
  label: '\ud1a2\uebe4\uee7d\ucdb4\ua366\u3a34',
  aspect: 'depth-only',
  baseMipLevel: 1,
  baseArrayLayer: 33,
  arrayLayerCount: 22,
});
let computePassEncoder48 = commandEncoder80.beginComputePass({});
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Float64Array(arrayBuffer0), /* required buffer size: 1_141 */
{offset: 565}, {width: 144, height: 1, depthOrArrayLayers: 1});
} catch {}
let bindGroup27 = device0.createBindGroup({label: '\u0712\u0aa4\ucaf6\u7e61\u9d87\u0d52\u3c75\u4613', layout: bindGroupLayout3, entries: []});
let commandEncoder81 = device0.createCommandEncoder({label: '\u06a9\u01c0'});
let querySet37 = device0.createQuerySet({label: '\u{1f8d4}\u{1fc3a}\ub8d0\u5588\u{1fe84}', type: 'occlusion', count: 608});
let renderBundle57 = renderBundleEncoder22.finish({label: '\u08c7\u051b\u64c9\u{1f6c5}\u83dd\u{1fc93}\u0325\u0353\u071e\u{1fa9e}\u0e7a'});
try {
renderPassEncoder0.beginOcclusionQuery(1422);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42]);
} catch {}
try {
renderPassEncoder0.setStencilReference(4026);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(2, buffer4);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer10, 6_336);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture40,
  mipLevel: 2,
  origin: {x: 74, y: 21, z: 12},
  aspect: 'all',
},
{
  texture: texture40,
  mipLevel: 3,
  origin: {x: 6, y: 1, z: 0},
  aspect: 'all',
},
{width: 18, height: 73, depthOrArrayLayers: 44});
} catch {}
try {
commandEncoder58.clearBuffer(buffer10);
} catch {}
try {
device0.queue.writeBuffer(buffer6, 9220, new DataView(new ArrayBuffer(56521)), 21224, 8876);
} catch {}
let querySet38 = device1.createQuerySet({label: '\u{1fef3}\u{1fef8}\u6e28', type: 'occlusion', count: 2545});
let externalTexture39 = device1.importExternalTexture({
  label: '\u0cca\u0748\u03cd\ucc1d\u6365\u00b7\uc3b4\u3b29\u{1fa60}',
  source: video0,
  colorSpace: 'srgb',
});
try {
computePassEncoder37.setBindGroup(0, bindGroup26, new Uint32Array(5463), 434, 0);
} catch {}
try {
renderBundleEncoder32.setBindGroup(3, bindGroup26, new Uint32Array(2143), 161, 0);
} catch {}
try {
device1.queue.submit([commandBuffer17]);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 348, new Int16Array(22814), 4352, 560);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer2), /* required buffer size: 1_274 */
{offset: 350}, {width: 231, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline70 = device1.createRenderPipeline({
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'zero'},
  },
  writeMask: 0,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'never', failOp: 'invert', depthFailOp: 'replace', passOp: 'increment-clamp'},
    stencilBack: {failOp: 'increment-clamp', depthFailOp: 'invert', passOp: 'increment-clamp'},
    stencilWriteMask: 1547406663,
    depthBias: 1988261768,
    depthBiasSlopeScale: 265.05718228831347,
    depthBiasClamp: 910.7800869699099,
  },
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {arrayStride: 16, attributes: [{format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4}]},
      {arrayStride: 292, stepMode: 'instance', attributes: []},
      {
        arrayStride: 152,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 40, shaderLocation: 15},
          {format: 'float32', offset: 4, shaderLocation: 1},
          {format: 'sint16x2', offset: 40, shaderLocation: 3},
        ],
      },
      {arrayStride: 184, attributes: []},
      {arrayStride: 848, attributes: []},
      {arrayStride: 72, stepMode: 'instance', attributes: []},
      {
        arrayStride: 628,
        attributes: [
          {format: 'float32x3', offset: 88, shaderLocation: 11},
          {format: 'sint16x4', offset: 180, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 240,
        attributes: [
          {format: 'sint16x4', offset: 8, shaderLocation: 12},
          {format: 'float32x3', offset: 60, shaderLocation: 10},
          {format: 'uint16x4', offset: 36, shaderLocation: 8},
          {format: 'uint32', offset: 32, shaderLocation: 5},
          {format: 'float32x2', offset: 8, shaderLocation: 13},
          {format: 'sint32', offset: 48, shaderLocation: 2},
          {format: 'sint16x4', offset: 28, shaderLocation: 6},
          {format: 'uint8x4', offset: 64, shaderLocation: 14},
          {format: 'unorm8x4', offset: 8, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'ccw'},
});
let bindGroup28 = device1.createBindGroup({layout: bindGroupLayout16, entries: [{binding: 32, resource: externalTexture31}]});
let commandEncoder82 = device1.createCommandEncoder({label: '\u0819\u0022\u506f\u0c80\u6942\u3360\u0524\u974d\u0954\u02e6'});
let commandBuffer21 = commandEncoder82.finish({label: '\u0ec6\u26a0\u039c\udffa\u1456\ub153\u{1f92c}'});
let textureView94 = texture44.createView({label: '\u{1f7c7}\u7afd\u{1f8ec}\uacc9\u{1f829}\u041b'});
try {
renderBundleEncoder39.setVertexBuffer(3, buffer12, 0, 337);
} catch {}
try {
  await device1.popErrorScope();
} catch {}
let promise21 = device1.queue.onSubmittedWorkDone();
let commandEncoder83 = device0.createCommandEncoder({label: '\u4c51\u019e\uc7ca\u00f3'});
let textureView95 = texture45.createView({});
let renderBundleEncoder41 = device0.createRenderBundleEncoder({
  label: '\u29ea\u08ff\u88b9\u{1f66f}\ub426\u2bdc\u8ec1\uf4e4\u0c80\ud1e6\u0dd2',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder13.drawIndexedIndirect(buffer0, 4_200);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder25.insertDebugMarker('\u066d');
} catch {}
let pipeline71 = await device0.createRenderPipelineAsync({
  label: '\u0636\ub1b1\u0fb2\u{1f61b}',
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.GREEN}, {format: 'rg16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rgba16uint', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 168, attributes: []},
      {
        arrayStride: 320,
        attributes: [
          {format: 'uint32x3', offset: 12, shaderLocation: 12},
          {format: 'sint32x2', offset: 8, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 176,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x4', offset: 20, shaderLocation: 4},
          {format: 'sint32x3', offset: 8, shaderLocation: 6},
          {format: 'float16x4', offset: 20, shaderLocation: 0},
          {format: 'snorm16x2', offset: 52, shaderLocation: 9},
        ],
      },
      {arrayStride: 0, attributes: []},
      {arrayStride: 1212, attributes: [{format: 'unorm10-10-10-2', offset: 408, shaderLocation: 1}]},
      {
        arrayStride: 20,
        attributes: [
          {format: 'sint32x4', offset: 0, shaderLocation: 13},
          {format: 'unorm8x4', offset: 4, shaderLocation: 5},
          {format: 'float32x4', offset: 0, shaderLocation: 8},
          {format: 'sint16x4', offset: 0, shaderLocation: 14},
        ],
      },
      {arrayStride: 884, attributes: []},
      {
        arrayStride: 452,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 124, shaderLocation: 2},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'uint8x4', offset: 92, shaderLocation: 3},
          {format: 'sint16x4', offset: 16, shaderLocation: 7},
          {format: 'sint32', offset: 0, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'none'},
});
let shaderModule11 = device1.createShaderModule({
  label: '\u5dd9\u0c85\u0484\uf242\u0b18\uea99\u9e89\u2ca1\u{1f7f5}',
  code: `@group(3) @binding(959)
var<storage, read_write> global1: array<u32>;
@group(3) @binding(522)
var<storage, read_write> n3: array<u32>;

@compute @workgroup_size(3, 3, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(2) f0: vec4<f32>,
  @location(1) f1: vec4<i32>,
  @location(0) f2: vec4<i32>,
  @builtin(sample_mask) f3: u32
}

@fragment
fn fragment0(@location(3) a0: vec3<f16>, @location(8) a1: f32, @location(12) a2: vec4<f32>, @location(10) a3: i32, @location(15) a4: vec4<u32>, @location(11) a5: vec4<f32>, @location(13) a6: vec2<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S11 {
  @location(6) f0: vec3<u32>,
  @location(2) f1: vec2<f16>,
  @location(0) f2: vec3<f32>,
  @location(15) f3: vec3<u32>,
  @location(14) f4: vec2<f32>,
  @builtin(vertex_index) f5: u32
}
struct VertexOutput0 {
  @location(10) f89: i32,
  @location(13) f90: vec2<f32>,
  @location(5) f91: vec3<i32>,
  @location(8) f92: f32,
  @location(6) f93: i32,
  @builtin(position) f94: vec4<f32>,
  @location(11) f95: vec4<f32>,
  @location(3) f96: vec3<f16>,
  @location(15) f97: vec4<u32>,
  @location(12) f98: vec4<f32>
}

@vertex
fn vertex0(@location(9) a0: vec4<u32>, @location(10) a1: vec2<i32>, @location(11) a2: vec2<u32>, @location(13) a3: vec2<f16>, @location(1) a4: vec4<u32>, @location(4) a5: u32, @location(7) a6: vec4<u32>, @location(5) a7: vec4<f32>, a8: S11, @location(3) a9: f32, @location(12) a10: vec3<f16>, @location(8) a11: u32, @builtin(instance_index) a12: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let renderBundle58 = renderBundleEncoder37.finish();
try {
buffer13.unmap();
} catch {}
try {
device1.queue.writeBuffer(buffer13, 13000, new Float32Array(54821), 54435);
} catch {}
try {
  await adapter3.requestAdapterInfo();
} catch {}
let commandEncoder84 = device0.createCommandEncoder();
let renderBundle59 = renderBundleEncoder26.finish({});
try {
computePassEncoder25.setPipeline(pipeline21);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setViewport(119.5, 11.44, 27.76, 85.01, 0.08725, 0.8440);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer3, 'uint16', 126, 16_844);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(1, buffer4, 17_160);
} catch {}
let pipeline72 = await device0.createRenderPipelineAsync({
  label: '\ufb7a\u08d0\uf918\uc40e\u{1fad7}\u073b\u081d\u0e46\u{1ff1d}',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'constant'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'src'},
  },
  writeMask: 0,
}, undefined, {format: 'rg8unorm', writeMask: 0}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-constant', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE,
}, {format: 'rgba16uint'}],
},
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 512,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint32x2', offset: 120, shaderLocation: 14},
          {format: 'sint8x2', offset: 110, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 668,
        attributes: [
          {format: 'float32', offset: 228, shaderLocation: 1},
          {format: 'sint8x2', offset: 246, shaderLocation: 15},
          {format: 'snorm16x2', offset: 184, shaderLocation: 9},
        ],
      },
      {arrayStride: 200, stepMode: 'instance', attributes: []},
      {arrayStride: 112, attributes: [{format: 'sint8x2', offset: 16, shaderLocation: 7}]},
      {
        arrayStride: 936,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint32x2', offset: 16, shaderLocation: 11},
          {format: 'sint32x4', offset: 56, shaderLocation: 4},
          {format: 'uint32x3', offset: 140, shaderLocation: 3},
          {format: 'float16x4', offset: 208, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 520,
        stepMode: 'instance',
        attributes: [{format: 'uint16x2', offset: 16, shaderLocation: 12}],
      },
      {arrayStride: 88, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 160, shaderLocation: 10},
          {format: 'unorm16x2', offset: 664, shaderLocation: 5},
          {format: 'sint32x2', offset: 576, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 116, shaderLocation: 8},
          {format: 'sint32x2', offset: 296, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw'},
});
offscreenCanvas0.height = 827;
let canvas12 = document.createElement('canvas');
let textureView96 = texture38.createView({
  label: '\ud855\u{1f7da}\ue9b2\ue31d\u176c\u{1f9ca}\u04b9\u{1f654}\u{1fb39}\u0eed\u8f32',
  arrayLayerCount: 1,
});
let renderBundleEncoder42 = device1.createRenderBundleEncoder({
  label: '\u0548\u{1fc93}\ub7d9\ud5e3\u06e4\u0c70\u9437\u00c5\u72dc',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  depthReadOnly: true,
});
let renderBundle60 = renderBundleEncoder35.finish({});
try {
device1.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(821), /* required buffer size: 821 */
{offset: 821}, {width: 109, height: 0, depthOrArrayLayers: 1});
} catch {}
let textureView97 = texture23.createView({label: '\ud978\u07a6\ufbfe\u{1fd5d}\u0f16\u06dc\u4dbc\u0aa5\u07dd\ubc60\ucdbd', baseArrayLayer: 0});
let sampler43 = device0.createSampler({
  label: '\u0b51\uf0e5\u0907\u0a31\u4b8e\u9460\u{1fa57}\u48fe\u6736',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 77.65,
  lodMaxClamp: 95.71,
  compare: 'always',
  maxAnisotropy: 18,
});
try {
computePassEncoder24.dispatchWorkgroups(5, 5, 3);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -7.223, g: 727.8, b: -83.89, a: 847.5, });
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint32', 92_096, 26_983);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer4);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(4, buffer4, 0, 41_211);
} catch {}
try {
commandEncoder53.copyBufferToBuffer(buffer1, 181820, buffer6, 21432, 2172);
} catch {}
document.body.prepend(video14);
let commandEncoder85 = device0.createCommandEncoder({label: '\u5fcc\ue521\u{1f73b}\uab19\u0e50\u{1f90a}\u019a\u9656\u3554\ube2c'});
let renderBundleEncoder43 = device0.createRenderBundleEncoder({label: '\u0b13\u{1f9df}\u8a90', colorFormats: ['r32float']});
let sampler44 = device0.createSampler({
  label: '\u08d3\ud9d7\u9882\u027e\u667d\u691f\u82bb\u2d89',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 48.16,
  lodMaxClamp: 90.29,
});
let externalTexture40 = device0.importExternalTexture({label: '\ud80a\u965f\u0002\u8627', source: videoFrame2, colorSpace: 'srgb'});
try {
computePassEncoder45.setBindGroup(0, bindGroup7);
} catch {}
try {
computePassEncoder28.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder0.setBindGroup(1, bindGroup2, new Uint32Array(5629), 4796, 0);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(916);
} catch {}
try {
renderPassEncoder0.setViewport(67.31, 67.96, 16.31, 37.31, 0.6030, 0.6508);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder36.setBindGroup(3, bindGroup18);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline32);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(2, buffer7, 0);
} catch {}
try {
commandEncoder63.copyTextureToTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 70, y: 73, z: 2},
  aspect: 'all',
},
{
  texture: texture15,
  mipLevel: 1,
  origin: {x: 7, y: 1, z: 7},
  aspect: 'all',
},
{width: 52, height: 110, depthOrArrayLayers: 10});
} catch {}
try {
commandEncoder31.resolveQuerySet(querySet7, 241, 87, buffer1, 82176);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 1328, new Int16Array(29314), 11535, 6564);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 9,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, new Int32Array(arrayBuffer3), /* required buffer size: 1_604_590 */
{offset: 786, bytesPerRow: 165, rowsPerImage: 216}, {width: 2, height: 1, depthOrArrayLayers: 46});
} catch {}
let pipeline73 = device0.createRenderPipeline({
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment0',
  targets: [{format: 'r16float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {
  format: 'rgba8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint'}, {format: 'rg16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'less', failOp: 'zero', depthFailOp: 'decrement-clamp', passOp: 'zero'},
    stencilBack: {compare: 'less-equal', failOp: 'replace', depthFailOp: 'replace', passOp: 'decrement-wrap'},
    stencilReadMask: 1980500589,
    stencilWriteMask: 2275132599,
    depthBias: -1645466020,
    depthBiasSlopeScale: 118.36829827139391,
  },
  vertex: {
    module: shaderModule6,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 152, attributes: []},
      {
        arrayStride: 96,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x4', offset: 4, shaderLocation: 6}],
      },
      {
        arrayStride: 28,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 0, shaderLocation: 4},
          {format: 'unorm16x4', offset: 0, shaderLocation: 7},
          {format: 'float32x4', offset: 0, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 308,
        attributes: [
          {format: 'unorm8x2', offset: 26, shaderLocation: 15},
          {format: 'float32x4', offset: 24, shaderLocation: 1},
          {format: 'sint32x2', offset: 44, shaderLocation: 11},
          {format: 'float32', offset: 96, shaderLocation: 12},
          {format: 'sint32x4', offset: 0, shaderLocation: 2},
          {format: 'unorm16x2', offset: 100, shaderLocation: 8},
        ],
      },
      {arrayStride: 260, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'snorm16x4', offset: 816, shaderLocation: 14}],
      },
      {arrayStride: 1228, stepMode: 'instance', attributes: []},
      {
        arrayStride: 40,
        attributes: [
          {format: 'unorm8x2', offset: 8, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 5},
          {format: 'uint16x4', offset: 0, shaderLocation: 13},
          {format: 'uint16x2', offset: 4, shaderLocation: 10},
        ],
      },
    ],
  },
});
let commandEncoder86 = device1.createCommandEncoder({});
let textureView98 = texture44.createView({label: '\u1cdf\u025e', baseMipLevel: 2, arrayLayerCount: 1});
let sampler45 = device1.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 88.17,
  lodMaxClamp: 91.34,
  compare: 'less-equal',
});
let externalTexture41 = device1.importExternalTexture({source: video0, colorSpace: 'display-p3'});
try {
computePassEncoder38.setPipeline(pipeline59);
} catch {}
try {
renderBundleEncoder32.setVertexBuffer(4, buffer12, 0, 1_594);
} catch {}
try {
commandEncoder86.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1724 */
  offset: 1724,
  bytesPerRow: 256,
  rowsPerImage: 279,
  buffer: buffer12,
}, {width: 5, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder86.clearBuffer(buffer12, 2064, 4444);
} catch {}
let commandEncoder87 = device0.createCommandEncoder();
let textureView99 = texture21.createView({
  label: '\u{1fafe}\u72ec\u{1fbf5}\u3a98\u{1fc3d}\u700d',
  baseMipLevel: 5,
  mipLevelCount: 1,
  baseArrayLayer: 37,
  arrayLayerCount: 75,
});
let renderBundleEncoder44 = device0.createRenderBundleEncoder({
  label: '\u{1f9ba}\u0507\uc1bf\ucdb7',
  colorFormats: ['r32float'],
  sampleCount: 1,
  stencilReadOnly: true,
});
let renderBundle61 = renderBundleEncoder2.finish({label: '\u0b62\ub3da'});
try {
computePassEncoder25.end();
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup24, new Uint32Array(1348), 609, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer4);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup20, new Uint32Array(4776), 1782, 0);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(2, buffer9, 0, 81_603);
} catch {}
try {
commandEncoder78.insertDebugMarker('\u{1f749}');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Float64Array(arrayBuffer1), /* required buffer size: 43 */
{offset: 43}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline74 = device0.createComputePipeline({
  label: '\uf2f1\ue76c\ua9e6\ua666',
  layout: pipelineLayout4,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
let bindGroup29 = device0.createBindGroup({layout: bindGroupLayout3, entries: []});
let textureView100 = texture14.createView({label: '\u{1f775}\u043f\u1635', format: 'rgb10a2unorm', arrayLayerCount: 1});
let renderBundle62 = renderBundleEncoder2.finish();
let externalTexture42 = device0.importExternalTexture({label: '\u37e4\udb15\u0254\u01bb\ud521\ud524\u5125', source: videoFrame0, colorSpace: 'srgb'});
try {
computePassEncoder7.setBindGroup(1, bindGroup6);
} catch {}
try {
renderPassEncoder0.setScissorRect(117, 45, 36, 32);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 61916, new DataView(new ArrayBuffer(53164)));
} catch {}
let promise22 = device0.queue.onSubmittedWorkDone();
let promise23 = device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule9, entryPoint: 'compute0'}});
let canvas13 = document.createElement('canvas');
let commandEncoder88 = device1.createCommandEncoder({label: '\u6463\ueed6\u4393\u0183\u{1f907}\u0cb2'});
let textureView101 = texture44.createView({baseMipLevel: 1, mipLevelCount: 1});
try {
device1.queue.writeBuffer(buffer12, 952, new Float32Array(43964), 36808, 760);
} catch {}
let pipeline75 = device1.createComputePipeline({
  label: '\u5639\u11a4\uc2ea\u0f9c\ue31a\u006a\u6229\uab5e\u23e9\u0baf\u81d8',
  layout: pipelineLayout5,
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let querySet39 = device1.createQuerySet({
  label: '\u{1fd43}\u{1f7eb}\u0153\ue369\ua66e\u{1f826}\u04e1\ue893\ud368\u1e6d\u9c7b',
  type: 'occlusion',
  count: 1568,
});
let texture50 = device1.createTexture({
  label: '\u{1fb1f}\u0467\u7370',
  size: [137, 1, 1],
  mipLevelCount: 6,
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView102 = texture38.createView({label: '\u0495\u0e8e\u0570\u283f\ue285\uc6c4\u8c77\u094d\ude91\ua40d\ufe0e', mipLevelCount: 1});
let renderBundle63 = renderBundleEncoder32.finish({label: '\u825f\u0c88\u0dba\ufd3a\u2daa\ue1e8\u540a\u{1f8a6}\u63ce\u0f6b'});
try {
commandEncoder86.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5548 */
  offset: 5548,
  bytesPerRow: 512,
  rowsPerImage: 260,
  buffer: buffer12,
}, {width: 2, height: 2, depthOrArrayLayers: 0});
} catch {}
let pipeline76 = device1.createRenderPipeline({
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'r32sint', writeMask: GPUColorWrite.GREEN}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'one-minus-dst'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilFront: {compare: 'less', depthFailOp: 'zero'},
    stencilBack: {compare: 'greater-equal', failOp: 'replace', depthFailOp: 'increment-clamp', passOp: 'replace'},
    stencilWriteMask: 3411824466,
    depthBias: 524155922,
    depthBiasSlopeScale: 312.0987409393567,
  },
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 64,
        attributes: [
          {format: 'uint32x2', offset: 0, shaderLocation: 8},
          {format: 'sint8x4', offset: 32, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 144,
        stepMode: 'vertex',
        attributes: [{format: 'sint32x3', offset: 12, shaderLocation: 6}],
      },
      {arrayStride: 1096, attributes: []},
      {arrayStride: 36, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 296,
        attributes: [
          {format: 'float32', offset: 48, shaderLocation: 4},
          {format: 'uint32', offset: 72, shaderLocation: 5},
          {format: 'uint32x2', offset: 8, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 0, shaderLocation: 0},
          {format: 'float32', offset: 8, shaderLocation: 10},
          {format: 'float32x2', offset: 0, shaderLocation: 13},
          {format: 'snorm16x4', offset: 4, shaderLocation: 1},
        ],
      },
      {arrayStride: 560, stepMode: 'instance', attributes: []},
      {
        arrayStride: 140,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 18, shaderLocation: 11},
          {format: 'sint32x2', offset: 72, shaderLocation: 3},
          {format: 'sint32', offset: 8, shaderLocation: 12},
          {format: 'sint32x4', offset: 0, shaderLocation: 2},
          {format: 'unorm8x4', offset: 4, shaderLocation: 9},
        ],
      },
    ],
  },
});
let gpuCanvasContext8 = canvas12.getContext('webgpu');
let video15 = await videoWithData();
let buffer14 = device0.createBuffer({
  label: '\u4f92\u097b\u03e1\u001d',
  size: 35838,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
try {
renderPassEncoder0.executeBundles([renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42]);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: 263.5, g: -882.1, b: 664.7, a: 211.8, });
} catch {}
try {
renderBundleEncoder24.setPipeline(pipeline9);
} catch {}
try {
device0.queue.submit([commandBuffer16]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 4},
  aspect: 'all',
}, new Uint16Array(arrayBuffer3), /* required buffer size: 134_643 */
{offset: 468, bytesPerRow: 357, rowsPerImage: 133}, {width: 150, height: 110, depthOrArrayLayers: 3});
} catch {}
try {
  await promise22;
} catch {}
let bindGroupLayout21 = device0.createBindGroupLayout({entries: []});
let commandEncoder89 = device0.createCommandEncoder({label: '\u0bcb\uc87e\uaf88'});
let textureView103 = texture25.createView({
  label: '\u16e6\u07c0\u{1ff98}\ue6cf\uc3e4\u02a9\uf49a\u0e88\u{1f9df}\u0283\u0539',
  dimension: '2d',
  baseMipLevel: 0,
  mipLevelCount: 2,
  baseArrayLayer: 17,
});
let externalTexture43 = device0.importExternalTexture({label: '\u{1f9b6}\u0654\u{1ff5e}\u00ee\u0fb7\u05bf', source: video6, colorSpace: 'display-p3'});
try {
computePassEncoder46.setBindGroup(3, bindGroup1);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42]);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
commandEncoder87.copyBufferToBuffer(buffer3, 47644, buffer14, 688, 13088);
} catch {}
try {
commandEncoder53.copyTextureToBuffer({
  texture: texture32,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 28},
  aspect: 'all',
}, {
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 86552 */
  offset: 41490,
  bytesPerRow: 256,
  rowsPerImage: 176,
  buffer: buffer1,
}, {width: 3, height: 1, depthOrArrayLayers: 2});
} catch {}
try {
commandEncoder53.clearBuffer(buffer10);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(arrayBuffer1), /* required buffer size: 817 */
{offset: 817}, {width: 82, height: 1, depthOrArrayLayers: 0});
} catch {}
let shaderModule12 = device0.createShaderModule({
  label: '\u0462\ue177\u806f\ub2a1\u7831\uabcd\u0c54\ue635',
  code: `@group(3) @binding(954)
var<storage, read_write> parameter6: array<u32>;
@group(2) @binding(954)
var<storage, read_write> function4: array<u32>;
@group(1) @binding(954)
var<storage, read_write> n4: array<u32>;
@group(0) @binding(954)
var<storage, read_write> function5: array<u32>;

@compute @workgroup_size(5, 4, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<f32>,
  @location(4) f1: vec2<i32>,
  @location(1) f2: vec4<f32>
}

@fragment
fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(sample_index) a1: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S12 {
  @location(2) f0: vec4<u32>,
  @location(6) f1: vec2<f16>,
  @location(10) f2: vec3<f32>,
  @location(9) f3: vec4<f32>,
  @location(3) f4: vec4<f32>,
  @location(14) f5: i32
}

@vertex
fn vertex0(@location(5) a0: vec3<i32>, @location(11) a1: f32, @location(8) a2: vec2<u32>, @location(0) a3: vec2<f16>, a4: S12, @location(13) a5: vec2<u32>, @location(1) a6: vec3<i32>, @location(7) a7: vec3<f16>, @location(4) a8: vec3<u32>, @location(12) a9: vec4<f32>, @location(15) a10: vec2<u32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let texture51 = device0.createTexture({
  label: '\u{1fb7c}\u{1fc8c}\ue250\u3794\u{1fdce}\u06a0\u3d1e\u{1f8b8}',
  size: {width: 330},
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView104 = texture35.createView({label: '\u{1f92b}\u9436\u040a\u{1f92a}', baseArrayLayer: 74, arrayLayerCount: 31});
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setViewport(79.30, 110.7, 53.88, 3.101, 0.3089, 0.9287);
} catch {}
try {
renderBundleEncoder44.setVertexBuffer(0, buffer7, 584);
} catch {}
try {
commandEncoder81.copyBufferToBuffer(buffer8, 42044, buffer7, 63036, 4092);
} catch {}
try {
commandEncoder62.copyTextureToBuffer({
  texture: texture4,
  mipLevel: 4,
  origin: {x: 0, y: 1, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 8598 */
  offset: 8598,
  bytesPerRow: 0,
  rowsPerImage: 232,
  buffer: buffer3,
}, {width: 0, height: 1, depthOrArrayLayers: 73});
} catch {}
try {
device0.queue.writeBuffer(buffer14, 2152, new Float32Array(53527), 2479, 3516);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 2,
  origin: {x: 51, y: 8, z: 2},
  aspect: 'all',
}, new Int16Array(arrayBuffer0), /* required buffer size: 538_259 */
{offset: 547, bytesPerRow: 750, rowsPerImage: 166}, {width: 178, height: 53, depthOrArrayLayers: 5});
} catch {}
try {
  await promise21;
} catch {}
gc();
try {
computePassEncoder42.setPipeline(pipeline59);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(0, buffer13, 8_520);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture48,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer4), /* required buffer size: 393 */
{offset: 377}, {width: 8, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let promise24 = device1.createRenderPipelineAsync({
  layout: pipelineLayout5,
  multisample: {count: 4, mask: 0xf106dd46},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-src'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'zero', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  vertex: {
    module: shaderModule11,
    buffers: [
      {
        arrayStride: 112,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 8, shaderLocation: 3}],
      },
      {arrayStride: 976, stepMode: 'instance', attributes: []},
      {
        arrayStride: 44,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 12},
          {format: 'uint16x2', offset: 0, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 176,
        stepMode: 'vertex',
        attributes: [{format: 'uint16x2', offset: 8, shaderLocation: 15}],
      },
      {arrayStride: 0, attributes: []},
      {arrayStride: 188, stepMode: 'instance', attributes: []},
      {
        arrayStride: 152,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 32, shaderLocation: 1},
          {format: 'uint16x2', offset: 20, shaderLocation: 4},
          {format: 'float32x4', offset: 12, shaderLocation: 2},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'uint32x4', offset: 1328, shaderLocation: 6},
          {format: 'unorm8x4', offset: 540, shaderLocation: 13},
          {format: 'uint32x3', offset: 232, shaderLocation: 9},
          {format: 'uint32x4', offset: 712, shaderLocation: 8},
          {format: 'snorm8x4', offset: 648, shaderLocation: 14},
          {format: 'uint16x4', offset: 528, shaderLocation: 11},
          {format: 'snorm16x2', offset: 348, shaderLocation: 0},
          {format: 'snorm8x4', offset: 180, shaderLocation: 5},
          {format: 'sint32x3', offset: 232, shaderLocation: 10},
        ],
      },
    ],
  },
});
try {
gpuCanvasContext4.unconfigure();
} catch {}
let imageBitmap11 = await createImageBitmap(imageData12);
let bindGroup30 = device1.createBindGroup({label: '\ub5c9\u{1ff29}\u39be\u3a4b', layout: bindGroupLayout20, entries: []});
let texture52 = device1.createTexture({
  label: '\u{1fd53}\ua61d\u056d\u{1f7d4}\u{1fdec}\u05a3',
  size: {width: 550, height: 6, depthOrArrayLayers: 190},
  mipLevelCount: 10,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'],
});
let externalTexture44 = device1.importExternalTexture({label: '\uc7ff\ue107\u{1fc50}', source: video4, colorSpace: 'srgb'});
try {
computePassEncoder35.setBindGroup(3, bindGroup22, []);
} catch {}
try {
renderBundleEncoder34.setBindGroup(2, bindGroup28, new Uint32Array(8701), 7967, 0);
} catch {}
try {
renderBundleEncoder39.setVertexBuffer(3, buffer13, 6_024, 28_113);
} catch {}
try {
commandEncoder86.copyBufferToTexture({
  /* bytesInLastRow: 440 widthInBlocks: 110 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 196 */
  offset: 196,
  rowsPerImage: 46,
  buffer: buffer13,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 110, height: 1, depthOrArrayLayers: 0});
} catch {}
let videoFrame8 = new VideoFrame(videoFrame4, {timestamp: 0});
try {
canvas13.getContext('webgpu');
} catch {}
let computePassEncoder49 = commandEncoder85.beginComputePass({label: '\ub984\u{1f696}'});
try {
renderBundleEncoder27.setVertexBuffer(6, undefined);
} catch {}
try {
commandEncoder79.copyTextureToBuffer({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1308 widthInBlocks: 327 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 7964 */
  offset: 6656,
  buffer: buffer14,
}, {width: 327, height: 1, depthOrArrayLayers: 1});
} catch {}
let bindGroupLayout22 = device0.createBindGroupLayout({
  label: '\u169f\udc9c\u8f77\uea3c\u6777\u43a8\u479d\ube24',
  entries: [
    {
      binding: 781,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 655,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 976,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true },
    },
  ],
});
let querySet40 = device0.createQuerySet({label: '\u2e16\u6dbb\ua79e', type: 'occlusion', count: 2009});
let texture53 = device0.createTexture({
  label: '\u{1fca1}\u0ecc\u0c74\u{1fae7}\uaba0\u0a3e\u{1f816}\u{1f87d}\u9014\u460e',
  size: {width: 1320, height: 960, depthOrArrayLayers: 1143},
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['r32float', 'r32float'],
});
let textureView105 = texture23.createView({label: '\ude53\u7d42\u0669\u0f4d'});
try {
computePassEncoder3.setBindGroup(3, bindGroup7, new Uint32Array(463), 277, 0);
} catch {}
try {
renderPassEncoder0.setViewport(162.3, 75.68, 1.340, 4.782, 0.4749, 0.6584);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint32', 23_408, 150);
} catch {}
try {
  await device0.popErrorScope();
} catch {}
try {
commandEncoder40.copyBufferToTexture({
  /* bytesInLastRow: 164 widthInBlocks: 82 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7180 */
  offset: 7180,
  bytesPerRow: 256,
  buffer: buffer5,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 14},
  aspect: 'all',
}, {width: 82, height: 112, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder59.clearBuffer(buffer1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 164}
*/
{
  source: imageData2,
  origin: { x: 1, y: 3 },
  flipY: false,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 2, y: 8, z: 9},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 13, height: 1, depthOrArrayLayers: 0});
} catch {}
let computePassEncoder50 = commandEncoder86.beginComputePass({});
let renderBundleEncoder45 = device1.createRenderBundleEncoder({
  label: '\ub84c\ud873\u07b2\u41b8\u{1fade}\uef5b\uc7ee\u{1f8b2}\u417d\u00d0\u{1fed4}',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let sampler46 = device1.createSampler({
  label: '\u5d08\u0441\u2c73\ue479',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 69.73,
  lodMaxClamp: 93.70,
  compare: 'greater-equal',
});
try {
computePassEncoder38.end();
} catch {}
try {
renderBundleEncoder42.setIndexBuffer(buffer13, 'uint16', 27_600, 37_242);
} catch {}
try {
commandEncoder88.copyBufferToBuffer(buffer13, 130220, buffer12, 1468, 1480);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture48,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer2, /* required buffer size: 170 */
{offset: 166, rowsPerImage: 272}, {width: 2, height: 1, depthOrArrayLayers: 1});
} catch {}
let img8 = await imageWithData(231, 119, '#17aaf4ba', '#b8083817');
let bindGroup31 = device0.createBindGroup({label: '\u1ca4\u2701\u9884\u{1fad4}\u5082\u6fbe', layout: bindGroupLayout21, entries: []});
let commandEncoder90 = device0.createCommandEncoder({label: '\u0136\ub1d5\ucdf2\u{1f9d4}'});
let textureView106 = texture34.createView({
  label: '\u712a\u{1f6a6}\u0523\u{1f92b}\u{1f9f7}\u0d01\uade1\u{1fd40}',
  format: 'rgba8unorm',
  baseMipLevel: 2,
});
let renderPassEncoder1 = commandEncoder31.beginRenderPass({
  label: '\u3f8b\u0b27\u0270\u8f37\u{1f96c}\u020c',
  colorAttachments: [{view: textureView73, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet7,
  maxDrawCount: 339081585,
});
let renderBundleEncoder46 = device0.createRenderBundleEncoder({
  label: '\u{1f8ab}\u7775\ucd0a\ud137\u020e\u3e53\u03a8\ud4bd',
  colorFormats: ['r32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let externalTexture45 = device0.importExternalTexture({
  label: '\u{1f70e}\u9c5c\u6e42\u8f05\ue6df\u{1fb05}\u0eab\u0d10\u7ee3',
  source: videoFrame6,
  colorSpace: 'srgb',
});
try {
computePassEncoder24.setPipeline(pipeline35);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -139.6, g: -331.4, b: 107.8, a: 94.22, });
} catch {}
try {
renderPassEncoder1.setViewport(118.6, 51.00, 15.13, 36.43, 0.7202, 0.8248);
} catch {}
try {
renderPassEncoder1.setIndexBuffer(buffer6, 'uint16', 134, 3_092);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(5, buffer6, 18_560, 505);
} catch {}
try {
renderBundleEncoder44.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(6, buffer7, 9_640, 19_075);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder57.clearBuffer(buffer6, 20320, 3760);
} catch {}
try {
commandEncoder67.popDebugGroup();
} catch {}
try {
device0.queue.writeBuffer(buffer1, 29968, new Float32Array(45513));
} catch {}
let imageData13 = new ImageData(224, 56);
let commandEncoder91 = device1.createCommandEncoder({label: '\u0101\uced5\u0628\u9c49\u59d0\u9bc4\u0ab3'});
let textureView107 = texture47.createView({label: '\u0ef5\u0d43\u13bf', mipLevelCount: 1});
try {
computePassEncoder48.setPipeline(pipeline59);
} catch {}
try {
renderBundleEncoder39.setBindGroup(2, bindGroup28);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(1, buffer12, 1_400, 1_077);
} catch {}
try {
commandEncoder88.clearBuffer(buffer13);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) };
} catch {}
try {
adapter0.label = '\u60ab\u87ba\ueeb6\u{1fe3b}\u068a\u0331\u0af9\u073a\u8f06\u6892\uc59f';
} catch {}
let bindGroup32 = device1.createBindGroup({
  label: '\uc66a\u0ec3\u0352\u03ab\u186a\u00ba\u0aee',
  layout: bindGroupLayout16,
  entries: [{binding: 32, resource: externalTexture39}],
});
let textureView108 = texture46.createView({label: '\u0d1c\u03c9\u0b27', dimension: '2d', baseMipLevel: 3, baseArrayLayer: 38});
try {
computePassEncoder42.setBindGroup(3, bindGroup28, new Uint32Array(8218), 2448, 0);
} catch {}
try {
renderBundleEncoder45.setIndexBuffer(buffer13, 'uint16', 1_666, 38_461);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(4_294_967_295, undefined, 853_401_322);
} catch {}
try {
commandEncoder88.copyBufferToTexture({
  /* bytesInLastRow: 808 widthInBlocks: 202 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 39948 */
  offset: 39948,
  rowsPerImage: 202,
  buffer: buffer13,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 202, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer2), /* required buffer size: 1_807 */
{offset: 815}, {width: 248, height: 1, depthOrArrayLayers: 1});
} catch {}
gc();
let buffer15 = device1.createBuffer({
  label: '\u{1fdbd}\u5d0e\udb23\u{1f8f5}',
  size: 32783,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView109 = texture38.createView({label: '\u{1f7d6}\u04b6\ucf10\u0d1a\u{1fd70}\u4655\uf4fd', dimension: '2d-array'});
try {
device1.pushErrorScope('internal');
} catch {}
try {
commandEncoder66.copyBufferToBuffer(buffer13, 52088, buffer12, 2924, 224);
} catch {}
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 13900 */
  offset: 13900,
  rowsPerImage: 62,
  buffer: buffer13,
}, {width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder66.copyTextureToTexture({
  texture: texture48,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture48,
  mipLevel: 0,
  origin: {x: 44, y: 0, z: 1},
  aspect: 'all',
},
{width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas14 = document.createElement('canvas');
let buffer16 = device0.createBuffer({label: '\u{1fcbe}\u0295', size: 11957, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder92 = device0.createCommandEncoder({label: '\u0228\u3a6b\ud1e1\u816c\u9616'});
let querySet41 = device0.createQuerySet({label: '\u1850\ub7eb\ud174\u8e31\ubcf2\u0748', type: 'occlusion', count: 2441});
let textureView110 = texture34.createView({baseMipLevel: 1, baseArrayLayer: 0});
let renderBundleEncoder47 = device0.createRenderBundleEncoder({
  label: '\ue5cc\u0bca\u009c\u56e8\ue229\u6c99\u05aa\u4c2d\u2caa\u0e36',
  colorFormats: ['rg16float', 'rgba16float'],
  depthReadOnly: true,
});
let sampler47 = device0.createSampler({
  label: '\u31a2\u{1f719}\u9299\u73e0\u1bab\u2f49\u59c1\u4694\ua64d',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 17.99,
  lodMaxClamp: 41.28,
  compare: 'never',
  maxAnisotropy: 20,
});
try {
renderPassEncoder0.setStencilReference(1878);
} catch {}
try {
renderPassEncoder0.setViewport(72.50, 23.57, 58.59, 26.23, 0.6409, 0.7134);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7, buffer7, 2_592);
} catch {}
try {
commandEncoder20.copyTextureToTexture({
  texture: texture32,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 5});
} catch {}
let videoFrame9 = new VideoFrame(video7, {timestamp: 0});
let texture54 = device1.createTexture({
  label: '\u0df3\ue789\u61a8\u01dc\uc653\ua882\u7394',
  size: {width: 10, height: 10, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST,
});
let computePassEncoder51 = commandEncoder88.beginComputePass({});
let externalTexture46 = device1.importExternalTexture({
  label: '\uaae6\u80d1\u0c25\ue4bb\u602d\u{1fb3b}\u{1f930}\u{1f6b5}\u{1fe2e}',
  source: video0,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder34.setBindGroup(0, bindGroup25, new Uint32Array(2817), 1839, 0);
} catch {}
try {
commandEncoder91.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 3,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3036 */
  offset: 3036,
  buffer: buffer13,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder34.pushDebugGroup('\ue58b');
} catch {}
let imageData14 = new ImageData(112, 132);
let querySet42 = device0.createQuerySet({
  label: '\u1b25\u{1f91c}\u{1fd1f}\uc1c9\u{1fbd9}\u{1f69f}\ubb82\u24b8\u084f\uef07',
  type: 'occlusion',
  count: 3260,
});
let texture55 = device0.createTexture({
  label: '\uc0d1\u7090\u261a\u0a12\u4290\u7709\ud2ad\ub7c8',
  size: {width: 165, height: 120, depthOrArrayLayers: 124},
  mipLevelCount: 6,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder52 = commandEncoder47.beginComputePass({label: '\u0580\u3a00\ufb04\u8af5\u{1ff66}\u1a2a'});
let externalTexture47 = device0.importExternalTexture({source: videoFrame5});
try {
computePassEncoder11.setBindGroup(1, bindGroup29);
} catch {}
try {
renderPassEncoder1.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder1.end();
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle42, renderBundle42, renderBundle42]);
} catch {}
try {
buffer2.destroy();
} catch {}
let promise25 = device0.queue.onSubmittedWorkDone();
let bindGroup33 = device1.createBindGroup({layout: bindGroupLayout16, entries: [{binding: 32, resource: externalTexture44}]});
let commandEncoder93 = device1.createCommandEncoder({label: '\u4c6f\u{1fc82}\u0c2f\ubc26\u{1fe8b}\u2f90'});
let texture56 = device1.createTexture({
  label: '\u09d4\u007b\u7c8a\u0d24\uc1be\u433e',
  size: {width: 640, height: 1, depthOrArrayLayers: 126},
  mipLevelCount: 4,
  sampleCount: 1,
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgba32sint'],
});
let renderBundle64 = renderBundleEncoder30.finish({label: '\u{1f76c}\ue88a\u{1f6c8}\u188a'});
try {
renderBundleEncoder39.setVertexBuffer(3, buffer12);
} catch {}
try {
commandEncoder93.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7008 */
  offset: 7008,
  rowsPerImage: 74,
  buffer: buffer13,
}, {
  texture: texture54,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline77 = device1.createRenderPipeline({
  label: '\u00da\u{1facb}\u2de8\u0b70\u04fa\u4c87\u0247',
  layout: pipelineLayout5,
  multisample: {count: 4, mask: 0x5b52dc1c},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {
  format: 'r32sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rgb10a2unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'less', failOp: 'increment-clamp', depthFailOp: 'zero', passOp: 'increment-clamp'},
    stencilBack: {compare: 'not-equal', failOp: 'increment-wrap', depthFailOp: 'replace', passOp: 'decrement-clamp'},
    stencilReadMask: 2336553439,
    stencilWriteMask: 1745341281,
    depthBias: -2107009686,
    depthBiasSlopeScale: 0.0,
    depthBiasClamp: 167.48880091403254,
  },
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 120, attributes: [{format: 'sint32x3', offset: 32, shaderLocation: 10}]},
      {arrayStride: 264, stepMode: 'vertex', attributes: []},
      {arrayStride: 140, attributes: []},
      {
        arrayStride: 64,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 0, shaderLocation: 0}],
      },
      {
        arrayStride: 364,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x4', offset: 32, shaderLocation: 15},
          {format: 'uint32x3', offset: 36, shaderLocation: 9},
        ],
      },
      {arrayStride: 616, attributes: [{format: 'snorm16x2', offset: 8, shaderLocation: 5}]},
      {arrayStride: 556, stepMode: 'instance', attributes: []},
      {
        arrayStride: 28,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 0, shaderLocation: 7},
          {format: 'float32x3', offset: 4, shaderLocation: 12},
          {format: 'uint16x4', offset: 0, shaderLocation: 4},
          {format: 'uint16x4', offset: 0, shaderLocation: 1},
          {format: 'unorm16x2', offset: 4, shaderLocation: 13},
          {format: 'uint32x3', offset: 0, shaderLocation: 8},
          {format: 'float32', offset: 4, shaderLocation: 14},
          {format: 'float32x3', offset: 8, shaderLocation: 3},
          {format: 'uint16x4', offset: 8, shaderLocation: 6},
          {format: 'uint32x4', offset: 0, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'},
});
let bindGroup34 = device0.createBindGroup({label: '\u{1fdbd}\u6272\u{1ff9e}\u0f95', layout: bindGroupLayout5, entries: []});
let texture57 = device0.createTexture({
  label: '\u{1fb7e}\u5f75\ua416\u0d45\u{1fc75}',
  size: [1320],
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView111 = texture29.createView({mipLevelCount: 2});
let computePassEncoder53 = commandEncoder63.beginComputePass({label: '\u780d\u08c9\u{1fa3a}\ud6fa\u{1fe64}\u5488\ua6fb\u099f'});
try {
computePassEncoder36.setBindGroup(2, bindGroup9, new Uint32Array(538), 328, 0);
} catch {}
try {
renderBundleEncoder43.setIndexBuffer(buffer0, 'uint32', 7_972, 152_700);
} catch {}
try {
commandEncoder87.copyTextureToBuffer({
  texture: texture25,
  mipLevel: 0,
  origin: {x: 40, y: 19, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1580 widthInBlocks: 790 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5118 */
  offset: 5118,
  bytesPerRow: 1792,
  rowsPerImage: 143,
  buffer: buffer1,
}, {width: 790, height: 100, depthOrArrayLayers: 0});
} catch {}
let canvas15 = document.createElement('canvas');
let video16 = await videoWithData();
let textureView112 = texture11.createView({
  label: '\u577c\u8eff\u0994\uc614\ued2a\u9dc9\u9d7d\u0d02\u1ecb',
  format: 'bgra8unorm',
  baseMipLevel: 6,
});
let computePassEncoder54 = commandEncoder81.beginComputePass({});
try {
renderPassEncoder0.setBindGroup(0, bindGroup9, new Uint32Array(4492), 1452, 0);
} catch {}
try {
renderPassEncoder0.setViewport(55.35, 52.70, 77.50, 63.26, 0.1769, 0.8773);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
gc();
let shaderModule13 = device1.createShaderModule({
  label: '\uc8f2\u9f91\u14f9\u5386\uf49f',
  code: `@group(3) @binding(522)
var<storage, read_write> function6: array<u32>;
@group(3) @binding(959)
var<storage, read_write> n5: array<u32>;

@compute @workgroup_size(3, 2, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S14 {
  @location(9) f0: vec2<u32>,
  @location(7) f1: vec2<i32>
}
struct FragmentOutput0 {
  @location(0) f0: vec4<u32>,
  @location(1) f1: vec3<u32>,
  @location(2) f2: i32,
  @location(3) f3: vec3<i32>,
  @builtin(sample_mask) f4: u32
}

@fragment
fn fragment0(@location(8) a0: vec4<f32>, @location(6) a1: vec4<u32>, a2: S14, @location(13) a3: vec2<f32>, @location(15) a4: vec4<f32>, @location(14) a5: vec4<f16>, @location(5) a6: vec2<f32>, @location(3) a7: vec3<i32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S13 {
  @location(6) f0: f32,
  @location(4) f1: vec2<u32>,
  @location(13) f2: vec3<u32>,
  @location(7) f3: vec3<i32>,
  @builtin(instance_index) f4: u32
}
struct VertexOutput0 {
  @location(14) f99: vec4<f16>,
  @location(10) f100: vec4<f32>,
  @location(5) f101: vec2<f32>,
  @location(13) f102: vec2<f32>,
  @location(7) f103: vec2<i32>,
  @location(12) f104: vec2<i32>,
  @location(9) f105: vec2<u32>,
  @location(6) f106: vec4<u32>,
  @builtin(position) f107: vec4<f32>,
  @location(8) f108: vec4<f32>,
  @location(2) f109: vec2<u32>,
  @location(15) f110: vec4<f32>,
  @location(4) f111: f32,
  @location(3) f112: vec3<i32>,
  @location(1) f113: vec3<u32>
}

@vertex
fn vertex0(@location(3) a0: vec2<f32>, @location(15) a1: vec3<i32>, @location(0) a2: vec3<i32>, @location(2) a3: vec4<i32>, @location(11) a4: vec4<f16>, @location(8) a5: vec3<u32>, @location(5) a6: vec4<f32>, @builtin(vertex_index) a7: u32, @location(14) a8: vec2<f32>, a9: S13) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  hints: {},
});
let querySet43 = device1.createQuerySet({
  label: '\ue9dd\u{1fc53}\u2418\u2c4a\u{1fc64}\u{1fed1}\u0300\u77c7\u1297',
  type: 'occlusion',
  count: 4001,
});
let sampler48 = device1.createSampler({
  label: '\uf663\u0c01\udda6\u{1fae3}\u{1f62a}\u831c\uf6ee\udcb2',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 38.73,
  lodMaxClamp: 56.45,
  maxAnisotropy: 3,
});
let gpuCanvasContext9 = canvas14.getContext('webgpu');
let imageData15 = new ImageData(252, 136);
let videoFrame10 = new VideoFrame(offscreenCanvas2, {timestamp: 0});
try {
externalTexture11.label = '\uaf97\u7467\u{1fb81}';
} catch {}
let bindGroup35 = device0.createBindGroup({
  label: '\u7493\u31e6\ua931\u039c\ue5db\u1247\u0440',
  layout: bindGroupLayout15,
  entries: [{binding: 454, resource: externalTexture14}, {binding: 379, resource: sampler11}],
});
let querySet44 = device0.createQuerySet({label: '\u{1f7b1}\uefa2\u717b\udef7\u{1f947}', type: 'occlusion', count: 3754});
let textureView113 = texture4.createView({label: '\u50c6\u09c5', dimension: '2d', baseMipLevel: 5, baseArrayLayer: 29});
let renderPassEncoder2 = commandEncoder37.beginRenderPass({
  label: '\u{1feb6}\ufdf8\u0c36\ue2ef\u5f56\u28f4',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: 859.9, g: -219.8, b: -792.8, a: 543.1, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet6,
  maxDrawCount: 754655080,
});
try {
renderPassEncoder0.setBlendConstant({ r: 975.5, g: 220.5, b: 559.8, a: 21.14, });
} catch {}
try {
renderPassEncoder2.setIndexBuffer(buffer0, 'uint32', 35_580, 68_910);
} catch {}
try {
commandEncoder70.copyBufferToBuffer(buffer4, 25912, buffer14, 820, 21460);
} catch {}
try {
commandEncoder74.clearBuffer(buffer3, 4548, 36312);
} catch {}
try {
device0.queue.submit([commandBuffer20]);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 41088, new DataView(new ArrayBuffer(51113)), 45315, 980);
} catch {}
let pipeline78 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule5, entryPoint: 'compute0', constants: {}}});
let pipeline79 = device0.createRenderPipeline({
  label: '\u46a7\u0bee\u5ab8',
  layout: pipelineLayout3,
  multisample: {mask: 0xa8240b6b},
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rg16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'greater', failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'increment-clamp'},
    stencilBack: {compare: 'always', depthFailOp: 'invert', passOp: 'invert'},
    stencilWriteMask: 356601588,
    depthBias: -833975608,
  },
  vertex: {
    module: shaderModule5,
    buffers: [
      {arrayStride: 336, stepMode: 'instance', attributes: []},
      {arrayStride: 88, stepMode: 'instance', attributes: []},
      {arrayStride: 48, stepMode: 'instance', attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 360, attributes: [{format: 'sint16x4', offset: 56, shaderLocation: 13}]},
      {
        arrayStride: 0,
        attributes: [
          {format: 'uint16x4', offset: 76, shaderLocation: 9},
          {format: 'unorm16x4', offset: 888, shaderLocation: 8},
        ],
      },
      {arrayStride: 1268, attributes: []},
      {
        arrayStride: 448,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 44, shaderLocation: 4},
          {format: 'float16x4', offset: 8, shaderLocation: 1},
          {format: 'sint32x4', offset: 92, shaderLocation: 2},
          {format: 'snorm8x2', offset: 72, shaderLocation: 7},
        ],
      },
    ],
  },
});
try {
  await promise25;
} catch {}
let commandEncoder94 = device1.createCommandEncoder({label: '\u05bb\uceb2\u{1feb3}\ua0da\u5389\ucef4'});
let textureView114 = texture38.createView({label: '\u060d\u2f74\u70c3\u{1fcbc}\ub1b0\u{1ff7a}\ua284', dimension: '2d-array', arrayLayerCount: 1});
try {
commandEncoder91.clearBuffer(buffer13);
} catch {}
let commandEncoder95 = device0.createCommandEncoder({label: '\u046f\u281c\u63f9\u{1ffad}\u{1f978}\u4415\u0ce0\ua85f\ub09b\uccaf\ue2f3'});
let texture58 = device0.createTexture({
  size: [165, 120, 1192],
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg8unorm', 'rg8unorm'],
});
let externalTexture48 = device0.importExternalTexture({label: '\u2616\u0b3f\u0469\u0ef0\u0599\u{1fd1f}', source: video8});
try {
computePassEncoder7.dispatchWorkgroups(5, 5);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle42]);
} catch {}
try {
renderPassEncoder2.setViewport(98.68, 29.47, 60.54, 72.98, 0.2900, 0.4946);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer3, 'uint32', 1_604, 8_598);
} catch {}
let promise26 = device0.queue.onSubmittedWorkDone();
let querySet45 = device1.createQuerySet({
  label: '\u7cc9\u{1fddd}\uf879\u360f\u2094\u9f77\u{1fe3c}\u0954\u8a84\uaa5d\ue9da',
  type: 'occlusion',
  count: 2204,
});
try {
computePassEncoder34.setBindGroup(0, bindGroup26);
} catch {}
try {
renderBundleEncoder42.setBindGroup(2, bindGroup30);
} catch {}
try {
commandEncoder93.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 8518 */
  offset: 7744,
  bytesPerRow: 256,
  buffer: buffer13,
}, {
  texture: texture54,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 4, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 138, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 92 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 33800 */
  offset: 33708,
  buffer: buffer13,
}, {width: 23, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder94.copyTextureToTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 145, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture47,
  mipLevel: 0,
  origin: {x: 34, y: 0, z: 0},
  aspect: 'all',
},
{width: 6, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder93.resolveQuerySet(querySet38, 25, 70, buffer15, 14848);
} catch {}
try {
renderBundleEncoder39.insertDebugMarker('\ud5fa');
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
let bindGroupLayout23 = device1.createBindGroupLayout({
  label: '\u09dd\u{1fc50}\u0cc1\ua290\u25cc\u{1f77c}\ue45b',
  entries: [
    {binding: 693, visibility: 0, sampler: { type: 'filtering' }},
    {
      binding: 160,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'depth', multisampled: false },
    },
  ],
});
let sampler49 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 67.63,
  lodMaxClamp: 72.72,
  compare: 'less',
});
try {
computePassEncoder42.setBindGroup(1, bindGroup30);
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
let texture59 = device0.createTexture({
  label: '\u363a\u{1fcab}\u9540\u04b1\u95aa\ub754\u6b37',
  size: {width: 165, height: 120, depthOrArrayLayers: 131},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32float', 'r32float', 'r32float'],
});
let renderBundle65 = renderBundleEncoder7.finish();
try {
computePassEncoder7.setBindGroup(1, bindGroup17, new Uint32Array(8780), 8163, 0);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: 586.9, g: 213.7, b: -208.9, a: 536.7, });
} catch {}
try {
renderPassEncoder0.setStencilReference(1061);
} catch {}
try {
renderBundleEncoder36.setBindGroup(1, bindGroup1, new Uint32Array(3662), 2116, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer3, 'uint32', 30_416, 10_624);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let canvas16 = document.createElement('canvas');
let pipelineLayout6 = device0.createPipelineLayout({label: '\ud947\u8c8e\ud0a6', bindGroupLayouts: [bindGroupLayout1, bindGroupLayout17]});
let commandEncoder96 = device0.createCommandEncoder();
let textureView115 = texture18.createView({label: '\ucc39\u073c\ud97a', dimension: '2d', baseMipLevel: 2, baseArrayLayer: 32});
let renderBundle66 = renderBundleEncoder22.finish({label: '\u096e\uaaa7'});
try {
computePassEncoder30.setBindGroup(3, bindGroup27);
} catch {}
try {
computePassEncoder7.dispatchWorkgroups(1, 4, 5);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42]);
} catch {}
try {
renderPassEncoder0.setScissorRect(61, 88, 96, 10);
} catch {}
try {
renderPassEncoder0.setStencilReference(2165);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint16', 35_448, 28_766);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(1, buffer9);
} catch {}
try {
commandEncoder79.insertDebugMarker('\u{1faa1}');
} catch {}
gc();
let bindGroupLayout24 = device1.createBindGroupLayout({
  label: '\u{1f997}\ue723\u{1fea6}\u003f\u{1fc52}',
  entries: [{binding: 966, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }}],
});
let buffer17 = device1.createBuffer({
  label: '\u0cca\uf5c3\u458e\uc08a\u08f0\u1cef\u0980\ue9d3\u{1faff}\u6cf7',
  size: 21389,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandBuffer22 = commandEncoder93.finish({label: '\u0de4\ua950\u0a24\u0638\u{1fd44}\u{1fb0e}\u0483\u0af6\u{1f72b}\u{1ffa7}\u626f'});
let renderBundleEncoder48 = device1.createRenderBundleEncoder({
  label: '\u0c51\uae9a\u6128\u9323\u554e\ud0e9',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  stencilReadOnly: true,
});
let externalTexture49 = device1.importExternalTexture({
  label: '\u2722\u{1f944}\u07e5\u0a50\u024a\ufb9f\u0484\u{1f828}',
  source: video5,
  colorSpace: 'display-p3',
});
try {
commandEncoder91.resolveQuerySet(querySet43, 384, 1688, buffer15, 0);
} catch {}
let video17 = await videoWithData();
let shaderModule14 = device1.createShaderModule({
  label: '\u0bc6\u06f0',
  code: `@group(3) @binding(959)
var<storage, read_write> type2: array<u32>;
@group(3) @binding(522)
var<storage, read_write> parameter7: array<u32>;

@compute @workgroup_size(4, 1, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S16 {
  @location(11) f0: vec2<f16>,
  @location(15) f1: vec2<f32>
}
struct FragmentOutput0 {
  @location(0) f0: vec4<u32>,
  @location(1) f1: vec4<u32>,
  @location(3) f2: vec4<i32>
}

@fragment
fn fragment0(a0: S16, @builtin(sample_mask) a1: u32, @builtin(sample_index) a2: u32, @builtin(position) a3: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S15 {
  @location(4) f0: vec3<f16>,
  @location(9) f1: vec3<f32>,
  @location(0) f2: u32,
  @builtin(instance_index) f3: u32,
  @location(1) f4: vec3<f16>,
  @location(2) f5: vec4<i32>,
  @location(3) f6: f16,
  @location(15) f7: u32,
  @location(5) f8: vec4<f32>,
  @location(10) f9: vec3<f16>,
  @location(13) f10: i32,
  @location(8) f11: vec2<f32>,
  @location(14) f12: vec2<f16>,
  @location(12) f13: u32
}
struct VertexOutput0 {
  @builtin(position) f114: vec4<f32>,
  @location(11) f115: vec2<f16>,
  @location(15) f116: vec2<f32>
}

@vertex
fn vertex0(@builtin(vertex_index) a0: u32, @location(11) a1: vec2<u32>, @location(6) a2: i32, a3: S15, @location(7) a4: vec3<f16>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
try {
computePassEncoder31.setPipeline(pipeline63);
} catch {}
try {
commandEncoder91.copyBufferToBuffer(buffer13, 91828, buffer12, 3184, 140);
} catch {}
try {
commandEncoder91.copyTextureToTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 141, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture50,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 34, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder91.clearBuffer(buffer12, 92, 2976);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm'],
  alphaMode: 'premultiplied',
});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture54,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(16), /* required buffer size: 1_716 */
{offset: 816, bytesPerRow: 300}, {width: 0, height: 4, depthOrArrayLayers: 1});
} catch {}
let pipeline80 = device1.createRenderPipeline({
  label: '\u7324\u365d\uc980',
  layout: 'auto',
  fragment: {
  module: shaderModule13,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA}, {format: 'r8uint', writeMask: GPUColorWrite.ALL}, {format: 'r16sint', writeMask: 0}, {format: 'rg32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule13,
    buffers: [
      {
        arrayStride: 200,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 12, shaderLocation: 14},
          {format: 'unorm16x2', offset: 0, shaderLocation: 6},
          {format: 'uint16x4', offset: 44, shaderLocation: 4},
        ],
      },
      {arrayStride: 20, attributes: [{format: 'sint16x4', offset: 4, shaderLocation: 0}]},
      {arrayStride: 704, stepMode: 'instance', attributes: []},
      {
        arrayStride: 88,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x2', offset: 52, shaderLocation: 15},
          {format: 'sint16x2', offset: 0, shaderLocation: 2},
          {format: 'snorm16x4', offset: 0, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 188,
        attributes: [
          {format: 'float32', offset: 20, shaderLocation: 11},
          {format: 'uint32x2', offset: 4, shaderLocation: 13},
        ],
      },
      {arrayStride: 644, stepMode: 'instance', attributes: []},
      {arrayStride: 360, stepMode: 'instance', attributes: []},
      {
        arrayStride: 388,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 88, shaderLocation: 8},
          {format: 'sint8x4', offset: 32, shaderLocation: 7},
          {format: 'float32x3', offset: 12, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16'},
});
let gpuCanvasContext10 = canvas16.getContext('webgpu');
let renderBundle67 = renderBundleEncoder37.finish();
try {
commandEncoder94.resolveQuerySet(querySet29, 262, 24, buffer15, 1024);
} catch {}
let pipeline81 = await device1.createComputePipelineAsync({
  label: '\uce06\u0852\u9411\u0c51\u3214',
  layout: pipelineLayout5,
  compute: {module: shaderModule11, entryPoint: 'compute0', constants: {}},
});
try {
  await adapter1.requestAdapterInfo();
} catch {}
let querySet46 = device0.createQuerySet({
  label: '\u7035\uf99e\u0e44\u1300\u0e5c\ufc0b\u5b96\u0aca\u7bf6\u0abd\u{1fd85}',
  type: 'occlusion',
  count: 3260,
});
let texture60 = device0.createTexture({
  label: '\u0620\u{1faf4}\u0047\u{1f74e}\u17a5\u3666\uddb7\u3ec9\u{1ff8b}\u1a05\u{1f93f}',
  size: {width: 330},
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgb10a2unorm', 'rgb10a2unorm', 'rgb10a2unorm'],
});
let renderBundleEncoder49 = device0.createRenderBundleEncoder({
  label: '\u6a8e\u7cbb\ubedf\u0b67\u90b6\u{1ffb1}\u76a7\u0cf9\u{1ff84}',
  colorFormats: ['rg16float', 'rgba16float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle68 = renderBundleEncoder24.finish({label: '\u0774\uba1d\u{1ffb5}\u{1f901}\u{1fbf9}\u{1fd94}\u{1f9ff}\u2383\u02d5\u0534\u533e'});
try {
renderPassEncoder0.beginOcclusionQuery(1458);
} catch {}
try {
renderPassEncoder0.setScissorRect(102, 115, 3, 5);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(0, buffer7, 10_124, 633);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(6, buffer4, 31_676);
} catch {}
try {
commandEncoder83.copyTextureToTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture29,
  mipLevel: 2,
  origin: {x: 5, y: 51, z: 2},
  aspect: 'all',
},
{width: 149, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder36.clearBuffer(buffer10, 39832);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer1, /* required buffer size: 294 */
{offset: 294}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
let promise27 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext11 = canvas15.getContext('webgpu');
let bindGroup36 = device1.createBindGroup({label: '\u{1fb4c}\uad58', layout: bindGroupLayout13, entries: []});
let querySet47 = device1.createQuerySet({
  label: '\u015d\uddaa\u3e25\uaf71\udcb6\u4b7f\u{1fc26}\u{1f652}\u{1fdd5}\uaaa4',
  type: 'occlusion',
  count: 3797,
});
let texture61 = device1.createTexture({
  label: '\u{1fdf5}\u0e36\u06fa',
  size: [302, 96, 1],
  mipLevelCount: 2,
  format: 'depth32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
computePassEncoder34.end();
} catch {}
try {
computePassEncoder47.setPipeline(pipeline81);
} catch {}
try {
renderBundleEncoder34.setIndexBuffer(buffer15, 'uint32', 2_364, 16_611);
} catch {}
try {
commandEncoder94.copyBufferToBuffer(buffer17, 1316, buffer12, 3512, 1700);
} catch {}
try {
commandEncoder94.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 832 widthInBlocks: 208 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2136 */
  offset: 1304,
  buffer: buffer13,
}, {width: 208, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline82 = await device1.createComputePipelineAsync({
  label: '\u0cb8\u97bd\u07b3\u0799\u0061\u{1f86c}\u0951\ude65\u428a\u{1fba0}\u0247',
  layout: 'auto',
  compute: {module: shaderModule10, entryPoint: 'compute0'},
});
let imageData16 = new ImageData(212, 200);
let querySet48 = device0.createQuerySet({label: '\ub8a9\u08ed\u9ded\u10f3', type: 'occlusion', count: 4047});
try {
computePassEncoder27.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder2.end();
} catch {}
try {
renderBundleEncoder29.setPipeline(pipeline22);
} catch {}
try {
commandEncoder95.copyTextureToBuffer({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 41, y: 38, z: 179},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4264 widthInBlocks: 1066 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 20792 */
  offset: 20792,
  bytesPerRow: 4352,
  buffer: buffer6,
}, {width: 1066, height: 34, depthOrArrayLayers: 0});
} catch {}
let promise28 = device0.createRenderPipelineAsync({
  label: '\ud385\ue0e9\u77da\u4084',
  layout: pipelineLayout6,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32float', writeMask: GPUColorWrite.ALL}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {failOp: 'zero', depthFailOp: 'decrement-clamp', passOp: 'increment-wrap'},
    stencilBack: {compare: 'always', failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'increment-wrap'},
    stencilWriteMask: 33483871,
    depthBias: -1403271946,
    depthBiasSlopeScale: 924.8192509819678,
    depthBiasClamp: 980.383004255578,
  },
  vertex: {
    module: shaderModule9,
    buffers: [
      {
        arrayStride: 408,
        attributes: [
          {format: 'float32', offset: 0, shaderLocation: 2},
          {format: 'uint32x4', offset: 92, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 408,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint8x4', offset: 124, shaderLocation: 14},
          {format: 'uint32x3', offset: 140, shaderLocation: 6},
          {format: 'float32x4', offset: 360, shaderLocation: 15},
          {format: 'unorm16x2', offset: 48, shaderLocation: 7},
          {format: 'snorm16x4', offset: 76, shaderLocation: 8},
          {format: 'sint8x2', offset: 200, shaderLocation: 1},
          {format: 'snorm8x4', offset: 88, shaderLocation: 5},
        ],
      },
      {arrayStride: 44, attributes: []},
      {
        arrayStride: 292,
        stepMode: 'instance',
        attributes: [{format: 'sint32x3', offset: 76, shaderLocation: 11}],
      },
      {
        arrayStride: 600,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x4', offset: 444, shaderLocation: 9}],
      },
      {arrayStride: 184, stepMode: 'instance', attributes: []},
      {arrayStride: 272, attributes: []},
      {
        arrayStride: 280,
        attributes: [
          {format: 'uint32x4', offset: 56, shaderLocation: 0},
          {format: 'snorm8x4', offset: 0, shaderLocation: 3},
          {format: 'uint8x4', offset: 28, shaderLocation: 4},
          {format: 'float32x3', offset: 148, shaderLocation: 12},
          {format: 'sint16x2', offset: 24, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
canvas6.width = 26;
let commandEncoder97 = device1.createCommandEncoder();
let querySet49 = device1.createQuerySet({type: 'occlusion', count: 2331});
try {
renderBundleEncoder45.setBindGroup(2, bindGroup30);
} catch {}
try {
commandEncoder94.copyBufferToBuffer(buffer17, 1004, buffer13, 172924, 13496);
} catch {}
try {
commandEncoder66.clearBuffer(buffer13);
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet47, 623, 438, buffer15, 1536);
} catch {}
let pipeline83 = device1.createRenderPipeline({
  label: '\ud370\ua6ac\u0096',
  layout: pipelineLayout5,
  multisample: {mask: 0xd7f12ad8},
  fragment: {
  module: shaderModule13,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: 0}, {format: 'r8uint'}, {format: 'r16sint', writeMask: 0}, {format: 'rg32sint', writeMask: GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'always',
    stencilFront: {compare: 'not-equal', failOp: 'replace', depthFailOp: 'replace'},
    stencilBack: {compare: 'equal', failOp: 'invert', depthFailOp: 'invert', passOp: 'increment-clamp'},
    stencilReadMask: 1808638145,
    depthBiasSlopeScale: 763.4555242459884,
  },
  vertex: {
    module: shaderModule13,
    buffers: [
      {arrayStride: 168, stepMode: 'instance', attributes: []},
      {arrayStride: 132, stepMode: 'instance', attributes: []},
      {arrayStride: 104, attributes: []},
      {arrayStride: 180, stepMode: 'instance', attributes: []},
      {
        arrayStride: 240,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 4, shaderLocation: 2},
          {format: 'sint32x4', offset: 172, shaderLocation: 7},
        ],
      },
      {arrayStride: 460, attributes: [{format: 'float32x3', offset: 104, shaderLocation: 5}]},
      {arrayStride: 484, attributes: []},
      {
        arrayStride: 732,
        attributes: [
          {format: 'uint16x4', offset: 108, shaderLocation: 4},
          {format: 'uint32x2', offset: 204, shaderLocation: 8},
          {format: 'float32', offset: 108, shaderLocation: 6},
          {format: 'float16x2', offset: 100, shaderLocation: 11},
          {format: 'uint8x2', offset: 14, shaderLocation: 13},
          {format: 'sint32x4', offset: 128, shaderLocation: 0},
          {format: 'unorm8x4', offset: 16, shaderLocation: 3},
          {format: 'sint8x2', offset: 282, shaderLocation: 15},
          {format: 'unorm8x2', offset: 272, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'},
});
let offscreenCanvas6 = new OffscreenCanvas(974, 952);
let commandEncoder98 = device1.createCommandEncoder({label: '\u3a87\u037d\u9a1f\uab1f\u02cc'});
let externalTexture50 = device1.importExternalTexture({label: '\ubfbe\u13b1\u{1fcba}\u0274\u0779', source: video16, colorSpace: 'srgb'});
try {
renderBundleEncoder45.setVertexBuffer(3, buffer13);
} catch {}
try {
commandEncoder98.copyBufferToTexture({
  /* bytesInLastRow: 380 widthInBlocks: 95 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 15104 */
  offset: 15104,
  buffer: buffer13,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
}, {width: 95, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder91.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 49112 */
  offset: 49112,
  buffer: buffer13,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder97.clearBuffer(buffer12, 3564, 2720);
} catch {}
let pipeline84 = device1.createRenderPipeline({
  layout: pipelineLayout5,
  vertex: {
    module: shaderModule11,
    buffers: [
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 668,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 14, shaderLocation: 7},
          {format: 'unorm8x4', offset: 80, shaderLocation: 0},
        ],
      },
      {arrayStride: 492, stepMode: 'instance', attributes: []},
      {arrayStride: 152, stepMode: 'instance', attributes: []},
      {arrayStride: 260, stepMode: 'instance', attributes: []},
      {
        arrayStride: 116,
        attributes: [
          {format: 'uint32x4', offset: 40, shaderLocation: 4},
          {format: 'uint16x2', offset: 4, shaderLocation: 1},
          {format: 'float16x2', offset: 36, shaderLocation: 5},
          {format: 'snorm16x4', offset: 12, shaderLocation: 3},
        ],
      },
      {
        arrayStride: 320,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 16, shaderLocation: 14},
          {format: 'sint32x2', offset: 16, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 140,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 4, shaderLocation: 6},
          {format: 'float32x2', offset: 16, shaderLocation: 13},
          {format: 'snorm8x4', offset: 24, shaderLocation: 2},
          {format: 'uint8x4', offset: 20, shaderLocation: 8},
          {format: 'float16x4', offset: 24, shaderLocation: 12},
          {format: 'uint8x2', offset: 4, shaderLocation: 9},
          {format: 'uint32x4', offset: 8, shaderLocation: 11},
          {format: 'uint32x3', offset: 0, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'back'},
});
let shaderModule15 = device1.createShaderModule({
  label: '\u0676\uce05\u5bf4\u77f4\u07e3\ua964\u{1f8b4}\u729e\u2247\uc037\uf64e',
  code: `@group(3) @binding(522)
var<storage, read_write> global2: array<u32>;

@compute @workgroup_size(2, 2, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec3<u32>,
  @location(3) f1: vec2<i32>,
  @location(1) f2: vec4<u32>,
  @location(2) f3: vec3<i32>
}

@fragment
fn fragment0(@location(8) a0: i32, @location(2) a1: u32, @location(7) a2: vec3<u32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S17 {
  @location(9) f0: vec3<f32>,
  @location(15) f1: vec2<u32>,
  @builtin(vertex_index) f2: u32,
  @location(5) f3: vec3<f32>,
  @location(4) f4: vec3<f32>,
  @location(6) f5: vec2<i32>,
  @location(14) f6: vec3<u32>,
  @location(11) f7: vec2<f16>,
  @location(3) f8: vec4<f32>,
  @location(12) f9: vec4<f32>
}
struct VertexOutput0 {
  @location(3) f117: vec4<i32>,
  @location(15) f118: vec3<f16>,
  @location(0) f119: i32,
  @location(1) f120: f16,
  @location(10) f121: vec4<u32>,
  @location(11) f122: vec3<f32>,
  @location(12) f123: u32,
  @location(4) f124: vec4<u32>,
  @location(5) f125: vec2<f32>,
  @builtin(position) f126: vec4<f32>,
  @location(14) f127: vec2<f32>,
  @location(8) f128: i32,
  @location(9) f129: vec2<u32>,
  @location(6) f130: vec2<u32>,
  @location(2) f131: u32,
  @location(7) f132: vec3<u32>,
  @location(13) f133: vec2<f16>
}

@vertex
fn vertex0(@location(0) a0: vec3<i32>, @location(1) a1: vec4<f32>, @builtin(instance_index) a2: u32, @location(7) a3: vec4<f32>, @location(13) a4: f16, @location(2) a5: vec3<f32>, @location(8) a6: vec3<f32>, a7: S17, @location(10) a8: i32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  hints: {},
});
let commandEncoder99 = device1.createCommandEncoder({label: '\u{1fc10}\u{1f65a}\uf423\u087c\u1daf\u00c9\u04eb'});
let querySet50 = device1.createQuerySet({type: 'occlusion', count: 3975});
let sampler50 = device1.createSampler({
  label: '\u{1feb1}\u{1facc}\u0d9a\u0742\u110b\u9d73\u81bd\uc3e9',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 47.22,
  lodMaxClamp: 75.19,
  compare: 'greater-equal',
});
let externalTexture51 = device1.importExternalTexture({label: '\u9fde\u06d7\u956d\u021d\ua74b', source: videoFrame6});
try {
renderBundleEncoder42.setBindGroup(2, bindGroup28);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder48.setVertexBuffer(2, buffer12, 284);
} catch {}
try {
commandEncoder66.copyBufferToBuffer(buffer15, 18736, buffer13, 43584, 10148);
} catch {}
let shaderModule16 = device0.createShaderModule({
  label: '\u{1fc29}\u97eb\u3a5b\u0667\u0767\u{1f90c}\u0ecf\u1ae7',
  code: `@group(1) @binding(954)
var<storage, read_write> global3: array<u32>;

@compute @workgroup_size(7, 2, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(3) f0: vec4<u32>,
  @location(0) f1: vec4<f32>,
  @location(1) f2: vec4<i32>,
  @location(2) f3: vec4<f32>,
  @location(5) f4: vec4<f32>,
  @location(4) f5: vec4<u32>
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32, @builtin(front_facing) a1: bool, @builtin(sample_mask) a2: u32, @builtin(position) a3: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@builtin(instance_index) a0: u32, @location(9) a1: i32, @location(7) a2: vec4<f16>, @location(8) a3: vec4<i32>, @location(14) a4: vec4<f16>, @location(11) a5: vec3<f16>, @builtin(vertex_index) a6: u32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
});
let querySet51 = device0.createQuerySet({label: '\u{1fbd8}\u02a2\u9142', type: 'occlusion', count: 351});
let textureView116 = texture15.createView({label: '\u0a35\u3045\u073a', mipLevelCount: 1});
let renderPassEncoder3 = commandEncoder56.beginRenderPass({
  label: '\u{1f87a}\ue4e9',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: -934.4, g: -562.3, b: 276.6, a: -60.25, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet20,
  maxDrawCount: 319024708,
});
try {
renderPassEncoder0.setScissorRect(37, 98, 86, 3);
} catch {}
try {
renderPassEncoder0.setStencilReference(1306);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(3, buffer5);
} catch {}
try {
renderBundleEncoder36.setBindGroup(3, bindGroup12, new Uint32Array(249), 184, 0);
} catch {}
try {
commandEncoder36.copyBufferToBuffer(buffer3, 71544, buffer9, 103404, 17224);
} catch {}
try {
commandEncoder52.clearBuffer(buffer2, 72740, 22204);
} catch {}
try {
commandEncoder44.resolveQuerySet(querySet7, 33, 22, buffer16, 4608);
} catch {}
let gpuCanvasContext12 = offscreenCanvas6.getContext('webgpu');
let shaderModule17 = device1.createShaderModule({
  label: '\uacfd\u{1fd49}\ue70b\u32aa\u5f56\u5a0e\u0038\u7e14\u7123\uef8c\u{1f6bc}',
  code: `@group(3) @binding(959)
var<storage, read_write> local5: array<u32>;

@compute @workgroup_size(7, 2, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<i32>,
  @builtin(sample_mask) f1: u32,
  @location(2) f2: vec4<f32>,
  @location(1) f3: vec2<i32>
}

@fragment
fn fragment0(@location(4) a0: f32, @location(10) a1: vec3<i32>, @location(6) a2: vec3<f32>, @location(9) a3: vec3<f16>, @location(0) a4: f32, @location(12) a5: vec3<u32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S18 {
  @location(0) f0: vec3<f32>,
  @location(13) f1: vec2<f16>,
  @location(9) f2: vec4<f16>,
  @location(7) f3: vec3<f32>,
  @location(4) f4: vec2<f32>,
  @location(10) f5: u32,
  @location(12) f6: vec4<f32>,
  @location(8) f7: vec2<u32>,
  @builtin(vertex_index) f8: u32,
  @location(6) f9: vec3<f16>,
  @location(5) f10: vec3<f16>
}
struct VertexOutput0 {
  @location(2) f134: vec4<f16>,
  @location(4) f135: f32,
  @location(3) f136: vec3<f32>,
  @location(15) f137: u32,
  @location(6) f138: vec3<f32>,
  @location(5) f139: vec3<u32>,
  @builtin(position) f140: vec4<f32>,
  @location(1) f141: vec2<f16>,
  @location(13) f142: vec2<f32>,
  @location(10) f143: vec3<i32>,
  @location(9) f144: vec3<f16>,
  @location(0) f145: f32,
  @location(12) f146: vec3<u32>,
  @location(7) f147: f32
}

@vertex
fn vertex0(@location(3) a0: vec3<f32>, @location(2) a1: vec3<i32>, @location(14) a2: vec4<u32>, @location(1) a3: vec3<i32>, @location(11) a4: vec2<u32>, a5: S18) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let buffer18 = device1.createBuffer({
  label: '\u8982\uf0b1\ub234\u{1f777}\u0a6e\u03a8\u9600\u79c3\ub4cb\u06e6\u09ef',
  size: 309029,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let computePassEncoder55 = commandEncoder91.beginComputePass({});
let sampler51 = device1.createSampler({
  label: '\ue72f\u0df9\u0cc0\u5df1\u44a8\u071a',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 56.53,
  compare: 'greater-equal',
});
let externalTexture52 = device1.importExternalTexture({label: '\u0d4e\u91a3\u0d1c\u{1fd87}\u83b2', source: video17, colorSpace: 'srgb'});
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 908 widthInBlocks: 227 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1016 */
  offset: 1016,
  buffer: buffer18,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, {width: 227, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder66.copyTextureToBuffer({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 328 widthInBlocks: 82 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 7576 */
  offset: 7248,
  buffer: buffer13,
}, {width: 82, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder64.clearBuffer(buffer13);
} catch {}
let video18 = await videoWithData();
let commandEncoder100 = device0.createCommandEncoder({label: '\u3da8\uc53c\u0c0a\u0125\u{1f91c}\u0c43\uad98'});
let texture62 = device0.createTexture({
  size: [660, 480, 124],
  mipLevelCount: 8,
  dimension: '2d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgb10a2unorm'],
});
let textureView117 = texture3.createView({label: '\u0594\u0d9e\u9d9d\ufaa2\u8344\u0d1f\u{1f88f}\u{1fcb8}\u5adc\u5f5a\u0142', baseArrayLayer: 0});
try {
renderPassEncoder3.beginOcclusionQuery(702);
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: 464.1, g: -697.6, b: -439.7, a: 370.7, });
} catch {}
try {
renderPassEncoder0.setVertexBuffer(0, buffer4, 0, 13_065);
} catch {}
try {
renderBundleEncoder41.setBindGroup(2, bindGroup18);
} catch {}
try {
commandEncoder90.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2662 */
  offset: 2652,
  bytesPerRow: 256,
  buffer: buffer5,
}, {
  texture: texture2,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder59.copyTextureToTexture({
  texture: texture17,
  mipLevel: 2,
  origin: {x: 0, y: 7, z: 7},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 0,
  origin: {x: 79, y: 1, z: 0},
  aspect: 'all',
},
{width: 325, height: 66, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder79.clearBuffer(buffer7, 1876);
} catch {}
try {
device0.queue.writeBuffer(buffer10, 9424, new Int16Array(7794));
} catch {}
let commandEncoder101 = device1.createCommandEncoder();
let querySet52 = device1.createQuerySet({label: '\u{1fbb3}\u4f56\ucad3', type: 'occlusion', count: 3958});
let texture63 = device1.createTexture({
  label: '\ud936\u0e1f\uf8d6\u0643\u{1f86d}\u4d62\u{1fc10}',
  size: {width: 640, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'depth32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['depth32float', 'depth32float'],
});
let textureView118 = texture48.createView({label: '\ude5c\uc02b\u{1fa15}\ub4c1\ubf9c', mipLevelCount: 5, arrayLayerCount: 1});
let externalTexture53 = device1.importExternalTexture({label: '\uc88c\ub2bb\u9971\u05e8\u{1f9eb}\u33c8\ufa60', source: video16});
try {
commandEncoder101.copyBufferToBuffer(buffer13, 83356, buffer12, 2072, 4244);
} catch {}
try {
commandEncoder97.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 11062 */
  offset: 11056,
  buffer: buffer17,
}, {
  texture: texture48,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 1, depthOrArrayLayers: 1});
} catch {}
let querySet53 = device0.createQuerySet({label: '\udd0f\u2495\u{1fc63}\uc4cd', type: 'occlusion', count: 475});
let computePassEncoder56 = commandEncoder79.beginComputePass({label: '\ufa8b\u0eca\ub83f\ucf5b\ud3cb\u517d\ue5f7\ub625'});
let renderBundleEncoder50 = device0.createRenderBundleEncoder({label: '\u{1f71c}\u0183\ub028\u459c\u077e\u{1fed4}', colorFormats: ['r32float']});
let externalTexture54 = device0.importExternalTexture({label: '\u04c6\u5ce5', source: video18, colorSpace: 'display-p3'});
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: 514.5, g: -919.6, b: -290.4, a: -355.9, });
} catch {}
try {
renderPassEncoder0.setViewport(78.61, 31.70, 9.445, 32.22, 0.03596, 0.08644);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer7, 'uint16', 2_784, 25_105);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(7, buffer9, 59_820, 25_277);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(7, buffer4, 30_652);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2956 */
  offset: 2956,
  buffer: buffer5,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder100.resolveQuerySet(querySet0, 223, 116, buffer1, 8960);
} catch {}
let pipeline85 = device0.createRenderPipeline({
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: 0}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-src'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule5,
    buffers: [
      {arrayStride: 232, stepMode: 'instance', attributes: []},
      {
        arrayStride: 612,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 416, shaderLocation: 8},
          {format: 'sint8x2', offset: 320, shaderLocation: 13},
        ],
      },
      {arrayStride: 392, stepMode: 'instance', attributes: []},
      {
        arrayStride: 244,
        stepMode: 'instance',
        attributes: [{format: 'snorm16x2', offset: 32, shaderLocation: 7}],
      },
      {
        arrayStride: 344,
        stepMode: 'instance',
        attributes: [{format: 'float32x2', offset: 20, shaderLocation: 1}],
      },
      {arrayStride: 148, attributes: []},
      {arrayStride: 336, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 28,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x3', offset: 4, shaderLocation: 4},
          {format: 'sint32x2', offset: 0, shaderLocation: 2},
          {format: 'uint32', offset: 12, shaderLocation: 9},
        ],
      },
    ],
  },
});
let buffer19 = device1.createBuffer({
  label: '\u764c\u{1f61b}\u10de\u02e9\u67d8\u2eda',
  size: 12431,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let querySet54 = device1.createQuerySet({label: '\u{1fbf3}\u089e\u0224\u049d\u{1f618}\u{1fc53}\u6b93', type: 'occlusion', count: 899});
let commandBuffer23 = commandEncoder101.finish();
let texture64 = device1.createTexture({
  label: '\ued89\u022d\u26c0\udca0\uce7f\u{1f98e}',
  size: [1100, 12, 48],
  mipLevelCount: 3,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rg32sint', 'rg32sint', 'rg32sint'],
});
let sampler52 = device1.createSampler({
  label: '\u00cd\u0b52\u0216\u0fe6',
  addressModeU: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 78.25,
  compare: 'greater',
});
let externalTexture55 = device1.importExternalTexture({label: '\u8206\u9bfd\u6a2c', source: videoFrame7, colorSpace: 'display-p3'});
try {
renderBundleEncoder34.setIndexBuffer(buffer13, 'uint16', 27_546, 42_070);
} catch {}
try {
renderBundleEncoder39.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder39.setVertexBuffer(7, buffer12);
} catch {}
try {
commandEncoder94.copyBufferToBuffer(buffer15, 30064, buffer12, 5612, 644);
} catch {}
try {
commandEncoder66.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 31456 */
  offset: 31456,
  bytesPerRow: 512,
  rowsPerImage: 45,
  buffer: buffer13,
}, {
  texture: texture54,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder99.resolveQuerySet(querySet36, 113, 52, buffer18, 25600);
} catch {}
let imageData17 = new ImageData(196, 164);
try {
window.someLabel = externalTexture46.label;
} catch {}
let textureView119 = texture61.createView({aspect: 'depth-only'});
let computePassEncoder57 = commandEncoder64.beginComputePass({label: '\u2b2a\u9c80\u6af3\ubfa4\u9ef9\u0e57\u00aa\u0f56'});
let renderBundleEncoder51 = device1.createRenderBundleEncoder({
  label: '\u35c1\u08cc\u525f\u35b0\u2b1e\u{1f8f0}',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  sampleCount: 1,
});
try {
renderBundleEncoder42.setBindGroup(0, bindGroup32, new Uint32Array(5421), 1513, 0);
} catch {}
try {
renderBundleEncoder34.popDebugGroup();
} catch {}
let canvas17 = document.createElement('canvas');
let bindGroupLayout25 = device0.createBindGroupLayout({
  label: '\u4d6f\u124a\u875e\u{1f672}\u5cc7\u833b\u66ee\uc2c6\u99b6\u{1f7fb}\u2281',
  entries: [
    {binding: 211, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 917,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
  ],
});
let texture65 = gpuCanvasContext1.getCurrentTexture();
let textureView120 = texture60.createView({label: '\uc3e6\u0296\u02c8\u9a95\u{1ff38}\u0653'});
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder27.setBindGroup(3, bindGroup29);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer10, 7_948);
} catch {}
let arrayBuffer5 = buffer9.getMappedRange(0, 81228);
try {
commandEncoder25.copyBufferToTexture({
  /* bytesInLastRow: 984 widthInBlocks: 246 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 25356 */
  offset: 24372,
  buffer: buffer10,
}, {
  texture: texture60,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {width: 246, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder67.resolveQuerySet(querySet44, 56, 433, buffer11, 62208);
} catch {}
let pipeline86 = device0.createComputePipeline({
  label: '\u01d6\u2e23\u{1fa88}\u22f3\u2133\ufd4f\u096f\u1ac5\u{1fba1}\u09b6',
  layout: pipelineLayout3,
  compute: {module: shaderModule8, entryPoint: 'compute0', constants: {}},
});
let pipeline87 = await promise28;
let commandEncoder102 = device0.createCommandEncoder({label: '\u4adc\u8769\u{1fa63}\u7066\u008b\uf73e\ua801\ub971'});
let computePassEncoder58 = commandEncoder51.beginComputePass({label: '\ueefa\u72bd\u{1fbaf}'});
try {
computePassEncoder10.setPipeline(pipeline41);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer3, 'uint32', 22_068, 5_204);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder41.setBindGroup(1, bindGroup21);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer0, 62_068);
} catch {}
try {
renderBundleEncoder44.setIndexBuffer(buffer0, 'uint32', 37_664, 38_885);
} catch {}
try {
commandEncoder62.copyTextureToBuffer({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 7, y: 51, z: 130},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4416 widthInBlocks: 1104 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 15032 */
  offset: 15032,
  bytesPerRow: 4608,
  rowsPerImage: 175,
  buffer: buffer14,
}, {width: 1104, height: 68, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder20.copyTextureToTexture({
  texture: texture5,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 27},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 3,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder92.resolveQuerySet(querySet15, 477, 43, buffer1, 32000);
} catch {}
let commandEncoder103 = device0.createCommandEncoder({label: '\u24a9\u056f\ub646\u7f58\u0f28\u18c9\ubd80'});
try {
computePassEncoder53.setBindGroup(3, bindGroup17, new Uint32Array(6441), 1191, 0);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(1870);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setScissorRect(64, 119, 74, 1);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer5, 3_992);
} catch {}
try {
renderBundleEncoder38.setPipeline(pipeline85);
} catch {}
try {
commandEncoder45.clearBuffer(buffer6, 25832, 1272);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let commandEncoder104 = device0.createCommandEncoder();
let texture66 = device0.createTexture({
  label: '\u5936\u{1fabf}\u{1f8ac}\ua51b\u0d66\u9b69\u{1f6cc}\u{1ffc8}\uf0da\u0497\u0f32',
  size: [330],
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let textureView121 = texture25.createView({label: '\u241a\ub54d\u7f9b\u48e8\u03ac', baseMipLevel: 2, baseArrayLayer: 60, arrayLayerCount: 12});
let renderBundle69 = renderBundleEncoder43.finish({label: '\u1d1e\u9020\u681c\udd6c\u{1fbf2}\u667a\ue670\u0052'});
try {
renderPassEncoder0.setBindGroup(1, bindGroup10);
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup29, new Uint32Array(470), 332, 0);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(184);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setScissorRect(108, 60, 40, 45);
} catch {}
try {
renderBundleEncoder29.draw(83, 167, 140, 1_899_064_274);
} catch {}
try {
commandEncoder95.copyBufferToBuffer(buffer1, 124628, buffer10, 18084, 15328);
} catch {}
let promise29 = device0.createRenderPipelineAsync({
  label: '\uf872\u4eac\u098a\u{1fc83}\u7b80\udca9',
  layout: pipelineLayout0,
  multisample: {count: 4, mask: 0xb9d96617},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one-minus-src-alpha', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'src-alpha'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'rg16uint'}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.ALL}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilFront: {compare: 'greater-equal', failOp: 'increment-wrap', depthFailOp: 'replace', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'less', failOp: 'replace', depthFailOp: 'decrement-clamp', passOp: 'decrement-clamp'},
    stencilReadMask: 2116151438,
    stencilWriteMask: 3972586871,
    depthBias: 367666473,
    depthBiasClamp: 819.1484309941713,
  },
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 216, attributes: []},
      {arrayStride: 240, stepMode: 'instance', attributes: []},
      {arrayStride: 84, attributes: []},
      {arrayStride: 116, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 700, stepMode: 'vertex', attributes: []},
      {arrayStride: 100, stepMode: 'instance', attributes: []},
      {
        arrayStride: 252,
        attributes: [
          {format: 'uint32x4', offset: 4, shaderLocation: 13},
          {format: 'sint16x2', offset: 116, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let bindGroupLayout26 = device0.createBindGroupLayout({label: '\u68b6\u010b\uc09f\u1723\u{1f750}\u3dc2\u35e9\u02c3\u225d\ufdb4', entries: []});
let textureView122 = texture11.createView({aspect: 'all', mipLevelCount: 1});
let renderPassEncoder4 = commandEncoder78.beginRenderPass({
  label: '\u0907\u2fa6\u9866\uad17\u{1f945}\u96fe\u073a',
  colorAttachments: [{view: textureView73, loadOp: 'load', storeOp: 'store'}],
  maxDrawCount: 794364435,
});
try {
computePassEncoder7.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder4.setBlendConstant({ r: -494.5, g: -27.88, b: 542.5, a: -700.2, });
} catch {}
try {
renderBundleEncoder40.setBindGroup(2, bindGroup15, new Uint32Array(4811), 4226, 0);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 47_328);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer6, 'uint16', 8_976, 4_311);
} catch {}
try {
renderBundleEncoder46.setVertexBuffer(0, buffer5, 230_472, 980);
} catch {}
try {
commandEncoder67.copyTextureToTexture({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'display-p3',
});
} catch {}
try {
canvas17.getContext('webgpu');
} catch {}
let shaderModule18 = device0.createShaderModule({
  label: '\u57f0\uab0b\u820f\u1dae\u088e\u998d\u3c3f\u{1ff06}',
  code: `@group(0) @binding(954)
var<storage, read_write> function7: array<u32>;
@group(1) @binding(416)
var<storage, read_write> n6: array<u32>;
@group(1) @binding(803)
var<storage, read_write> n7: array<u32>;

@compute @workgroup_size(6, 2, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S20 {
  @builtin(position) f0: vec4<f32>,
  @builtin(sample_mask) f1: u32
}
struct FragmentOutput0 {
  @location(0) f0: vec3<f32>,
  @location(1) f1: vec4<f32>,
  @location(7) f2: vec3<i32>
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32, a1: S20, @builtin(front_facing) a2: bool) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S19 {
  @location(4) f0: vec3<i32>,
  @builtin(vertex_index) f1: u32,
  @location(8) f2: vec3<f16>
}
struct VertexOutput0 {
  @builtin(position) f148: vec4<f32>
}

@vertex
fn vertex0(@location(1) a0: vec3<f16>, @location(7) a1: vec4<f16>, @location(3) a2: vec4<f32>, a3: S19, @location(2) a4: i32, @location(5) a5: vec3<u32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
});
let textureView123 = texture16.createView({label: '\u1c1d\ub7cb\u0bfd\u0780\u0dea', baseArrayLayer: 0});
let renderBundle70 = renderBundleEncoder47.finish({label: '\u028e\u03b4\u{1fb02}\u{1ffb0}\u657b\uc101\u0f27\u086c'});
try {
computePassEncoder7.dispatchWorkgroups(2, 1);
} catch {}
try {
renderPassEncoder3.setStencilReference(1488);
} catch {}
try {
renderPassEncoder0.setViewport(159.4, 63.77, 5.238, 27.50, 0.3549, 0.7259);
} catch {}
try {
renderBundleEncoder29.setBindGroup(3, bindGroup24);
} catch {}
try {
renderBundleEncoder29.draw(36, 182, 222, 505_770_078);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer10, 72);
} catch {}
try {
renderBundleEncoder41.setIndexBuffer(buffer0, 'uint16', 2_148, 60_777);
} catch {}
try {
renderBundleEncoder46.setPipeline(pipeline67);
} catch {}
try {
  await buffer14.mapAsync(GPUMapMode.READ, 32840, 2120);
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture4,
  mipLevel: 0,
  origin: {x: 6, y: 7, z: 0},
  aspect: 'all',
},
{
  texture: texture27,
  mipLevel: 1,
  origin: {x: 3, y: 2, z: 12},
  aspect: 'all',
},
{width: 9, height: 3, depthOrArrayLayers: 120});
} catch {}
try {
commandEncoder32.insertDebugMarker('\u0abd');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture40,
  mipLevel: 3,
  origin: {x: 1, y: 12, z: 10},
  aspect: 'all',
}, new Float64Array(new ArrayBuffer(56)), /* required buffer size: 394_439 */
{offset: 476, bytesPerRow: 1139, rowsPerImage: 54}, {width: 126, height: 22, depthOrArrayLayers: 7});
} catch {}
let bindGroupLayout27 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 354,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 406, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {
      binding: 180,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let pipelineLayout7 = device1.createPipelineLayout({
  label: '\ua43f\u43d7\ueb55\ufd28\u9bfe\u0717',
  bindGroupLayouts: [bindGroupLayout27, bindGroupLayout14],
});
let textureView124 = texture52.createView({
  label: '\ubb4c\u8fef\uc412',
  format: 'rg8uint',
  mipLevelCount: 2,
  baseArrayLayer: 135,
  arrayLayerCount: 8,
});
let externalTexture56 = device1.importExternalTexture({label: '\u774b\u0c1d\u30f0\u0381\u0d65\u7d08', source: videoFrame7, colorSpace: 'display-p3'});
try {
renderBundleEncoder34.setBindGroup(1, bindGroup30);
} catch {}
try {
renderBundleEncoder51.setVertexBuffer(2, buffer12, 0, 272);
} catch {}
try {
commandEncoder99.resolveQuerySet(querySet39, 350, 195, buffer15, 1280);
} catch {}
canvas13.height = 2257;
let bindGroup37 = device0.createBindGroup({
  label: '\uf611\ub4af\u8c38',
  layout: bindGroupLayout15,
  entries: [{binding: 454, resource: externalTexture5}, {binding: 379, resource: sampler5}],
});
let querySet55 = device0.createQuerySet({label: '\ua108\u0241\ue7fe\u{1fab3}', type: 'occlusion', count: 1477});
let texture67 = gpuCanvasContext0.getCurrentTexture();
let textureView125 = texture19.createView({
  label: '\u0fba\ud2e6\u{1fc9e}\u0ea6\u0397\u{1fccc}\ufeee\u9ba5\uf130\u0cd4',
  dimension: '2d',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 21,
});
try {
renderPassEncoder3.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder4.end();
} catch {}
try {
renderPassEncoder0.setScissorRect(5, 84, 24, 32);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer0, 49_400);
} catch {}
try {
renderBundleEncoder13.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(3, buffer9, 0, 34_703);
} catch {}
try {
commandEncoder60.resolveQuerySet(querySet46, 396, 1223, buffer16, 256);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 9},
  aspect: 'all',
}, new Int16Array(arrayBuffer5), /* required buffer size: 866_975 */
{offset: 368, bytesPerRow: 737, rowsPerImage: 355}, {width: 158, height: 111, depthOrArrayLayers: 4});
} catch {}
try {
externalTexture36.label = '\u04f6\u0d7e\u{1fbc9}\u03cf\u{1f610}\u{1f77e}\u6467\u{1f6a2}';
} catch {}
let bindGroupLayout28 = device0.createBindGroupLayout({
  label: '\u0d9d\u03cb\ub963\u9e08\u00ff\u7b62\u9ec4',
  entries: [
    {
      binding: 96,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
  ],
});
let bindGroup38 = device0.createBindGroup({
  label: '\u{1f79d}\u3d20\udbbb\uf4ab\u749c\u7c48\ua2d4\u06bc',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer3, offset: 33024, size: 14012}}],
});
let commandBuffer24 = commandEncoder104.finish();
let textureView126 = texture29.createView({
  label: '\udb6a\u0e33\u{1fde9}\u03ed\u{1fd60}\u0169\uc8e4\u0a7e\u3af2\u09df',
  aspect: 'all',
  mipLevelCount: 1,
});
try {
computePassEncoder18.setBindGroup(1, bindGroup27, new Uint32Array(3590), 557, 0);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle69, renderBundle42, renderBundle42, renderBundle69, renderBundle42]);
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: -993.2, g: 129.8, b: 665.4, a: 463.4, });
} catch {}
try {
renderBundleEncoder29.draw(183, 132, 55, 170_738_726);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer0, 104_228);
} catch {}
let pipeline88 = await promise29;
let computePassEncoder59 = commandEncoder66.beginComputePass({label: '\u{1f8cc}\ub309\u9814\ucfa1'});
let renderBundle71 = renderBundleEncoder42.finish({label: '\u{1fc90}\uc5ea\u{1f88f}\ue039\u9fce\u38c5\u0395\u{1f600}\u85f7\u0c0b\u2ed5'});
try {
commandEncoder94.copyBufferToBuffer(buffer17, 1084, buffer13, 14460, 4144);
} catch {}
try {
commandEncoder98.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 188 widthInBlocks: 47 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2392 */
  offset: 2204,
  buffer: buffer13,
}, {width: 47, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
computePassEncoder7.setBindGroup(2, bindGroup20, new Uint32Array(7194), 6026, 0);
} catch {}
try {
computePassEncoder7.dispatchWorkgroupsIndirect(buffer11, 388068);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer10, 29_116);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer0, 15_636);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 20, height: 15, depthOrArrayLayers: 20}
*/
{
  source: imageData3,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture8,
  mipLevel: 3,
  origin: {x: 1, y: 1, z: 2},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline89 = device0.createComputePipeline({
  label: '\u32a0\u{1fbad}\u8e27\u97c3',
  layout: pipelineLayout4,
  compute: {module: shaderModule12, entryPoint: 'compute0', constants: {}},
});
let promise30 = navigator.gpu.requestAdapter({});
let img9 = await imageWithData(96, 249, '#0d33c377', '#603675e2');
try {
renderPassEncoder0.setScissorRect(56, 23, 87, 65);
} catch {}
try {
renderBundleEncoder40.setBindGroup(1, bindGroup27, []);
} catch {}
try {
renderBundleEncoder20.setBindGroup(3, bindGroup27, new Uint32Array(2494), 86, 0);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 5,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(8_279_649), /* required buffer size: 8_279_649 */
{offset: 917, bytesPerRow: 299, rowsPerImage: 245}, {width: 5, height: 4, depthOrArrayLayers: 114});
} catch {}
video16.height = 49;
let bindGroupLayout29 = device0.createBindGroupLayout({
  label: '\u{1fc48}\u1c6a\u0fb6',
  entries: [
    {
      binding: 706,
      visibility: 0,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 167,
      visibility: 0,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 683,
      visibility: 0,
      buffer: { type: 'uniform', minBindingSize: 105770031, hasDynamicOffset: false },
    },
  ],
});
let textureView127 = texture7.createView({label: '\u{1fd72}\u00cd\u0a1c\u0cc6', dimension: '2d-array', baseMipLevel: 0, baseArrayLayer: 0});
let renderPassEncoder5 = commandEncoder58.beginRenderPass({
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: -735.6, g: -262.1, b: -588.1, a: 33.85, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet42,
  maxDrawCount: 228957739,
});
try {
renderPassEncoder5.end();
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: -40.64, g: 268.8, b: -372.2, a: -259.1, });
} catch {}
try {
renderPassEncoder3.setViewport(118.0, 59.34, 27.41, 24.52, 0.2857, 0.3601);
} catch {}
try {
renderBundleEncoder20.setIndexBuffer(buffer3, 'uint16', 7_852, 8_070);
} catch {}
try {
commandEncoder20.copyBufferToBuffer(buffer4, 8332, buffer10, 4888, 29592);
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule19 = device0.createShaderModule({
  code: `@group(1) @binding(91)
var<storage, read_write> type3: array<u32>;

@compute @workgroup_size(6, 2, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(5) f0: u32,
  @location(0) f1: vec3<f32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@builtin(vertex_index) a0: u32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let buffer20 = device0.createBuffer({size: 104305, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false});
let commandEncoder105 = device0.createCommandEncoder({label: '\u24f8\u{1f81d}\u0216\u5be7\u2d44'});
let querySet56 = device0.createQuerySet({type: 'occlusion', count: 1580});
let externalTexture57 = device0.importExternalTexture({
  label: '\u{1fb33}\u0e74\u8c03\u222e\u4938\u{1ff15}\u0e24',
  source: videoFrame0,
  colorSpace: 'display-p3',
});
try {
computePassEncoder24.setBindGroup(0, bindGroup20);
} catch {}
try {
renderPassEncoder0.setScissorRect(130, 114, 19, 6);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer3, 'uint32', 27_244, 9_750);
} catch {}
try {
renderBundleEncoder44.setBindGroup(1, bindGroup37, []);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 239_416);
} catch {}
try {
commandEncoder57.clearBuffer(buffer6, 13840, 2248);
} catch {}
let promise31 = device0.createRenderPipelineAsync({
  label: '\u65f1\u{1f975}\u2c93\u0f2d\u2368\u049a\u5fe9\u0928\u9cde\u0a0c',
  layout: pipelineLayout4,
  multisample: {count: 1},
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'constant', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.GREEN,
}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'one-minus-src'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {failOp: 'decrement-wrap', depthFailOp: 'invert', passOp: 'increment-wrap'},
    stencilBack: {compare: 'greater', failOp: 'invert', depthFailOp: 'decrement-wrap', passOp: 'invert'},
    stencilReadMask: 2719883054,
    stencilWriteMask: 1420230946,
    depthBias: 1011055886,
    depthBiasClamp: 699.268022015375,
  },
  vertex: {
    module: shaderModule3,
    constants: {},
    buffers: [
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 116, attributes: [{format: 'uint32', offset: 0, shaderLocation: 5}]},
      {arrayStride: 556, attributes: []},
      {arrayStride: 352, stepMode: 'vertex', attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 48, stepMode: 'instance', attributes: []},
      {arrayStride: 660, attributes: []},
      {
        arrayStride: 352,
        attributes: [
          {format: 'unorm8x2', offset: 80, shaderLocation: 13},
          {format: 'unorm8x2', offset: 22, shaderLocation: 7},
        ],
      },
    ],
  },
});
let offscreenCanvas7 = new OffscreenCanvas(918, 416);
let commandEncoder106 = device0.createCommandEncoder({label: '\ue61b\u{1fde1}\ucca7\u{1fe5c}\uab9a'});
let textureView128 = texture12.createView({label: '\u7bd7\ue53d\u9709\u083c', dimension: '2d', baseMipLevel: 6, baseArrayLayer: 37});
let computePassEncoder60 = commandEncoder36.beginComputePass({label: '\u02af\u59a6\u0ded\uf2a5\u0dd3\u0c91\u08ff\u1af2'});
try {
renderPassEncoder3.executeBundles([renderBundle42, renderBundle69, renderBundle69, renderBundle69]);
} catch {}
try {
renderPassEncoder3.setScissorRect(72, 80, 60, 14);
} catch {}
try {
renderPassEncoder0.setStencilReference(2776);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer0, 'uint32', 62_860, 53_116);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder36.setBindGroup(1, bindGroup31);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer11, 8_172);
} catch {}
try {
buffer5.unmap();
} catch {}
try {
commandEncoder25.copyTextureToTexture({
  texture: texture1,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder46.pushDebugGroup('\u499e');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 23420, new DataView(new ArrayBuffer(5867)), 2186, 164);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let imageData18 = new ImageData(68, 116);
let bindGroup39 = device1.createBindGroup({label: '\ub458\u{1fa25}\u7e38\u7191', layout: bindGroupLayout13, entries: []});
let texture68 = device1.createTexture({
  label: '\u582a\ufeb0',
  size: [302, 96, 1],
  mipLevelCount: 2,
  sampleCount: 1,
  dimension: '2d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgb10a2unorm', 'rgb10a2unorm'],
});
let textureView129 = texture56.createView({
  label: '\ub983\u0a19\ub5af\u0c21\u006e\u1056\u{1ff43}\ud881\uf45f\u6b9d',
  dimension: '2d',
  mipLevelCount: 1,
  baseArrayLayer: 51,
});
let computePassEncoder61 = commandEncoder99.beginComputePass({label: '\u6daf\u0eec\u3392\uc67d\u{1fd41}\u{1fb46}\uc323'});
let renderBundle72 = renderBundleEncoder33.finish({label: '\ud6dc\u19b1\u0cbe\ub3af\u6a57\u{1f9c7}\u00ee\uc39c\ub6bd\u09c9'});
try {
computePassEncoder57.end();
} catch {}
try {
renderBundleEncoder51.setIndexBuffer(buffer18, 'uint32', 49_408, 25_509);
} catch {}
try {
renderBundleEncoder48.setVertexBuffer(3, buffer13, 112_940);
} catch {}
let commandEncoder107 = device0.createCommandEncoder({});
let texture69 = device0.createTexture({
  label: '\u{1ffbd}\u{1f685}\u6ae8\u{1fa46}\ud7b9\u3b17\ub3a3\u28db',
  size: {width: 330, height: 240, depthOrArrayLayers: 124},
  mipLevelCount: 5,
  sampleCount: 1,
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['r16float', 'r16float'],
});
let textureView130 = texture3.createView({
  label: '\ub4d6\u91e5\u0c98\u1b37\u987e\ub8f9\u5cc7\ubca0\u17e7\u0f9f\uf099',
  aspect: 'all',
  baseArrayLayer: 0,
});
let externalTexture58 = device0.importExternalTexture({label: '\u0c72\u0b24\u7b61', source: video5, colorSpace: 'display-p3'});
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.draw(214, 172, 58, 406_290_396);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer0, 'uint16', 201_966, 30_399);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(7, buffer4);
} catch {}
try {
commandEncoder103.copyTextureToBuffer({
  texture: texture23,
  mipLevel: 1,
  origin: {x: 25, y: 165, z: 47},
  aspect: 'all',
}, {
  /* bytesInLastRow: 652 widthInBlocks: 326 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 292 */
  offset: 292,
  bytesPerRow: 1024,
  buffer: buffer7,
}, {width: 326, height: 129, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer16, 7384, new BigUint64Array(62757), 41099, 124);
} catch {}
let pipeline90 = device0.createComputePipeline({
  label: '\u0ed0\u{1fc89}\u{1fc28}\u01e9\u0a50\u4fc9\u{1fcf4}\ubca6\u{1fb00}',
  layout: pipelineLayout2,
  compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}},
});
let pipeline91 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  multisample: {mask: 0x35663215},
  fragment: {
  module: shaderModule8,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: 0}, {format: 'rg16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule8,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 300, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 72, stepMode: 'instance', attributes: []},
      {arrayStride: 532, stepMode: 'instance', attributes: []},
      {arrayStride: 72, attributes: []},
      {arrayStride: 96, attributes: []},
      {arrayStride: 192, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 420,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 68, shaderLocation: 2},
          {format: 'uint8x4', offset: 92, shaderLocation: 5},
        ],
      },
    ],
  },
});
try {
window.someLabel = externalTexture39.label;
} catch {}
let commandEncoder108 = device1.createCommandEncoder({label: '\uef83\u{1fab7}\u8a41\uc563\ua0f3\u1faf'});
let computePassEncoder62 = commandEncoder97.beginComputePass({label: '\u7258\u06bd'});
try {
computePassEncoder37.setBindGroup(2, bindGroup22, []);
} catch {}
try {
computePassEncoder37.setPipeline(pipeline59);
} catch {}
try {
renderBundleEncoder39.setBindGroup(3, bindGroup28);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline80);
} catch {}
let promise32 = buffer17.mapAsync(GPUMapMode.WRITE, 0, 19060);
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 28632 */
  offset: 28632,
  bytesPerRow: 512,
  rowsPerImage: 258,
  buffer: buffer15,
}, {
  texture: texture54,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {width: 6, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder64.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 200 */
  offset: 200,
  bytesPerRow: 256,
  buffer: buffer12,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder64.clearBuffer(buffer12, 2216, 1644);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
gc();
let computePassEncoder63 = commandEncoder62.beginComputePass({label: '\u8905\u{1ffe5}\u4e42\ubfa6\u7b3a\u00ec\u0a07\u{1fd7f}\u0d77\ue559\u059e'});
let renderBundle73 = renderBundleEncoder44.finish({label: '\u00f7\u{1fed1}\u012d\uaa5c\u013a\ud824\u{1f999}\u9cf7'});
try {
computePassEncoder3.end();
} catch {}
try {
renderPassEncoder0.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(322);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.draw(141, 33, 95, 1_055_130_464);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer11, 116_232);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(7, buffer9, 71_920, 25_538);
} catch {}
try {
commandEncoder90.copyTextureToBuffer({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1674 widthInBlocks: 837 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 6530 */
  offset: 4856,
  buffer: buffer3,
}, {width: 837, height: 1, depthOrArrayLayers: 1});
} catch {}
let imageBitmap12 = await createImageBitmap(imageBitmap3);
let externalTexture59 = device1.importExternalTexture({label: '\u{1fd2f}\u{1f7fa}\ub1a3\ub63f\u0c0d\u47a8\u86a1', source: videoFrame4});
try {
computePassEncoder61.setBindGroup(0, bindGroup39, new Uint32Array(8065), 7312, 0);
} catch {}
try {
renderBundleEncoder45.setBindGroup(0, bindGroup30);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(1, buffer13, 47_916);
} catch {}
try {
commandEncoder94.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 11264 */
  offset: 11264,
  buffer: buffer13,
}, {
  texture: texture50,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 40, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder108.clearBuffer(buffer12, 3464, 844);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer3, /* required buffer size: 703 */
{offset: 703, rowsPerImage: 59}, {width: 133, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline92 = await device1.createComputePipelineAsync({layout: pipelineLayout7, compute: {module: shaderModule14, entryPoint: 'compute0'}});
try {
adapter0.label = '\u2151\u9a7d\u{1feae}\u1efd';
} catch {}
try {
window.someLabel = renderBundle24.label;
} catch {}
let texture70 = device0.createTexture({
  label: '\ubdde\u6ea6\u53ba\u80f1\u8b06\u{1f9d0}\u{1fcef}\u003d\u0a95\u{1fafd}',
  size: [330],
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32float', 'r32float'],
});
try {
computePassEncoder39.setBindGroup(2, bindGroup4, new Uint32Array(5860), 2819, 0);
} catch {}
try {
renderPassEncoder3.setStencilReference(772);
} catch {}
try {
renderBundleEncoder49.setBindGroup(0, bindGroup3);
} catch {}
try {
renderBundleEncoder29.draw(210, 14, 242, 14_356_787);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer5, 43_416);
} catch {}
try {
renderBundleEncoder13.setVertexBuffer(0, buffer9, 18_376, 28_380);
} catch {}
try {
commandEncoder106.copyTextureToTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 28, y: 57, z: 168},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 2,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 28, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder102.pushDebugGroup('\u071c');
} catch {}
let pipeline93 = device0.createRenderPipeline({
  label: '\u0443\u0776\u1e69\u{1fba8}\uff47\uf027\u0f69\u592e',
  layout: pipelineLayout6,
  fragment: {
  module: shaderModule16,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.RED}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rg16uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst-alpha', dstFactor: 'dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}],
},
  vertex: {
    module: shaderModule16,
    buffers: [
      {arrayStride: 68, attributes: []},
      {arrayStride: 236, attributes: []},
      {
        arrayStride: 528,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x2', offset: 102, shaderLocation: 7}],
      },
      {arrayStride: 236, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 408, shaderLocation: 11}],
      },
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 544,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 100, shaderLocation: 9}],
      },
      {
        arrayStride: 204,
        attributes: [
          {format: 'unorm8x2', offset: 52, shaderLocation: 14},
          {format: 'sint32', offset: 132, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'front'},
});
let gpuCanvasContext13 = offscreenCanvas7.getContext('webgpu');
try {
computePassEncoder37.setPipeline(pipeline82);
} catch {}
try {
renderBundleEncoder45.setBindGroup(2, bindGroup28, new Uint32Array(6696), 4648, 0);
} catch {}
try {
renderBundleEncoder51.setIndexBuffer(buffer18, 'uint32', 6_040, 141);
} catch {}
try {
commandEncoder108.copyBufferToTexture({
  /* bytesInLastRow: 128 widthInBlocks: 32 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 25740 */
  offset: 25612,
  buffer: buffer18,
}, {
  texture: texture50,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 32, height: 1, depthOrArrayLayers: 1});
} catch {}
let imageBitmap13 = await createImageBitmap(imageBitmap5);
let commandEncoder109 = device0.createCommandEncoder({label: '\u4fcc\u0f3b\ub5b8\u0e3c\u{1f6d1}\u18d4\u78f9'});
let texture71 = device0.createTexture({
  label: '\ufca0\u1ed5\u0584\u053a\u101b',
  size: {width: 1320, height: 960, depthOrArrayLayers: 124},
  mipLevelCount: 7,
  sampleCount: 1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView131 = texture6.createView({
  label: '\uaf0c\uc6e3\ue335\u0459',
  dimension: '2d',
  format: 'rgba16uint',
  baseMipLevel: 4,
  mipLevelCount: 3,
  baseArrayLayer: 40,
  arrayLayerCount: 1,
});
try {
renderPassEncoder0.beginOcclusionQuery(1468);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -295.6, g: 730.5, b: -831.4, a: 658.8, });
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer5, 159_416, 53_980);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline67);
} catch {}
try {
commandEncoder20.copyBufferToBuffer(buffer1, 175752, buffer7, 10904, 59800);
} catch {}
try {
commandEncoder106.copyTextureToBuffer({
  texture: texture66,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2352 widthInBlocks: 294 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 6928 */
  offset: 6928,
  buffer: buffer16,
}, {width: 294, height: 1, depthOrArrayLayers: 0});
} catch {}
let promise33 = device0.createRenderPipelineAsync({
  layout: pipelineLayout6,
  multisample: {mask: 0x10534613},
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: 0}, {format: 'rg16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'rgba16uint'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'decrement-clamp', passOp: 'zero'},
    stencilBack: {compare: 'greater', failOp: 'invert', depthFailOp: 'increment-wrap', passOp: 'increment-clamp'},
    stencilReadMask: 52121911,
    stencilWriteMask: 3284602732,
    depthBias: -2013687545,
    depthBiasClamp: 897.5989975036882,
  },
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 52,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint8x4', offset: 4, shaderLocation: 2},
          {format: 'sint16x2', offset: 24, shaderLocation: 4},
          {format: 'uint32', offset: 8, shaderLocation: 12},
        ],
      },
      {arrayStride: 156, stepMode: 'instance', attributes: []},
      {
        arrayStride: 376,
        attributes: [
          {format: 'float16x4', offset: 76, shaderLocation: 1},
          {format: 'float32x3', offset: 84, shaderLocation: 8},
        ],
      },
      {arrayStride: 188, attributes: []},
      {
        arrayStride: 312,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint16x2', offset: 36, shaderLocation: 6},
          {format: 'sint32', offset: 24, shaderLocation: 15},
          {format: 'unorm8x4', offset: 40, shaderLocation: 5},
        ],
      },
      {arrayStride: 344, stepMode: 'instance', attributes: []},
      {arrayStride: 368, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 1096,
        attributes: [
          {format: 'snorm8x2', offset: 96, shaderLocation: 9},
          {format: 'sint32x2', offset: 240, shaderLocation: 11},
          {format: 'float32x2', offset: 776, shaderLocation: 10},
          {format: 'uint32x3', offset: 100, shaderLocation: 3},
          {format: 'sint32x4', offset: 44, shaderLocation: 14},
          {format: 'sint16x2', offset: 196, shaderLocation: 7},
          {format: 'snorm8x2', offset: 40, shaderLocation: 0},
          {format: 'sint16x4', offset: 272, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw'},
});
let canvas18 = document.createElement('canvas');
try {
computePassEncoder37.setBindGroup(0, bindGroup26);
} catch {}
try {
computePassEncoder51.setPipeline(pipeline59);
} catch {}
try {
renderBundleEncoder45.setBindGroup(1, bindGroup36, new Uint32Array(9332), 458, 0);
} catch {}
try {
commandEncoder98.copyBufferToBuffer(buffer13, 166432, buffer12, 5216, 672);
} catch {}
try {
commandEncoder108.copyTextureToTexture({
  texture: texture42,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture63,
  mipLevel: 0,
  origin: {x: 124, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
externalTexture28.label = '\u5580\u0bb8\u053d';
} catch {}
let renderBundleEncoder52 = device1.createRenderBundleEncoder({label: '\uab59\u2040', colorFormats: ['rgba8sint', 'rg16uint', 'rg32sint'], depthReadOnly: true});
try {
computePassEncoder55.setPipeline(pipeline92);
} catch {}
try {
renderBundleEncoder45.setVertexBuffer(7, buffer12, 1_992, 482);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture50,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer3, /* required buffer size: 1_022 */
{offset: 994}, {width: 7, height: 1, depthOrArrayLayers: 1});
} catch {}
gc();
let commandEncoder110 = device0.createCommandEncoder();
try {
computePassEncoder7.setBindGroup(2, bindGroup19, new Uint32Array(6259), 3033, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline28);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle42, renderBundle73, renderBundle69, renderBundle42, renderBundle73]);
} catch {}
try {
renderPassEncoder0.setStencilReference(608);
} catch {}
try {
renderPassEncoder3.setViewport(144.9, 10.27, 13.55, 69.32, 0.1394, 0.3318);
} catch {}
try {
renderPassEncoder0.setIndexBuffer(buffer7, 'uint32', 4_036, 19_960);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.draw(33, 533, 5, 668_671_343);
} catch {}
try {
renderBundleEncoder41.setPipeline(pipeline71);
} catch {}
try {
commandEncoder52.copyBufferToBuffer(buffer5, 216236, buffer16, 5900, 2764);
} catch {}
try {
commandEncoder67.copyTextureToTexture({
  texture: texture1,
  mipLevel: 9,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture6,
  mipLevel: 0,
  origin: {x: 24, y: 34, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder106.clearBuffer(buffer16, 9288, 308);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 30, y: 235 },
  flipY: true,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise26;
} catch {}
document.body.prepend(canvas0);
let commandEncoder111 = device1.createCommandEncoder();
let commandBuffer25 = commandEncoder108.finish({label: '\ub9d9\u62d7\u06f2\u28b5\u016c\u2943'});
let externalTexture60 = device1.importExternalTexture({label: '\uf417\u0923\u{1f8ce}\uc785\u67f7\u3bce\uade7\uf076', source: video5, colorSpace: 'srgb'});
try {
renderBundleEncoder34.setVertexBuffer(4, buffer12, 0, 1_824);
} catch {}
try {
commandEncoder94.copyTextureToBuffer({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 14084 */
  offset: 14056,
  buffer: buffer13,
}, {width: 7, height: 1, depthOrArrayLayers: 1});
} catch {}
let commandEncoder112 = device0.createCommandEncoder({});
let textureView132 = texture21.createView({label: '\uf6e7\u42f0\u{1f790}', dimension: '2d', aspect: 'all', baseMipLevel: 6, baseArrayLayer: 56});
let renderBundle74 = renderBundleEncoder5.finish({label: '\u7767\u{1f799}\u03a3\u7d9d\u10f6\u0932\uf023\u0ac7'});
let externalTexture61 = device0.importExternalTexture({label: '\ud6c5\ub2fd\ua224', source: videoFrame3, colorSpace: 'display-p3'});
try {
renderPassEncoder3.setBindGroup(0, bindGroup37);
} catch {}
try {
renderPassEncoder3.setScissorRect(11, 106, 61, 10);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer6, 'uint16', 1_802, 179);
} catch {}
try {
commandEncoder57.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2732 */
  offset: 2732,
  buffer: buffer16,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder106.clearBuffer(buffer20, 13024, 67028);
} catch {}
try {
gpuCanvasContext13.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
gc();
let commandEncoder113 = device0.createCommandEncoder({label: '\u{1f916}\u{1f87f}\ub784\u{1f669}\u0279'});
let querySet57 = device0.createQuerySet({label: '\u39ce\u{1f851}\u7766\u4b67\u0959\u6793\u34b3\u0123', type: 'occlusion', count: 1514});
try {
computePassEncoder7.setPipeline(pipeline10);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle69, renderBundle42, renderBundle42, renderBundle73, renderBundle42, renderBundle69, renderBundle42, renderBundle73, renderBundle73, renderBundle73]);
} catch {}
try {
renderPassEncoder0.setViewport(116.9, 110.3, 7.116, 5.948, 0.8598, 0.9956);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.draw(67, 306, 217, 748_700_781);
} catch {}
try {
commandEncoder52.copyBufferToTexture({
  /* bytesInLastRow: 1040 widthInBlocks: 260 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 34964 */
  offset: 34964,
  buffer: buffer1,
}, {
  texture: texture70,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 260, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder95.copyTextureToTexture({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture34,
  mipLevel: 2,
  origin: {x: 23, y: 7, z: 15},
  aspect: 'all',
},
{width: 51, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder8.resolveQuerySet(querySet51, 58, 5, buffer16, 3584);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 16088, new DataView(new ArrayBuffer(32364)), 28492);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer4, /* required buffer size: 549 */
{offset: 549, rowsPerImage: 26}, {width: 767, height: 0, depthOrArrayLayers: 1});
} catch {}
let commandEncoder114 = device0.createCommandEncoder({});
let commandBuffer26 = commandEncoder25.finish({label: '\u527a\u0e6e\uee8c\u54ba\u9cb6\u6139\u593d'});
let textureView133 = texture65.createView({label: '\u{1ff5b}\u0b58\uc781\u{1f75f}\ua7d5\u2298\u{1f6fa}', dimension: '2d-array', aspect: 'all'});
let computePassEncoder64 = commandEncoder103.beginComputePass({});
let externalTexture62 = device0.importExternalTexture({label: '\u55e4\u2a25', source: videoFrame9, colorSpace: 'display-p3'});
try {
renderPassEncoder0.setScissorRect(8, 99, 13, 2);
} catch {}
try {
renderBundleEncoder46.setBindGroup(2, bindGroup21, new Uint32Array(1433), 554, 0);
} catch {}
try {
renderBundleEncoder29.draw(14, 303, 21, 1_747_905_618);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer10, 21_012);
} catch {}
try {
commandEncoder43.copyTextureToTexture({
  texture: texture5,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 21},
  aspect: 'all',
},
{
  texture: texture21,
  mipLevel: 4,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
},
{width: 7, height: 1, depthOrArrayLayers: 0});
} catch {}
let texture72 = device0.createTexture({
  label: '\u7c2e\ubdc2\ub648',
  size: {width: 1320},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle75 = renderBundleEncoder18.finish({label: '\u3f5a\u380f\u3c54\u2bb4\u{1f9a0}\u0dd1\u0d19\u{1faab}'});
try {
computePassEncoder54.setBindGroup(0, bindGroup9, new Uint32Array(5119), 550, 0);
} catch {}
try {
computePassEncoder0.dispatchWorkgroups(1, 3, 5);
} catch {}
try {
renderPassEncoder0.end();
} catch {}
try {
renderPassEncoder3.executeBundles([]);
} catch {}
try {
renderPassEncoder3.setStencilReference(1220);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer0, 14_204);
} catch {}
try {
commandEncoder74.clearBuffer(buffer16, 6640, 852);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm-srgb'],
});
} catch {}
let querySet58 = device0.createQuerySet({label: '\u6dc1\u8d0c\u8e5e\u{1fa1a}\u06d7\ud035\u60fb\ubfeb\u096e', type: 'occlusion', count: 273});
let textureView134 = texture41.createView({
  label: '\u{1f62d}\ufab8',
  dimension: '2d-array',
  baseMipLevel: 3,
  baseArrayLayer: 99,
  arrayLayerCount: 12,
});
let computePassEncoder65 = commandEncoder74.beginComputePass({});
try {
renderPassEncoder3.setBindGroup(0, bindGroup10, new Uint32Array(8376), 3779, 0);
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: -531.7, g: -543.0, b: 202.7, a: -546.4, });
} catch {}
try {
renderBundleEncoder29.setBindGroup(1, bindGroup34);
} catch {}
try {
commandEncoder113.clearBuffer(buffer20, 10784, 86784);
} catch {}
let pipeline94 = device0.createRenderPipeline({
  label: '\u0a4b\u0cdb\u{1f8ae}\u{1fd7a}\u04f5\u8888\u{1f9a3}\uf449\uf680\u51a9',
  layout: pipelineLayout0,
  multisample: {mask: 0xb7f3fd6b},
  fragment: {
  module: shaderModule16,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'bgra8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'constant'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rg16uint', writeMask: GPUColorWrite.BLUE}, {
  format: 'rgb10a2unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'never',
    stencilFront: {compare: 'never', depthFailOp: 'invert', passOp: 'invert'},
    stencilBack: {compare: 'greater-equal', failOp: 'zero', depthFailOp: 'invert', passOp: 'invert'},
    stencilReadMask: 3186552606,
    depthBias: 1381289726,
    depthBiasClamp: 755.0934999366588,
  },
  vertex: {
    module: shaderModule16,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 736, attributes: []},
      {arrayStride: 256, stepMode: 'instance', attributes: []},
      {arrayStride: 320, stepMode: 'instance', attributes: []},
      {arrayStride: 32, attributes: []},
      {arrayStride: 208, stepMode: 'instance', attributes: []},
      {arrayStride: 260, stepMode: 'instance', attributes: []},
      {arrayStride: 836, attributes: []},
      {
        arrayStride: 408,
        attributes: [
          {format: 'snorm8x4', offset: 20, shaderLocation: 11},
          {format: 'sint8x2', offset: 92, shaderLocation: 9},
          {format: 'float32x2', offset: 332, shaderLocation: 7},
          {format: 'sint32', offset: 124, shaderLocation: 8},
          {format: 'float32x4', offset: 32, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'},
});
let shaderModule20 = device0.createShaderModule({
  label: '\u{1fc07}\u{1fdc4}\u{1fc75}\u0997\u09bd',
  code: `@group(3) @binding(954)
var<storage, read_write> global4: array<u32>;
@group(2) @binding(954)
var<storage, read_write> n8: array<u32>;
@group(1) @binding(954)
var<storage, read_write> function8: array<u32>;

@compute @workgroup_size(1, 2, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}


@fragment
fn fragment0(@location(15) a0: vec4<u32>, @location(12) a1: vec3<f32>, @location(10) a2: vec4<f16>, @location(4) a3: vec3<u32>, @location(9) a4: vec4<u32>, @builtin(sample_index) a5: u32, @builtin(front_facing) a6: bool, @builtin(sample_mask) a7: u32, @builtin(position) a8: vec4<f32>) -> @location(200) vec2<f32> {
return vec2<f32>();
}

struct S21 {
  @location(1) f0: vec4<f16>,
  @location(4) f1: vec3<f16>
}
struct VertexOutput0 {
  @location(12) f149: vec3<f32>,
  @location(15) f150: vec4<u32>,
  @location(10) f151: vec4<f16>,
  @builtin(position) f152: vec4<f32>,
  @location(4) f153: vec3<u32>,
  @location(9) f154: vec4<u32>
}

@vertex
fn vertex0(@location(13) a0: vec3<f32>, a1: S21, @location(0) a2: vec4<f32>, @location(2) a3: vec3<f16>, @location(15) a4: u32, @location(8) a5: vec3<f32>, @location(9) a6: vec4<i32>, @location(14) a7: vec4<f16>, @location(6) a8: f32, @location(5) a9: vec4<i32>, @location(11) a10: vec2<f16>, @location(3) a11: vec2<f16>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout30 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 319,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let bindGroup40 = device0.createBindGroup({
  label: '\u4235\u350d\u00cd\u{1fb1c}\ue7b3\uca8e\u6037\u3380\u{1fa97}\u4507\ue1e4',
  layout: bindGroupLayout21,
  entries: [],
});
let textureView135 = texture8.createView({label: '\u029f\ud709\u{1f977}\u0824\ub417', baseMipLevel: 2, mipLevelCount: 2});
try {
computePassEncoder53.setBindGroup(1, bindGroup7, new Uint32Array(7134), 6155, 0);
} catch {}
try {
renderPassEncoder3.setStencilReference(2645);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.draw(186, 104, 41, 177_309_074);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 214_380);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer3, 'uint32', 19_576, 41_904);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(7, buffer7, 7_028, 5_257);
} catch {}
try {
commandEncoder89.copyBufferToBuffer(buffer1, 215400, buffer2, 15076, 37064);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 20, height: 15, depthOrArrayLayers: 20}
*/
{
  source: video8,
  origin: { x: 1, y: 3 },
  flipY: false,
}, {
  texture: texture8,
  mipLevel: 3,
  origin: {x: 2, y: 2, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let shaderModule21 = device0.createShaderModule({
  label: '\u0eef\u9c83\u051c\u{1fead}',
  code: `@group(1) @binding(954)
var<storage, read_write> n9: array<u32>;

@compute @workgroup_size(8, 1, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: f32
}

@fragment
fn fragment0(@builtin(sample_mask) a0: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0() -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  hints: {},
});
let commandBuffer27 = commandEncoder59.finish({label: '\u002b\u7e78\u{1f7df}\u0c79\u6c55\u{1fecd}\u4b14\u68c4\u0936\u0f5f'});
try {
renderPassEncoder3.setScissorRect(52, 97, 6, 8);
} catch {}
try {
renderBundleEncoder46.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.setVertexBuffer(0, buffer7, 0, 6_357);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 20, height: 15, depthOrArrayLayers: 100}
*/
{
  source: imageData11,
  origin: { x: 11, y: 42 },
  flipY: true,
}, {
  texture: texture27,
  mipLevel: 3,
  origin: {x: 1, y: 2, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline95 = device0.createRenderPipeline({
  label: '\u0758\u00ab\u7ff1\u0e91\ua894\ue3e9\u{1feb9}',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule12,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, {format: 'rgba16float', writeMask: 0}],
},
  vertex: {
    module: shaderModule12,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 100,
        stepMode: 'instance',
        attributes: [{format: 'uint32x4', offset: 0, shaderLocation: 2}],
      },
      {arrayStride: 528, stepMode: 'instance', attributes: []},
      {arrayStride: 1084, attributes: []},
      {
        arrayStride: 140,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 0, shaderLocation: 8},
          {format: 'uint32x2', offset: 12, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 160,
        stepMode: 'instance',
        attributes: [{format: 'float16x4', offset: 16, shaderLocation: 10}],
      },
      {arrayStride: 136, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: [{format: 'snorm8x2', offset: 342, shaderLocation: 11}]},
      {
        arrayStride: 180,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 16, shaderLocation: 9},
          {format: 'unorm16x4', offset: 52, shaderLocation: 6},
          {format: 'sint32x3', offset: 8, shaderLocation: 14},
          {format: 'sint16x2', offset: 24, shaderLocation: 5},
          {format: 'uint16x2', offset: 44, shaderLocation: 13},
          {format: 'float16x4', offset: 0, shaderLocation: 0},
          {format: 'sint32x3', offset: 40, shaderLocation: 1},
          {format: 'uint16x2', offset: 0, shaderLocation: 4},
          {format: 'float32x3', offset: 104, shaderLocation: 7},
          {format: 'snorm16x2', offset: 28, shaderLocation: 3},
          {format: 'snorm16x2', offset: 24, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-list', frontFace: 'cw', cullMode: 'front'},
});
let commandBuffer28 = commandEncoder111.finish({label: '\u92f4\u59e1\uc4fb\u6005\u{1fab4}\u4e30\u{1fcc8}\u494f'});
let textureView136 = texture37.createView({label: '\u1abd\u{1f71b}\uc2f1\u0922\u0144\u500a', mipLevelCount: 1});
let renderBundle76 = renderBundleEncoder48.finish({label: '\ub3a7\u{1fcf2}\u0e94\ue3be\u0d3e\ua751\uecce\u{1f607}\u{1f875}\u{1f8fe}\ufb0b'});
try {
renderBundleEncoder51.setPipeline(pipeline80);
} catch {}
try {
commandEncoder64.copyTextureToTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture48,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 66, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet39, 320, 478, buffer18, 157952);
} catch {}
let pipeline96 = await device1.createRenderPipelineAsync({
  label: '\u3452\u04c1\u{1f72e}',
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule15,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'r8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'r16sint', writeMask: 0}, {
  format: 'rg32sint',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilFront: {compare: 'greater-equal', failOp: 'increment-wrap', depthFailOp: 'decrement-wrap', passOp: 'invert'},
    stencilBack: {compare: 'less', failOp: 'decrement-clamp', depthFailOp: 'invert'},
    stencilReadMask: 3380704378,
    stencilWriteMask: 508874960,
    depthBiasClamp: 388.18518646335195,
  },
  vertex: {
    module: shaderModule15,
    buffers: [
      {arrayStride: 504, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 320,
        attributes: [
          {format: 'snorm8x4', offset: 164, shaderLocation: 3},
          {format: 'sint32x2', offset: 0, shaderLocation: 6},
          {format: 'float32x2', offset: 40, shaderLocation: 2},
          {format: 'sint16x2', offset: 52, shaderLocation: 0},
          {format: 'float32', offset: 16, shaderLocation: 12},
          {format: 'unorm16x2', offset: 44, shaderLocation: 13},
        ],
      },
      {arrayStride: 36, attributes: []},
      {arrayStride: 1872, stepMode: 'instance', attributes: []},
      {arrayStride: 524, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 464,
        stepMode: 'vertex',
        attributes: [{format: 'float32x2', offset: 84, shaderLocation: 1}],
      },
      {arrayStride: 84, attributes: []},
      {
        arrayStride: 856,
        attributes: [
          {format: 'unorm16x2', offset: 72, shaderLocation: 4},
          {format: 'float32', offset: 56, shaderLocation: 9},
          {format: 'unorm8x4', offset: 60, shaderLocation: 8},
          {format: 'snorm16x4', offset: 276, shaderLocation: 5},
          {format: 'float32', offset: 28, shaderLocation: 11},
          {format: 'uint32x3', offset: 176, shaderLocation: 15},
          {format: 'uint32x4', offset: 440, shaderLocation: 14},
          {format: 'float16x2', offset: 52, shaderLocation: 7},
          {format: 'sint8x4', offset: 44, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let promise34 = adapter2.requestAdapterInfo();
try {
window.someLabel = commandEncoder108.label;
} catch {}
let bindGroupLayout31 = device1.createBindGroupLayout({label: '\u5caf\u8766\u08f5\u030a\u072d', entries: []});
let commandEncoder115 = device1.createCommandEncoder({label: '\u3735\u{1f7df}'});
let querySet59 = device1.createQuerySet({label: '\u48c0\u{1fe6b}', type: 'occlusion', count: 106});
try {
renderBundleEncoder51.setVertexBuffer(0, buffer13, 0, 15_784);
} catch {}
try {
commandEncoder94.clearBuffer(buffer13);
} catch {}
try {
commandEncoder98.resolveQuerySet(querySet38, 251, 157, buffer18, 75008);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 304, new BigUint64Array(56459), 11975, 60);
} catch {}
let adapter4 = await promise6;
let bindGroup41 = device1.createBindGroup({
  label: '\u{1f948}\u000c\u3575\u808d\u{1fe84}\u02c5\uba99',
  layout: bindGroupLayout24,
  entries: [{binding: 966, resource: sampler42}],
});
let commandEncoder116 = device1.createCommandEncoder();
try {
computePassEncoder44.end();
} catch {}
try {
commandEncoder116.copyBufferToBuffer(buffer13, 58852, buffer12, 2052, 1224);
} catch {}
try {
commandEncoder116.copyBufferToTexture({
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 34690 */
  offset: 33660,
  bytesPerRow: 256,
  buffer: buffer13,
}, {
  texture: texture54,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 5, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder116.copyTextureToBuffer({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 59, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 144 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 16728 */
  offset: 16584,
  buffer: buffer13,
}, {width: 36, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline97 = await device1.createRenderPipelineAsync({
  label: '\u09a4\u{1fd6c}\u048a\uf828\u{1fb9b}\u2276\u9ca3\u{1f650}\ua604\ucaec\u6b1a',
  layout: pipelineLayout7,
  multisample: {count: 4},
  fragment: {
  module: shaderModule15,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: 0}, {format: 'r8uint', writeMask: 0}, {format: 'r16sint', writeMask: 0}, {format: 'rg32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilFront: {compare: 'not-equal', failOp: 'increment-wrap', passOp: 'zero'},
    stencilBack: {compare: 'equal', failOp: 'increment-wrap', depthFailOp: 'increment-clamp'},
    stencilReadMask: 423256676,
    stencilWriteMask: 1279966467,
    depthBiasClamp: 907.8160445812034,
  },
  vertex: {
    module: shaderModule15,
    buffers: [
      {arrayStride: 172, stepMode: 'instance', attributes: []},
      {
        arrayStride: 596,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 46, shaderLocation: 6},
          {format: 'snorm8x4', offset: 68, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 416,
        attributes: [
          {format: 'float32x3', offset: 12, shaderLocation: 1},
          {format: 'snorm16x2', offset: 72, shaderLocation: 8},
          {format: 'float32x4', offset: 28, shaderLocation: 7},
          {format: 'uint8x2', offset: 68, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 324,
        stepMode: 'instance',
        attributes: [{format: 'snorm16x2', offset: 12, shaderLocation: 2}],
      },
      {arrayStride: 16, stepMode: 'instance', attributes: []},
      {arrayStride: 548, attributes: []},
      {arrayStride: 136, attributes: [{format: 'unorm10-10-10-2', offset: 28, shaderLocation: 13}]},
      {
        arrayStride: 548,
        attributes: [
          {format: 'sint8x4', offset: 92, shaderLocation: 10},
          {format: 'sint8x2', offset: 118, shaderLocation: 0},
          {format: 'snorm16x2', offset: 8, shaderLocation: 4},
          {format: 'float16x2', offset: 20, shaderLocation: 5},
          {format: 'snorm16x2', offset: 36, shaderLocation: 9},
          {format: 'float16x2', offset: 20, shaderLocation: 3},
          {format: 'float32x3', offset: 56, shaderLocation: 11},
          {format: 'uint32x3', offset: 88, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list'},
});
let commandEncoder117 = device1.createCommandEncoder({label: '\u{1fae6}\u3adc\ua76e\u{1f74a}\udca9\u0102\uafbb'});
let querySet60 = device1.createQuerySet({label: '\u00ec\u24bf\u7575\u6aef\u6960', type: 'occlusion', count: 3085});
try {
computePassEncoder59.setBindGroup(1, bindGroup28, new Uint32Array(3954), 2656, 0);
} catch {}
document.body.prepend(video6);
let shaderModule22 = device0.createShaderModule({
  label: '\u7587\u{1fb4f}\u0ee5\u{1fd28}\u4221\u07cd',
  code: `@group(1) @binding(834)
var<storage, read_write> parameter8: array<u32>;
@group(1) @binding(464)
var<storage, read_write> global5: array<u32>;
@group(1) @binding(91)
var<storage, read_write> parameter9: array<u32>;

@compute @workgroup_size(6, 3, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(4) f0: vec2<u32>,
  @location(1) f1: vec4<i32>,
  @location(2) f2: vec4<f32>,
  @location(5) f3: vec4<f32>,
  @location(3) f4: vec3<u32>,
  @location(0) f5: vec4<f32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(11) a0: vec4<f32>, @location(0) a1: vec2<u32>, @location(14) a2: vec3<u32>, @location(5) a3: vec2<f16>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  hints: {},
});
let commandBuffer29 = commandEncoder92.finish({label: '\udeaa\u9855\u{1f982}\u09fe\u8019\u{1f611}\u04aa\uf3f9\u00f4\u0e42\u0542'});
let texture73 = device0.createTexture({
  label: '\u05e2\ua1e1\u0b1d\u{1fa42}',
  size: {width: 165, height: 120, depthOrArrayLayers: 124},
  mipLevelCount: 5,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let sampler53 = device0.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 49.59,
  lodMaxClamp: 62.44,
  maxAnisotropy: 13,
});
try {
computePassEncoder26.dispatchWorkgroupsIndirect(buffer11, 406316);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: -465.1, g: 697.7, b: -149.7, a: 728.9, });
} catch {}
try {
renderPassEncoder3.setVertexBuffer(0, buffer6, 3_488);
} catch {}
try {
renderBundleEncoder40.setBindGroup(3, bindGroup7, new Uint32Array(8960), 8654, 0);
} catch {}
try {
renderBundleEncoder29.drawIndexed(2_717, 154, 234, 216_106_018, 2_283_568_351);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer11, 445_296);
} catch {}
try {
renderBundleEncoder13.setIndexBuffer(buffer0, 'uint16', 34_648, 13_188);
} catch {}
try {
renderBundleEncoder49.setVertexBuffer(5, buffer5, 0, 42_321);
} catch {}
try {
commandEncoder87.copyTextureToBuffer({
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 11612 */
  offset: 11612,
  rowsPerImage: 155,
  buffer: buffer3,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder70.resolveQuerySet(querySet0, 216, 20, buffer16, 0);
} catch {}
try {
renderBundleEncoder49.insertDebugMarker('\u0314');
} catch {}
try {
device0.queue.writeBuffer(buffer7, 24152, new Float32Array(31521), 7912, 2020);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandBuffer30 = commandEncoder94.finish({label: '\u005d\u3785\u0f90'});
let texture74 = gpuCanvasContext4.getCurrentTexture();
let textureView137 = texture36.createView({label: '\u49b1\u45f8\uff82\uc113\u{1faeb}\u{1ff28}\u0495\u7420', aspect: 'depth-only'});
let externalTexture63 = device1.importExternalTexture({label: '\u0de6\u0233\u61d0\u8217\u921e\u{1fffe}\u14a2\ub45f\u{1fb0f}', source: video0});
try {
device1.pushErrorScope('internal');
} catch {}
try {
commandEncoder98.clearBuffer(buffer12, 2704, 1396);
} catch {}
try {
device1.queue.submit([commandBuffer21, commandBuffer19, commandBuffer18]);
} catch {}
let promise35 = device1.createComputePipelineAsync({
  label: '\u4286\u{1ffdb}\u0c2f\u0ebd\u{1fe35}\u073d\u{1f7d2}\u0efc\u07fd\u6822',
  layout: pipelineLayout7,
  compute: {module: shaderModule11, entryPoint: 'compute0', constants: {}},
});
gc();
let canvas19 = document.createElement('canvas');
let externalTexture64 = device1.importExternalTexture({label: '\u0c8c\u{1f8bf}\uff2b\u5ec0\u049a', source: videoFrame8, colorSpace: 'display-p3'});
try {
renderBundleEncoder39.setIndexBuffer(buffer18, 'uint16', 105_946, 19_705);
} catch {}
try {
commandEncoder117.resolveQuerySet(querySet50, 344, 1183, buffer18, 15872);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture64,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(214), /* required buffer size: 214 */
{offset: 214, rowsPerImage: 199}, {width: 267, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise36 = device1.createRenderPipelineAsync({
  label: '\u3eb4\u1fdf\u{1fe2d}\ubbf3\uea21\u8806\uc9c4',
  layout: pipelineLayout5,
  multisample: {count: 4},
  fragment: {
  module: shaderModule14,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'r16sint', writeMask: 0}, {
  format: 'rg32sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilFront: {compare: 'equal', failOp: 'zero', depthFailOp: 'zero', passOp: 'replace'},
    stencilBack: {compare: 'not-equal', failOp: 'decrement-wrap', depthFailOp: 'keep', passOp: 'increment-clamp'},
    stencilReadMask: 2435938237,
    depthBiasSlopeScale: -82.30298543284894,
    depthBiasClamp: 443.6945325393997,
  },
  vertex: {
    module: shaderModule14,
    constants: {},
    buffers: [
      {arrayStride: 400, attributes: []},
      {arrayStride: 48, stepMode: 'instance', attributes: []},
      {
        arrayStride: 388,
        stepMode: 'vertex',
        attributes: [{format: 'snorm8x2', offset: 58, shaderLocation: 1}],
      },
      {
        arrayStride: 64,
        stepMode: 'instance',
        attributes: [{format: 'uint32x3', offset: 40, shaderLocation: 0}],
      },
      {arrayStride: 0, attributes: []},
      {arrayStride: 84, attributes: []},
      {
        arrayStride: 236,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint16x4', offset: 16, shaderLocation: 2},
          {format: 'snorm16x4', offset: 12, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 356,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 156, shaderLocation: 12},
          {format: 'uint8x4', offset: 60, shaderLocation: 11},
          {format: 'sint32', offset: 260, shaderLocation: 13},
          {format: 'sint8x2', offset: 62, shaderLocation: 6},
          {format: 'float32x2', offset: 0, shaderLocation: 9},
          {format: 'uint16x2', offset: 32, shaderLocation: 15},
          {format: 'snorm8x2', offset: 42, shaderLocation: 4},
          {format: 'unorm8x4', offset: 12, shaderLocation: 3},
          {format: 'snorm8x2', offset: 10, shaderLocation: 5},
          {format: 'float32x2', offset: 128, shaderLocation: 7},
          {format: 'unorm8x2', offset: 74, shaderLocation: 8},
          {format: 'float32x2', offset: 0, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'front'},
});
try {
canvas18.getContext('webgpu');
} catch {}
let bindGroupLayout32 = device0.createBindGroupLayout({
  label: '\u6066\u{1fd7a}\uebc9\u1a4c\u0b3e\uc6c6\u{1ffac}\u0f7b',
  entries: [{binding: 923, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}],
});
let buffer21 = device0.createBuffer({
  label: '\u3feb\udf10\u{1f9f7}\u{1ff06}\uaff0',
  size: 36416,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: false,
});
let commandEncoder118 = device0.createCommandEncoder({label: '\u{1ffc5}\u6750\uacfd\ued6e\u1659\u{1fa84}\u1c7b\u6fcb'});
let textureView138 = texture72.createView({});
let computePassEncoder66 = commandEncoder114.beginComputePass({label: '\u{1f64e}\u2c38\u003b\u1ed3\u2a0d\u0466\uabd7\u{1fbba}\u28aa\u0db7'});
try {
computePassEncoder1.setBindGroup(1, bindGroup40);
} catch {}
try {
computePassEncoder45.setBindGroup(0, bindGroup29, new Uint32Array(4837), 4090, 0);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline64);
} catch {}
try {
renderPassEncoder3.setScissorRect(58, 116, 50, 4);
} catch {}
try {
renderPassEncoder3.setStencilReference(3874);
} catch {}
try {
renderBundleEncoder29.drawIndexed(689, 110, 2_177, -1_989_045_910, 64_938_334);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 94092, new Int16Array(29046), 24195, 884);
} catch {}
let commandEncoder119 = device1.createCommandEncoder({});
let computePassEncoder67 = commandEncoder98.beginComputePass({label: '\u0a76\u8529\uc631\u0638\ub578\u99ce\u301b\udc66\uc654'});
try {
renderBundleEncoder51.setVertexBuffer(5, buffer12);
} catch {}
try {
commandEncoder117.copyBufferToBuffer(buffer17, 19264, buffer13, 105676, 844);
} catch {}
try {
commandEncoder76.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 536 widthInBlocks: 134 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 784 */
  offset: 248,
  buffer: buffer13,
}, {width: 134, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.writeBuffer(buffer13, 29768, new DataView(new ArrayBuffer(53078)), 25615, 3472);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Uint32Array(arrayBuffer3), /* required buffer size: 636 */
{offset: 636}, {width: 246, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline98 = device1.createRenderPipeline({
  label: '\u3e8c\u088c\u6e1d\u{1fa1f}\u4624\u6d02\ueb0e\u0ab8',
  layout: pipelineLayout5,
  multisample: {count: 4, mask: 0xf9cca910},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r32sint', writeMask: GPUColorWrite.ALL}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 68,
        attributes: [
          {format: 'uint16x2', offset: 48, shaderLocation: 9},
          {format: 'snorm8x2', offset: 14, shaderLocation: 2},
          {format: 'uint8x4', offset: 4, shaderLocation: 7},
        ],
      },
      {arrayStride: 596, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 700,
        attributes: [
          {format: 'float32x2', offset: 28, shaderLocation: 0},
          {format: 'uint16x2', offset: 520, shaderLocation: 4},
          {format: 'sint8x2', offset: 94, shaderLocation: 10},
          {format: 'uint32', offset: 332, shaderLocation: 6},
          {format: 'uint32x3', offset: 20, shaderLocation: 1},
        ],
      },
      {arrayStride: 380, attributes: [{format: 'unorm10-10-10-2', offset: 60, shaderLocation: 5}]},
      {arrayStride: 132, attributes: []},
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 168,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 32, shaderLocation: 8},
          {format: 'unorm8x2', offset: 10, shaderLocation: 13},
          {format: 'uint32', offset: 4, shaderLocation: 11},
          {format: 'uint8x4', offset: 36, shaderLocation: 15},
          {format: 'float32x3', offset: 0, shaderLocation: 12},
          {format: 'unorm8x2', offset: 6, shaderLocation: 14},
          {format: 'unorm8x4', offset: 36, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'},
});
let gpuCanvasContext14 = canvas19.getContext('webgpu');
let querySet61 = device1.createQuerySet({label: '\u4f41\u000d\ub396\u8043\uf3f4\u{1fd0d}\u76d8', type: 'occlusion', count: 690});
let computePassEncoder68 = commandEncoder115.beginComputePass();
try {
computePassEncoder42.setBindGroup(1, bindGroup33, new Uint32Array(829), 247, 0);
} catch {}
try {
commandEncoder119.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 15214 */
  offset: 14700,
  bytesPerRow: 512,
  buffer: buffer18,
}, {
  texture: texture54,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
}, {width: 1, height: 2, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder119.clearBuffer(buffer13);
} catch {}
let imageBitmap14 = await createImageBitmap(canvas6);
let promise37 = adapter0.requestAdapterInfo();
let bindGroup42 = device0.createBindGroup({label: '\u6501\ue8c3\u{1f790}\u0f5b', layout: bindGroupLayout2, entries: []});
let commandEncoder120 = device0.createCommandEncoder({label: '\u9695\u{1fcef}\u5687\uc9be\uffee\u{1f999}\u77c7\u73dd\u{1fbd4}'});
let computePassEncoder69 = commandEncoder96.beginComputePass({label: '\u4428\u3b0f\u0c6c\u2f47\u{1fb6c}\u2417\u{1f65a}\u53a3\ued24\ufdd9'});
let renderBundleEncoder53 = device0.createRenderBundleEncoder({
  label: '\u{1fd21}\uef01\u{1f781}\u04c4\u0d79',
  colorFormats: ['rgba8unorm'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let sampler54 = device0.createSampler({
  label: '\u{1f7d7}\u{1fb34}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 79.70,
});
try {
computePassEncoder58.setBindGroup(1, bindGroup35);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle69, renderBundle42, renderBundle73, renderBundle42]);
} catch {}
try {
renderPassEncoder3.setStencilReference(3912);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer4, 0, 10_670);
} catch {}
try {
renderBundleEncoder29.setBindGroup(0, bindGroup20);
} catch {}
try {
renderBundleEncoder29.draw(121, 345, 4, 102_750_847);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 150_160);
} catch {}
try {
buffer11.unmap();
} catch {}
let promise38 = buffer21.mapAsync(GPUMapMode.WRITE, 0, 32568);
try {
commandEncoder90.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 30000 */
  offset: 30000,
  bytesPerRow: 256,
  buffer: buffer3,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder100.clearBuffer(buffer10, 41612, 1292);
} catch {}
try {
device0.queue.writeBuffer(buffer16, 912, new BigUint64Array(64774), 64303, 120);
} catch {}
let videoFrame11 = new VideoFrame(video3, {timestamp: 0});
let textureView139 = texture64.createView({label: '\u9c11\u0361\uc5cc\uec5e\ufe81\ua004\u6a4f\u0373\u{1fabd}\ued68', baseMipLevel: 2});
let renderBundleEncoder54 = device1.createRenderBundleEncoder({
  label: '\u1550\u{1f691}\u0749\u5675\u9c42',
  colorFormats: ['rgba8sint', 'rg16uint', 'rg32sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder35.setPipeline(pipeline63);
} catch {}
try {
renderBundleEncoder51.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder54.setVertexBuffer(1, buffer12, 800, 247);
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
let commandEncoder121 = device0.createCommandEncoder({label: '\uf18c\u{1fe15}\ud522'});
let texture75 = device0.createTexture({
  size: [1320, 960, 166],
  mipLevelCount: 8,
  sampleCount: 1,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgba16uint'],
});
let textureView140 = texture4.createView({dimension: '2d', format: 'rg8unorm', baseMipLevel: 5, baseArrayLayer: 116});
let renderPassEncoder6 = commandEncoder60.beginRenderPass({
  label: '\u{1fdf5}\u3f70\ua4bf\u0f83\u80ea',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: 276.6, g: -523.3, b: 463.3, a: -473.3, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet48,
  maxDrawCount: 615487092,
});
try {
computePassEncoder64.end();
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(442);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle69, renderBundle42, renderBundle73, renderBundle69, renderBundle69, renderBundle42, renderBundle69, renderBundle73]);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: -123.9, g: 320.1, b: 732.2, a: 210.5, });
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer6, 'uint32', 980, 3_681);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(5, buffer7, 6_468);
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup4);
} catch {}
try {
renderBundleEncoder29.draw(13, 230, 36, 108_260_539);
} catch {}
try {
renderBundleEncoder29.drawIndexed(1_230, 268, 448, 288_216_132, 167_881_602);
} catch {}
try {
renderBundleEncoder41.setPipeline(pipeline72);
} catch {}
try {
commandEncoder118.copyBufferToBuffer(buffer9, 157164, buffer16, 728, 9060);
} catch {}
try {
commandEncoder44.copyBufferToTexture({
  /* bytesInLastRow: 1316 widthInBlocks: 329 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 66904 */
  offset: 66904,
  buffer: buffer3,
}, {
  texture: texture60,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 329, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder56.insertDebugMarker('\u4792');
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let bindGroupLayout33 = device0.createBindGroupLayout({label: '\u0c6d\u4aab\ufe3b\u8d9b', entries: []});
let commandEncoder122 = device0.createCommandEncoder({label: '\u2db8\u15d4\u0fa0\u52cc\ud1c7\u39b8'});
let texture76 = device0.createTexture({
  label: '\u0005\u68c6\u6e6b',
  size: {width: 330, height: 240, depthOrArrayLayers: 950},
  mipLevelCount: 10,
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32sint', 'rg32sint', 'rg32sint'],
});
let renderBundleEncoder55 = device0.createRenderBundleEncoder({
  label: '\u{1fe98}\u77ef\u7dff\u0075\uf1aa\u{1fd6c}\ua1a8\ub5ec\u5ce7',
  colorFormats: ['rg16float', 'rgba16float'],
  depthReadOnly: false,
});
let renderBundle77 = renderBundleEncoder3.finish({label: '\u{1f97e}\u7b14\u91fc\u0a11\u0689\u30ae'});
try {
renderPassEncoder6.setScissorRect(109, 30, 1, 9);
} catch {}
try {
renderPassEncoder3.setStencilReference(490);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer0, 'uint16', 197_876, 11_815);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer10, 3_308);
} catch {}
try {
renderBundleEncoder50.setPipeline(pipeline67);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder84.copyBufferToBuffer(buffer10, 4192, buffer14, 776, 24832);
} catch {}
try {
commandEncoder102.copyTextureToBuffer({
  texture: texture28,
  mipLevel: 0,
  origin: {x: 20, y: 3, z: 21},
  aspect: 'all',
}, {
  /* bytesInLastRow: 504 widthInBlocks: 126 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 26588 */
  offset: 5604,
  bytesPerRow: 512,
  buffer: buffer1,
}, {width: 126, height: 41, depthOrArrayLayers: 1});
} catch {}
let bindGroup43 = device0.createBindGroup({label: '\u{1fcf1}\u{1f976}\u9499\u0578\ue3bd\u2eba\u0e6d', layout: bindGroupLayout11, entries: []});
try {
computePassEncoder10.dispatchWorkgroups(2, 2, 4);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup21, new Uint32Array(6021), 3250, 0);
} catch {}
try {
renderPassEncoder3.beginOcclusionQuery(247);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.setVertexBuffer(7, buffer4, 10_056, 45_629);
} catch {}
try {
renderBundleEncoder36.setBindGroup(1, bindGroup10);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer0, 17_888);
} catch {}
try {
renderBundleEncoder40.setVertexBuffer(6, buffer4, 0, 67_179);
} catch {}
try {
buffer8.destroy();
} catch {}
try {
commandEncoder89.copyBufferToBuffer(buffer10, 31048, buffer7, 71164, 384);
} catch {}
try {
commandEncoder102.clearBuffer(buffer20, 31948, 35544);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 45192, new DataView(new ArrayBuffer(38566)), 3123, 716);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture10,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Int16Array(arrayBuffer0), /* required buffer size: 275_510 */
{offset: 946, bytesPerRow: 24, rowsPerImage: 279}, {width: 1, height: 2, depthOrArrayLayers: 42});
} catch {}
let pipelineLayout8 = device0.createPipelineLayout({label: '\u{1f66e}\ubc47\u4c1d\ucc82', bindGroupLayouts: [bindGroupLayout10]});
let commandEncoder123 = device0.createCommandEncoder({label: '\u8c7f\ua36b\u{1f95b}\u4eb4'});
let renderBundle78 = renderBundleEncoder8.finish({});
let externalTexture65 = device0.importExternalTexture({label: '\u0f3a\u{1fce6}', source: videoFrame7, colorSpace: 'srgb'});
try {
computePassEncoder52.setPipeline(pipeline54);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(4, buffer7, 3_364, 2_628);
} catch {}
try {
renderBundleEncoder50.setIndexBuffer(buffer3, 'uint16', 25_862, 14_654);
} catch {}
try {
commandEncoder44.copyBufferToBuffer(buffer9, 3204, buffer10, 8752, 19076);
} catch {}
try {
commandEncoder110.copyTextureToBuffer({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 6, y: 10, z: 135},
  aspect: 'all',
}, {
  /* bytesInLastRow: 464 widthInBlocks: 232 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 206754 */
  offset: 11730,
  bytesPerRow: 512,
  rowsPerImage: 209,
  buffer: buffer1,
}, {width: 232, height: 172, depthOrArrayLayers: 2});
} catch {}
try {
commandEncoder38.clearBuffer(buffer16, 6760, 1620);
} catch {}
try {
device0.queue.writeBuffer(buffer16, 872, new Int16Array(28654), 19820, 232);
} catch {}
let textureView141 = texture21.createView({
  label: '\u0596\u2ac4\u{1f7c2}\ucef7\u2cc9\u8a1d\u0597\u05e5\u{1fcf8}',
  baseMipLevel: 4,
  mipLevelCount: 1,
  baseArrayLayer: 33,
  arrayLayerCount: 26,
});
let renderBundle79 = renderBundleEncoder24.finish({});
try {
computePassEncoder10.dispatchWorkgroupsIndirect(buffer0, 264540);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle73, renderBundle42, renderBundle42, renderBundle73, renderBundle73]);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: -276.6, g: 335.2, b: 477.4, a: -397.8, });
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer5, 25_308);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(1, buffer5, 10_096);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder84.clearBuffer(buffer6, 21592, 1828);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 99, y: 18, z: 67},
  aspect: 'all',
}, arrayBuffer1, /* required buffer size: 359_215 */
{offset: 471, bytesPerRow: 172, rowsPerImage: 56}, {width: 62, height: 14, depthOrArrayLayers: 38});
} catch {}
let bindGroup44 = device0.createBindGroup({
  layout: bindGroupLayout22,
  entries: [
    {binding: 781, resource: sampler54},
    {binding: 976, resource: {buffer: buffer6, offset: 12288, size: 752}},
    {binding: 655, resource: {buffer: buffer6, offset: 11776, size: 10384}},
  ],
});
let querySet62 = device0.createQuerySet({
  label: '\u0d5e\u6090\u{1fd8e}\u{1ffbe}\uacd3\u0120\u09d8\u7549\u0a9c\u63dc\u0b61',
  type: 'occlusion',
  count: 2035,
});
let texture77 = device0.createTexture({
  label: '\u3a3c\u{1f640}',
  size: [165, 120, 1169],
  mipLevelCount: 10,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder56 = device0.createRenderBundleEncoder({
  label: '\u1d06\u0fd3\u0d2b\ua4ac',
  colorFormats: ['r32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle80 = renderBundleEncoder15.finish({label: '\u68db\u0162'});
try {
renderPassEncoder3.setBindGroup(3, bindGroup37);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup8, new Uint32Array(4591), 3146, 0);
} catch {}
try {
renderPassEncoder6.setStencilReference(3846);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer0, 'uint32', 106_196, 34_675);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.draw(14, 208, 20, 462_435_445);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer10, 13_580);
} catch {}
try {
  await buffer20.mapAsync(GPUMapMode.READ, 90200, 10476);
} catch {}
try {
commandEncoder84.copyBufferToTexture({
  /* bytesInLastRow: 680 widthInBlocks: 85 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 98624 */
  offset: 9624,
  bytesPerRow: 768,
  buffer: buffer8,
}, {
  texture: texture6,
  mipLevel: 0,
  origin: {x: 18, y: 18, z: 0},
  aspect: 'all',
}, {width: 85, height: 116, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder113.copyTextureToTexture({
  texture: texture28,
  mipLevel: 2,
  origin: {x: 1, y: 4, z: 4},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder124 = device1.createCommandEncoder({label: '\u0306\ub884'});
let sampler55 = device1.createSampler({
  label: '\u5ba8\u{1fe75}\u{1feb6}\u0a78\u0795\u1f5a',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.97,
  maxAnisotropy: 2,
});
try {
computePassEncoder61.setPipeline(pipeline75);
} catch {}
try {
renderBundleEncoder39.setVertexBuffer(7, buffer12, 0);
} catch {}
try {
commandEncoder116.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 21, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 204 widthInBlocks: 51 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 63228 */
  offset: 63228,
  buffer: buffer13,
}, {width: 51, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
video13.height = 122;
let texture78 = device1.createTexture({
  label: '\u3f84\u8640\u{1fe04}\u2b6f\u{1f752}\u0eb8\u07d8',
  size: {width: 20, height: 20, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView142 = texture63.createView({label: '\u7e91\u{1febd}\u{1fcab}\u05bf\u9447', mipLevelCount: 3});
try {
renderBundleEncoder52.setIndexBuffer(buffer15, 'uint32', 184, 3_091);
} catch {}
try {
renderBundleEncoder45.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(3, buffer13, 0);
} catch {}
try {
commandEncoder76.clearBuffer(buffer13);
} catch {}
let bindGroup45 = device0.createBindGroup({
  label: '\u9304\u1d30\u{1f993}',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer10, offset: 15872, size: 22020}}],
});
let textureView143 = texture67.createView({label: '\u035a\uc1b9\u842c', dimension: '2d-array'});
let computePassEncoder70 = commandEncoder112.beginComputePass({label: '\ue02b\u4fcb\ud18a\u0575\u{1fc76}\ud364\uaeda\u0639\u0800\u1371\u3fde'});
let renderBundle81 = renderBundleEncoder55.finish({label: '\u0129\u{1fbf4}\u949e\u096a\u4680\u22c6\u{1fb63}'});
let externalTexture66 = device0.importExternalTexture({label: '\u5fd7\u9e37\uf399', source: video15, colorSpace: 'display-p3'});
try {
computePassEncoder11.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: 967.6, g: 815.5, b: 659.6, a: 502.2, });
} catch {}
try {
renderPassEncoder3.setStencilReference(2908);
} catch {}
try {
renderPassEncoder6.setViewport(61.76, 44.08, 68.66, 31.79, 0.9324, 0.9517);
} catch {}
try {
renderBundleEncoder41.setBindGroup(2, bindGroup2, new Uint32Array(7680), 7337, 0);
} catch {}
try {
commandEncoder70.copyBufferToBuffer(buffer1, 162580, buffer14, 3040, 27404);
} catch {}
try {
commandEncoder106.copyTextureToBuffer({
  texture: texture17,
  mipLevel: 1,
  origin: {x: 189, y: 0, z: 5},
  aspect: 'all',
}, {
  /* bytesInLastRow: 228 widthInBlocks: 114 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5106 */
  offset: 5106,
  bytesPerRow: 256,
  buffer: buffer2,
}, {width: 114, height: 466, depthOrArrayLayers: 0});
} catch {}
try {
renderPassEncoder6.insertDebugMarker('\u{1faaf}');
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let device2 = await adapter4.requestDevice({
  label: '\u{1fd84}\u0a6b\u{1ff6b}\u9d91\u0fbd\u401c\u{1fc7d}\u{1f6f7}\u{1ff2a}',
  defaultQueue: {label: '\u094d\uef23\uce68\u1d3a'},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxBindGroups: 4,
    maxUniformBufferBindingSize: 27999300,
    maxStorageBufferBindingSize: 247566156,
    maxUniformBuffersPerShaderStage: 12,
  },
});
let texture79 = device2.createTexture({
  label: '\u029e\u8678\u035b\u72a2\u1b68\u2b74',
  size: {width: 240, height: 24, depthOrArrayLayers: 32},
  mipLevelCount: 1,
  format: 'astc-12x12-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['astc-12x12-unorm', 'astc-12x12-unorm', 'astc-12x12-unorm-srgb'],
});
let textureView144 = texture79.createView({
  label: '\u{1f66a}\udc36\u06d0\uf5be\ucc7d\u{1f9bd}\u2c37\u{1fb55}\u733a\u{1f747}\ud89e',
  dimension: '2d',
  baseMipLevel: 0,
});
let sampler56 = device2.createSampler({
  label: '\u{1f6b9}\u0cb3\u0f05\u{1fb5d}\u3f62\u6696\u4c73',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.94,
  lodMaxClamp: 47.90,
  maxAnisotropy: 5,
});
try {
device2.queue.writeTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 1},
  aspect: 'all',
}, new ArrayBuffer(337_157), /* required buffer size: 337_157 */
{offset: 786, bytesPerRow: 279, rowsPerImage: 301}, {width: 132, height: 24, depthOrArrayLayers: 5});
} catch {}
let canvas20 = document.createElement('canvas');
let imageData19 = new ImageData(172, 108);
let shaderModule23 = device0.createShaderModule({
  label: '\u23d3\u{1f891}\u{1f8cd}\u0f55\u99cb\u{1f71e}\ufdd8\uae1a\u095c',
  code: `@group(1) @binding(464)
var<storage, read_write> type4: array<u32>;
@group(1) @binding(91)
var<storage, read_write> type5: array<u32>;

@compute @workgroup_size(6, 3, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(2) f0: vec4<f32>,
  @location(0) f1: vec3<f32>,
  @location(5) f2: vec4<f32>,
  @location(4) f3: vec3<u32>,
  @location(3) f4: vec3<u32>,
  @location(1) f5: vec4<i32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S22 {
  @location(5) f0: vec2<i32>,
  @location(7) f1: vec3<u32>,
  @builtin(vertex_index) f2: u32,
  @location(13) f3: vec3<i32>,
  @location(4) f4: f32
}
struct VertexOutput0 {
  @location(4) f155: f16,
  @location(0) f156: i32,
  @location(3) f157: f32,
  @location(15) f158: vec4<i32>,
  @location(9) f159: vec4<f16>,
  @location(10) f160: vec3<u32>,
  @builtin(position) f161: vec4<f32>,
  @location(12) f162: vec2<f16>
}

@vertex
fn vertex0(@builtin(instance_index) a0: u32, @location(9) a1: vec2<f16>, @location(10) a2: vec3<i32>, a3: S22) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let commandBuffer31 = commandEncoder105.finish({label: '\u2cbf\u{1f77f}\uefe5\u0e41\u7e3f\u{1feaa}\u23a1\u33b1'});
let texture80 = device0.createTexture({
  label: '\u0339\u0bf5\u8002',
  size: {width: 165},
  sampleCount: 1,
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['r32float'],
});
let computePassEncoder71 = commandEncoder43.beginComputePass({label: '\u0882\u01e6\u85db\u092a\u2896\u3334\u08ea\u{1f92d}\ubbfd\u2fc6'});
let renderPassEncoder7 = commandEncoder123.beginRenderPass({
  label: '\u96c8\u5aa5\u181d\udd71\ue586\u056f\u798d\uf86f\u7c6b\u{1ff22}\u0f4e',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: -815.7, g: -858.5, b: -184.9, a: 703.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 306664896,
});
let sampler57 = device0.createSampler({
  label: '\u8d01\u1376\u{1f778}\ub70b',
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 99.75,
});
try {
renderBundleEncoder38.setBindGroup(3, bindGroup44, [5888, 1024]);
} catch {}
try {
renderBundleEncoder29.draw(34, 62, 12, 72_579_391);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer5, 8_876);
} catch {}
try {
commandEncoder109.copyBufferToBuffer(buffer4, 30276, buffer9, 331128, 2152);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture14,
  mipLevel: 0,
  origin: {x: 99, y: 0, z: 0},
  aspect: 'all',
}, new Int32Array(arrayBuffer3), /* required buffer size: 517 */
{offset: 517, bytesPerRow: 2792}, {width: 636, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise39 = device0.createComputePipelineAsync({
  label: '\u53d4\u{1ff79}',
  layout: pipelineLayout2,
  compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}},
});
try {
canvas20.getContext('webgl2');
} catch {}
let shaderModule24 = device1.createShaderModule({
  code: `@group(3) @binding(959)
var<storage, read_write> field4: array<u32>;

@compute @workgroup_size(6, 3, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(1) f0: vec4<u32>,
  @location(0) f1: vec4<i32>,
  @location(2) f2: vec4<i32>
}

@fragment
fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(front_facing) a1: bool, @builtin(sample_index) a2: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S23 {
  @location(14) f0: vec2<u32>,
  @location(12) f1: i32,
  @location(10) f2: vec4<i32>,
  @location(1) f3: u32,
  @location(6) f4: vec4<f32>
}

@vertex
fn vertex0(a0: S23, @location(2) a1: vec2<f32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
});
let textureView145 = texture49.createView({label: '\ue8e7\u12b6\u04c7\ub235\u{1ff24}', baseMipLevel: 2, arrayLayerCount: 1});
let sampler58 = device1.createSampler({
  label: '\u{1f95d}\u720c\ua224\u71bd\u03d4\u{1f66f}\u02e4\u98d8',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 58.91,
  lodMaxClamp: 98.80,
});
try {
renderBundleEncoder34.setBindGroup(1, bindGroup39);
} catch {}
try {
commandEncoder76.copyBufferToBuffer(buffer13, 177976, buffer12, 5328, 1024);
} catch {}
try {
commandEncoder64.clearBuffer(buffer13);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer5, /* required buffer size: 277 */
{offset: 277, bytesPerRow: 1261}, {width: 269, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline99 = device1.createComputePipeline({
  label: '\u0e64\u0352\u{1fb6a}\u0af9\u{1f6ce}\u0180\u0259\u012d\u0407\u0aaa',
  layout: pipelineLayout5,
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let commandEncoder125 = device0.createCommandEncoder({});
try {
computePassEncoder27.setBindGroup(1, bindGroup5);
} catch {}
try {
computePassEncoder26.dispatchWorkgroups(3, 2, 5);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setViewport(93.24, 9.198, 46.60, 1.433, 0.3475, 0.3481);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(6, buffer4, 0, 4_594);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup0);
} catch {}
try {
renderBundleEncoder29.draw(311, 30, 18, 1_256_555_187);
} catch {}
try {
commandEncoder84.copyTextureToTexture({
  texture: texture57,
  mipLevel: 0,
  origin: {x: 230, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture58,
  mipLevel: 0,
  origin: {x: 4, y: 43, z: 15},
  aspect: 'all',
},
{width: 24, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder44.insertDebugMarker('\u3ed5');
} catch {}
try {
device0.queue.submit([commandBuffer29, commandBuffer14]);
} catch {}
let pipeline100 = device0.createRenderPipeline({
  label: '\u08f1\u0936\u33b6\u07be\u{1f8de}\u0d8d\u{1fc20}\u6d1a',
  layout: pipelineLayout6,
  multisample: {count: 4},
  fragment: {
  module: shaderModule12,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, {
  format: 'rgba16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: 0,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilFront: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'increment-clamp', passOp: 'invert'},
    stencilBack: {compare: 'never', depthFailOp: 'decrement-wrap', passOp: 'increment-wrap'},
    stencilWriteMask: 3950346381,
    depthBiasClamp: 119.95085776468017,
  },
  vertex: {
    module: shaderModule12,
    buffers: [
      {arrayStride: 444, attributes: [{format: 'uint32x2', offset: 72, shaderLocation: 13}]},
      {
        arrayStride: 216,
        stepMode: 'instance',
        attributes: [{format: 'sint8x4', offset: 16, shaderLocation: 14}, {format: 'sint32', offset: 0, shaderLocation: 1}],
      },
      {arrayStride: 44, stepMode: 'vertex', attributes: []},
      {arrayStride: 428, stepMode: 'instance', attributes: []},
      {
        arrayStride: 1144,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 300, shaderLocation: 15},
          {format: 'snorm8x4', offset: 44, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 112,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 0, shaderLocation: 0},
          {format: 'float32', offset: 20, shaderLocation: 10},
          {format: 'snorm16x2', offset: 44, shaderLocation: 12},
          {format: 'float32x4', offset: 20, shaderLocation: 3},
          {format: 'float16x2', offset: 4, shaderLocation: 6},
          {format: 'float32x2', offset: 40, shaderLocation: 11},
        ],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 20,
        attributes: [
          {format: 'uint32', offset: 0, shaderLocation: 4},
          {format: 'uint8x2', offset: 2, shaderLocation: 2},
          {format: 'float32x4', offset: 0, shaderLocation: 9},
          {format: 'sint32x4', offset: 0, shaderLocation: 5},
          {format: 'uint32x2', offset: 0, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'ccw', cullMode: 'back', unclippedDepth: false},
});
let textureView146 = texture79.createView({label: '\ua789\u8163\u6a8b\u028d\u0281\u0760\u0e30', dimension: '2d', baseArrayLayer: 15});
try {
  await device2.popErrorScope();
} catch {}
try {
gpuCanvasContext8.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device2.queue.submit([]);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, new BigUint64Array(arrayBuffer4), /* required buffer size: 47_441 */
{offset: 977, bytesPerRow: 88, rowsPerImage: 24}, {width: 60, height: 0, depthOrArrayLayers: 23});
} catch {}
let texture81 = device0.createTexture({
  label: '\ucf3e\u06d2\u0bd0\ubc62\u739f\u04d1\ud993\uac35\u{1fd54}\u{1fae9}\uee2f',
  size: {width: 165, height: 120, depthOrArrayLayers: 124},
  mipLevelCount: 7,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'],
});
try {
renderPassEncoder3.beginOcclusionQuery(394);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle73, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle42, renderBundle73]);
} catch {}
try {
renderPassEncoder3.setStencilReference(2994);
} catch {}
try {
renderPassEncoder6.setViewport(89.02, 73.17, 15.72, 22.75, 0.2517, 0.6577);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer3, 'uint16', 2_638, 20_529);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder56.setBindGroup(3, bindGroup2);
} catch {}
try {
renderBundleEncoder29.draw(111, 187, 30, 66_255_336);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer11, 122_716);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder50.setVertexBuffer(6, buffer5);
} catch {}
try {
buffer0.destroy();
} catch {}
try {
commandEncoder109.copyBufferToTexture({
  /* bytesInLastRow: 228 widthInBlocks: 114 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 367862 */
  offset: 31762,
  bytesPerRow: 256,
  rowsPerImage: 210,
  buffer: buffer5,
}, {
  texture: texture24,
  mipLevel: 1,
  origin: {x: 1, y: 3, z: 9},
  aspect: 'all',
}, {width: 114, height: 53, depthOrArrayLayers: 7});
} catch {}
try {
commandEncoder106.clearBuffer(buffer10);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 41, height: 30, depthOrArrayLayers: 124}
*/
{
  source: video5,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture62,
  mipLevel: 4,
  origin: {x: 8, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline101 = await promise39;
gc();
let offscreenCanvas8 = new OffscreenCanvas(389, 86);
try {
offscreenCanvas8.getContext('2d');
} catch {}
let textureView147 = texture79.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 9});
let imageData20 = new ImageData(180, 28);
let texture82 = device2.createTexture({
  size: [60, 6, 88],
  mipLevelCount: 4,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder57 = device2.createRenderBundleEncoder({
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
});
let texture83 = device0.createTexture({
  label: '\u2c2b\uc3b7\u589a\u0e83\u9ca2',
  size: {width: 165, height: 120, depthOrArrayLayers: 124},
  mipLevelCount: 2,
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder72 = commandEncoder113.beginComputePass({label: '\u{1fc80}\u9777\u0390\u{1f79d}\u{1fe96}\u{1fc50}\ue58d'});
let renderBundle82 = renderBundleEncoder53.finish({label: '\u0d0d\u758b\ud2dc'});
let externalTexture67 = device0.importExternalTexture({label: '\u{1fe67}\u9f5f\u0f88\u{1fb75}\uc309\u27a8\u0fb1', source: video4, colorSpace: 'srgb'});
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle73, renderBundle73, renderBundle42, renderBundle73, renderBundle42]);
} catch {}
try {
renderPassEncoder6.setViewport(31.34, 46.38, 41.11, 51.89, 0.5370, 0.9533);
} catch {}
try {
renderBundleEncoder29.draw(241, 383, 47, 32_932_199);
} catch {}
let pipeline102 = device0.createRenderPipeline({
  label: '\u0ee4\uf8af\uea4d\u0771',
  layout: 'auto',
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'add', srcFactor: 'one', dstFactor: 'dst-alpha'},
    alpha: {operation: 'subtract', srcFactor: 'src-alpha', dstFactor: 'one-minus-src'},
  },
  writeMask: 0,
}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'add', srcFactor: 'src', dstFactor: 'dst'},
  },
}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-constant', dstFactor: 'src-alpha'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'equal', failOp: 'zero', depthFailOp: 'keep', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'increment-wrap'},
    stencilWriteMask: 3892081308,
    depthBias: -1107719262,
    depthBiasSlopeScale: 572.6430996996955,
    depthBiasClamp: 527.276980005541,
  },
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 240, stepMode: 'instance', attributes: []},
      {arrayStride: 268, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 760, stepMode: 'instance', attributes: []},
      {arrayStride: 280, attributes: []},
      {arrayStride: 488, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32x2', offset: 692, shaderLocation: 7},
          {format: 'float16x2', offset: 484, shaderLocation: 13},
          {format: 'uint16x2', offset: 568, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw'},
});
let bindGroupLayout34 = device2.createBindGroupLayout({
  label: '\u{1f710}\u00a8\u{1f94b}\ud3ed\u7394\uf7d6\u05cb\u{1ff60}\u0744\u{1fb17}\ud29d',
  entries: [{binding: 786, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}],
});
let textureView148 = texture79.createView({
  label: '\ucfc0\u0d9e\u719a\u0cd7\u04f6',
  dimension: '2d',
  format: 'astc-12x12-unorm',
  baseArrayLayer: 9,
});
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
let offscreenCanvas9 = new OffscreenCanvas(754, 693);
let img10 = await imageWithData(177, 131, '#c06e281f', '#91212e66');
let texture84 = device2.createTexture({
  label: '\u5bf8\u0905\ud02f\uea20\u225e\u774b\ua7ee\uc72b',
  size: [22, 96, 140],
  mipLevelCount: 7,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm-srgb'],
});
let renderBundleEncoder58 = device2.createRenderBundleEncoder({
  label: '\u0708\u3cf7\u{1f839}\ud553\u{1ffd8}\u5102\ud855\u9702\u5a5d\u0ef3\ue301',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
});
let renderBundle83 = renderBundleEncoder58.finish({});
try {
gpuCanvasContext13.configure({
  device: device2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let img11 = await imageWithData(210, 134, '#a78dad19', '#ce4d9067');
let commandEncoder126 = device1.createCommandEncoder({});
let textureView149 = texture44.createView({format: 'r32sint', baseMipLevel: 1});
try {
computePassEncoder68.setBindGroup(3, bindGroup25);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(6, buffer12, 0, 925);
} catch {}
try {
commandEncoder76.copyBufferToBuffer(buffer15, 30096, buffer13, 146236, 1112);
} catch {}
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 300 widthInBlocks: 75 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 38396 */
  offset: 38396,
  buffer: buffer13,
}, {
  texture: texture47,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, {width: 75, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder116.copyTextureToTexture({
  texture: texture42,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
},
{
  texture: texture39,
  mipLevel: 3,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'depth-only',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder64.clearBuffer(buffer13);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm', 'rgba8unorm'],
  colorSpace: 'srgb',
});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData1,
  origin: { x: 7, y: 57 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
video18.width = 18;
let pipelineLayout9 = device2.createPipelineLayout({label: '\u{1fbe0}\ubb2f', bindGroupLayouts: [bindGroupLayout34]});
let commandEncoder127 = device2.createCommandEncoder({label: '\u{1f9de}\u02e1'});
let querySet63 = device2.createQuerySet({label: '\u4575\u0047\u3fbf', type: 'occlusion', count: 1046});
let externalTexture68 = device2.importExternalTexture({
  label: '\u7405\u9054\ua0df\u05e0\ubb9d\u8da3\u060b\u0af1\u40dd\u0aa6',
  source: videoFrame6,
  colorSpace: 'display-p3',
});
try {
commandEncoder127.copyTextureToTexture({
  texture: texture82,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 18},
  aspect: 'all',
},
{
  texture: texture82,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
let bindGroup46 = device1.createBindGroup({layout: bindGroupLayout20, entries: []});
let renderBundleEncoder59 = device1.createRenderBundleEncoder({colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'], depthReadOnly: true});
let renderBundle84 = renderBundleEncoder51.finish();
try {
computePassEncoder55.setBindGroup(3, bindGroup25, new Uint32Array(9477), 4121, 0);
} catch {}
try {
commandEncoder119.resolveQuerySet(querySet52, 272, 2290, buffer18, 17920);
} catch {}
try {
device1.queue.submit([commandBuffer23]);
} catch {}
let pipeline103 = device1.createRenderPipeline({
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: 0}, {format: 'r32sint', writeMask: GPUColorWrite.GREEN}, {format: 'rgb10a2unorm', writeMask: 0}],
},
  vertex: {
    module: shaderModule11,
    buffers: [
      {arrayStride: 296, stepMode: 'instance', attributes: []},
      {
        arrayStride: 128,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x4', offset: 16, shaderLocation: 9},
          {format: 'unorm10-10-10-2', offset: 20, shaderLocation: 0},
          {format: 'uint32x3', offset: 32, shaderLocation: 4},
          {format: 'unorm10-10-10-2', offset: 44, shaderLocation: 2},
          {format: 'uint8x2', offset: 18, shaderLocation: 8},
          {format: 'uint32', offset: 0, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 684,
        stepMode: 'instance',
        attributes: [{format: 'uint16x2', offset: 40, shaderLocation: 11}],
      },
      {arrayStride: 64, stepMode: 'instance', attributes: []},
      {arrayStride: 1864, stepMode: 'instance', attributes: []},
      {arrayStride: 64, attributes: [{format: 'snorm16x2', offset: 0, shaderLocation: 5}]},
      {arrayStride: 424, attributes: [{format: 'uint16x2', offset: 156, shaderLocation: 7}]},
      {
        arrayStride: 608,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 12, shaderLocation: 14},
          {format: 'unorm8x2', offset: 236, shaderLocation: 13},
          {format: 'sint32x2', offset: 92, shaderLocation: 10},
          {format: 'float32x2', offset: 232, shaderLocation: 12},
          {format: 'uint16x2', offset: 84, shaderLocation: 1},
          {format: 'uint8x2', offset: 276, shaderLocation: 6},
          {format: 'unorm8x4', offset: 8, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'ccw'},
});
try {
computePassEncoder35.setPipeline(pipeline99);
} catch {}
try {
device1.pushErrorScope('internal');
} catch {}
try {
buffer18.unmap();
} catch {}
try {
commandEncoder124.resolveQuerySet(querySet30, 138, 73, buffer15, 1792);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture64,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new DataView(arrayBuffer0), /* required buffer size: 257 */
{offset: 257, bytesPerRow: 2313}, {width: 266, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup47 = device2.createBindGroup({
  label: '\ud90a\ube43',
  layout: bindGroupLayout34,
  entries: [{binding: 786, resource: externalTexture68}],
});
let buffer22 = device2.createBuffer({
  label: '\u0076\u{1fbfa}',
  size: 339704,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: true,
});
let commandEncoder128 = device2.createCommandEncoder({label: '\u0c9f\u634e\u002e\u0fee\u9020'});
try {
renderBundleEncoder57.setBindGroup(0, bindGroup47, new Uint32Array(3068), 608, 0);
} catch {}
let arrayBuffer6 = buffer22.getMappedRange(168136);
try {
commandEncoder127.copyTextureToTexture({
  texture: texture82,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 4},
  aspect: 'all',
},
{
  texture: texture82,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 11, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let textureView150 = texture84.createView({
  label: '\ud160\uaad1\ub159\u2424\u769c',
  dimension: '2d-array',
  format: 'rgba8unorm-srgb',
  baseMipLevel: 1,
  baseArrayLayer: 37,
  arrayLayerCount: 44,
});
try {
  await promise38;
} catch {}
let bindGroupLayout35 = device0.createBindGroupLayout({label: '\u060c\u9727\u0247', entries: []});
let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout30, bindGroupLayout19, bindGroupLayout9, bindGroupLayout26]});
let commandEncoder129 = device0.createCommandEncoder({label: '\ue588\u23d7'});
let querySet64 = device0.createQuerySet({type: 'occlusion', count: 3231});
let renderBundle85 = renderBundleEncoder49.finish({label: '\ua921\u0737\u5e2f'});
let externalTexture69 = device0.importExternalTexture({label: '\u{1faa8}\u0d45', source: videoFrame5, colorSpace: 'srgb'});
try {
renderBundleEncoder29.draw(28, 11, 89, 1_582_232_805);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer10, 7_528);
} catch {}
try {
renderBundleEncoder27.setVertexBuffer(6, buffer4, 0, 10_203);
} catch {}
try {
commandEncoder52.copyBufferToBuffer(buffer10, 20736, buffer16, 4036, 6688);
} catch {}
try {
commandEncoder20.copyBufferToTexture({
  /* bytesInLastRow: 66 widthInBlocks: 33 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 391910 */
  offset: 37796,
  bytesPerRow: 256,
  rowsPerImage: 76,
  buffer: buffer5,
}, {
  texture: texture8,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 3},
  aspect: 'all',
}, {width: 33, height: 16, depthOrArrayLayers: 19});
} catch {}
try {
commandEncoder122.copyTextureToTexture({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture70,
  mipLevel: 0,
  origin: {x: 37, y: 0, z: 0},
  aspect: 'all',
},
{width: 22, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder125.insertDebugMarker('\u69bf');
} catch {}
try {
device0.queue.writeBuffer(buffer1, 17012, new Float32Array(6140), 6071);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 41, height: 30, depthOrArrayLayers: 124}
*/
{
  source: imageData6,
  origin: { x: 0, y: 2 },
  flipY: false,
}, {
  texture: texture62,
  mipLevel: 4,
  origin: {x: 0, y: 2, z: 15},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 6, depthOrArrayLayers: 0});
} catch {}
let pipeline104 = await promise23;
let videoFrame12 = new VideoFrame(img10, {timestamp: 0});
let shaderModule25 = device2.createShaderModule({
  code: `@group(0) @binding(786)
var<storage, read_write> global6: array<u32>;

@compute @workgroup_size(4, 3, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S25 {
  @location(7) f0: f32,
  @location(0) f1: vec2<u32>,
  @builtin(sample_index) f2: u32
}
struct FragmentOutput0 {
  @location(5) f0: vec3<f32>,
  @location(1) f1: vec4<f32>,
  @location(0) f2: vec4<f32>,
  @location(3) f3: vec4<f32>,
  @location(2) f4: vec4<f32>,
  @location(4) f5: i32,
  @location(6) f6: vec4<i32>
}

@fragment
fn fragment0(@location(13) a0: vec4<f32>, a1: S25) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S24 {
  @builtin(instance_index) f0: u32
}
struct VertexOutput0 {
  @builtin(position) f163: vec4<f32>,
  @location(13) f164: vec4<f32>,
  @location(7) f165: f32,
  @location(0) f166: vec2<u32>
}

@vertex
fn vertex0(@location(13) a0: u32, @location(0) a1: vec2<f16>, a2: S24, @builtin(vertex_index) a3: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
});
let commandEncoder130 = device2.createCommandEncoder({label: '\u08e3\ua34e\u{1fdae}\ufdf2\ue4d4\ude20\u0b9c\u7911\u{1fa54}\u4bb5'});
let sampler59 = device2.createSampler({
  label: '\uaf7c\u0c25\u015b\u0242\uce10\u0cd0\ub788\u{1f797}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 36.11,
  lodMaxClamp: 43.94,
});
let externalTexture70 = device2.importExternalTexture({label: '\u2d9a\u0af5\u{1f6fe}\u28e7', source: videoFrame9});
let commandEncoder131 = device0.createCommandEncoder({});
let textureView151 = texture0.createView({mipLevelCount: 1, baseArrayLayer: 36, arrayLayerCount: 46});
let externalTexture71 = device0.importExternalTexture({label: '\u0e50\u136d', source: video12});
try {
computePassEncoder0.setPipeline(pipeline78);
} catch {}
try {
renderPassEncoder3.setBlendConstant({ r: -877.0, g: 543.8, b: 831.0, a: 551.3, });
} catch {}
try {
renderBundleEncoder50.setBindGroup(1, bindGroup1);
} catch {}
try {
renderBundleEncoder29.drawIndexed(3_730, 112, 2_603, -1_512_225_635, 345_652_214);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer10, 16_068);
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture29,
  mipLevel: 0,
  origin: {x: 353, y: 15, z: 7},
  aspect: 'all',
},
{width: 247, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder20.clearBuffer(buffer6, 12820, 1124);
} catch {}
let commandBuffer32 = commandEncoder53.finish({label: '\u038d\u{1ff7f}\u0b42'});
let renderBundleEncoder60 = device0.createRenderBundleEncoder({
  label: '\u{1fe92}\uef65\ud675\ue4dc\ubb6c\u{1f970}\u0190',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let externalTexture72 = device0.importExternalTexture({
  label: '\uddf3\ud3c1\u0061\uce85\uca52\u07e3\u{1fc58}\u2c1a',
  source: videoFrame9,
  colorSpace: 'display-p3',
});
try {
renderPassEncoder3.beginOcclusionQuery(794);
} catch {}
try {
renderBundleEncoder29.draw(1, 272, 23, 581_029_789);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm', 'rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let buffer23 = device2.createBuffer({
  label: '\u{1fd1d}\u6b42\u9ca1',
  size: 539927,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
});
let commandEncoder132 = device2.createCommandEncoder({label: '\uba2b\u0200\u{1fcd4}\u0a36\u9bd6\u4947'});
let texture85 = device2.createTexture({
  label: '\u{1fcdb}\u6c7b\u8f00\u0041\u4c16\uba75\uf785\u070b\u9600\u3195\u{1fd3d}',
  size: {width: 60},
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm'],
});
let computePassEncoder73 = commandEncoder132.beginComputePass();
try {
commandEncoder128.copyBufferToBuffer(buffer22, 268636, buffer23, 373432, 57104);
} catch {}
let pipeline105 = await device2.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}}});
let commandEncoder133 = device1.createCommandEncoder({label: '\u4914\ueb6b\u2c38'});
let textureView152 = texture46.createView({
  label: '\u8fc4\u5a28\u0f0f\u0568\u23b1\u{1fc2d}\ufabf\u41de',
  dimension: '2d',
  baseMipLevel: 4,
  baseArrayLayer: 18,
});
let renderBundleEncoder61 = device1.createRenderBundleEncoder({
  label: '\u0e26\u0932\u0a79\u7de5\u{1fb41}\u4d28\u3e1d\uebb5\u18ac\u7eac',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
});
try {
computePassEncoder48.setPipeline(pipeline92);
} catch {}
try {
buffer19.unmap();
} catch {}
try {
commandEncoder119.copyBufferToBuffer(buffer15, 20448, buffer12, 2660, 780);
} catch {}
try {
commandEncoder133.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 14216 */
  offset: 14206,
  buffer: buffer13,
}, {width: 5, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder117.copyTextureToTexture({
  texture: texture56,
  mipLevel: 3,
  origin: {x: 9, y: 0, z: 14},
  aspect: 'all',
},
{
  texture: texture78,
  mipLevel: 2,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder124.clearBuffer(buffer13);
} catch {}
try {
computePassEncoder59.insertDebugMarker('\u0ad6');
} catch {}
try {
device1.queue.submit([commandBuffer22, commandBuffer30, commandBuffer28]);
} catch {}
try {
  await promise37;
} catch {}
let img12 = await imageWithData(197, 124, '#17992473', '#0efcc6ff');
let commandEncoder134 = device0.createCommandEncoder({label: '\u19f1\u0e70\u{1f7c7}\ue23d\u8e54\uf535\u2b40'});
let externalTexture73 = device0.importExternalTexture({source: video12, colorSpace: 'display-p3'});
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
commandEncoder109.copyTextureToTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 233, y: 101, z: 387},
  aspect: 'all',
},
{
  texture: texture72,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
},
{width: 132, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer3, 28068, new Int16Array(51918), 50348, 508);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 124}
*/
{
  source: video16,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture24,
  mipLevel: 1,
  origin: {x: 13, y: 17, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline106 = device0.createRenderPipeline({
  label: '\uabf3\u0c94\u027b\u99e3\u079c\u{1f9e6}\u2288\ub145\u68f5\ua42e',
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule20,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32float', writeMask: GPUColorWrite.ALL}],
},
  vertex: {
    module: shaderModule20,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 724, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 328, shaderLocation: 15},
          {format: 'unorm10-10-10-2', offset: 1004, shaderLocation: 0},
          {format: 'unorm8x2', offset: 400, shaderLocation: 14},
          {format: 'snorm16x4', offset: 1100, shaderLocation: 1},
          {format: 'snorm8x2', offset: 812, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 544,
        stepMode: 'instance',
        attributes: [{format: 'float32', offset: 4, shaderLocation: 2}],
      },
      {arrayStride: 1076, attributes: []},
      {
        arrayStride: 172,
        stepMode: 'instance',
        attributes: [{format: 'sint16x2', offset: 44, shaderLocation: 5}],
      },
      {arrayStride: 84, stepMode: 'vertex', attributes: [{format: 'sint32x4', offset: 0, shaderLocation: 9}]},
      {
        arrayStride: 1780,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 488, shaderLocation: 3},
          {format: 'unorm8x2', offset: 1234, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 72,
        attributes: [
          {format: 'float32x2', offset: 0, shaderLocation: 8},
          {format: 'snorm16x4', offset: 4, shaderLocation: 4},
          {format: 'float32x4', offset: 4, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw'},
});
let bindGroupLayout36 = pipeline14.getBindGroupLayout(1);
let renderBundleEncoder62 = device0.createRenderBundleEncoder({colorFormats: ['rg16float', 'rgba16float']});
try {
computePassEncoder69.setBindGroup(1, bindGroup4, new Uint32Array(6650), 2889, 0);
} catch {}
try {
computePassEncoder18.setPipeline(pipeline52);
} catch {}
try {
renderPassEncoder3.setStencilReference(1062);
} catch {}
try {
renderPassEncoder6.setViewport(150.5, 19.79, 5.969, 23.11, 0.02276, 0.9348);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(1, buffer5, 78_416, 92_089);
} catch {}
try {
commandEncoder121.copyBufferToBuffer(buffer5, 316148, buffer16, 556, 524);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 296 */
{offset: 292}, {width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 124}
*/
{
  source: imageData11,
  origin: { x: 1, y: 147 },
  flipY: false,
}, {
  texture: texture28,
  mipLevel: 0,
  origin: {x: 6, y: 7, z: 88},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 41, height: 7, depthOrArrayLayers: 0});
} catch {}
let pipeline107 = device0.createRenderPipeline({
  label: '\u0e33\u39d3\ue411\ua4ed\u05af\uff97\u292a\u0297',
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule8,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
}, {
  format: 'rgba8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.GREEN}, {format: 'rg16uint', writeMask: 0}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.BLUE,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'always',
    stencilFront: {compare: 'equal', failOp: 'decrement-wrap', depthFailOp: 'replace', passOp: 'zero'},
    stencilBack: {failOp: 'increment-clamp', depthFailOp: 'invert', passOp: 'invert'},
    stencilWriteMask: 4294967295,
    depthBias: 1544822241,
    depthBiasSlopeScale: 397.9474047949289,
    depthBiasClamp: 302.7151578807565,
  },
  vertex: {
    module: shaderModule8,
    buffers: [
      {arrayStride: 332, attributes: []},
      {arrayStride: 244, stepMode: 'instance', attributes: []},
      {arrayStride: 76, stepMode: 'instance', attributes: []},
      {arrayStride: 24, stepMode: 'vertex', attributes: []},
      {arrayStride: 300, attributes: []},
      {arrayStride: 32, stepMode: 'instance', attributes: []},
      {arrayStride: 1172, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x2', offset: 468, shaderLocation: 5},
          {format: 'unorm16x4', offset: 28, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list'},
});
let texture86 = device2.createTexture({
  label: '\u743b\u46e6',
  size: {width: 45, height: 192, depthOrArrayLayers: 57},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm-srgb'],
});
try {
renderBundleEncoder57.setBindGroup(3, bindGroup47, []);
} catch {}
let arrayBuffer7 = buffer22.getMappedRange(0, 12184);
try {
commandEncoder130.copyBufferToBuffer(buffer22, 171520, buffer23, 279912, 123268);
} catch {}
try {
commandEncoder128.clearBuffer(buffer23, 28512, 327688);
} catch {}
try {
commandEncoder127.resolveQuerySet(querySet63, 128, 187, buffer23, 104192);
} catch {}
try {
device2.queue.writeBuffer(buffer23, 112416, new Float32Array(57260), 48778, 1716);
} catch {}
canvas13.height = 1482;
let querySet65 = device2.createQuerySet({label: '\ubb62\ue7de\u7206\u00cd\u0aa4\ucef5\uf085\u0684', type: 'occlusion', count: 1437});
let renderBundle86 = renderBundleEncoder58.finish({});
try {
commandEncoder130.clearBuffer(buffer23, 517840, 6212);
} catch {}
let pipeline108 = device2.createRenderPipeline({
  label: '\u0e79\u0b49\u{1fd61}\uf939\u354e\udb56\u865d\u{1f9d6}\u084a\u{1fbd6}',
  layout: pipelineLayout9,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-src'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgba8unorm-srgb', writeMask: 0}, {format: 'r8unorm', writeMask: GPUColorWrite.GREEN}, {format: 'r8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'never', failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'zero'},
    stencilBack: {failOp: 'invert', depthFailOp: 'increment-clamp', passOp: 'zero'},
    stencilWriteMask: 2327019662,
    depthBiasSlopeScale: 954.6933946749373,
  },
  vertex: {
    module: shaderModule25,
    buffers: [
      {arrayStride: 1856, attributes: []},
      {arrayStride: 28, attributes: []},
      {arrayStride: 972, stepMode: 'instance', attributes: []},
      {arrayStride: 160, stepMode: 'instance', attributes: []},
      {arrayStride: 300, stepMode: 'vertex', attributes: []},
      {arrayStride: 76, stepMode: 'instance', attributes: []},
      {arrayStride: 568, attributes: [{format: 'unorm16x2', offset: 24, shaderLocation: 0}]},
      {
        arrayStride: 684,
        stepMode: 'instance',
        attributes: [{format: 'uint8x4', offset: 48, shaderLocation: 13}],
      },
    ],
  },
});
let textureView153 = texture38.createView({label: '\u36f3\u2a65\u02e0\u908b\u04ff\u{1fd32}\u0d18'});
try {
computePassEncoder35.setBindGroup(3, bindGroup30, new Uint32Array(4381), 1813, 0);
} catch {}
try {
renderBundleEncoder39.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder52.setVertexBuffer(5, buffer12);
} catch {}
try {
commandEncoder117.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 24 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 9552 */
  offset: 9552,
  bytesPerRow: 256,
  buffer: buffer13,
}, {width: 12, height: 0, depthOrArrayLayers: 1});
} catch {}
let video19 = await videoWithData();
let imageBitmap15 = await createImageBitmap(imageBitmap13);
let bindGroupLayout37 = device0.createBindGroupLayout({entries: []});
try {
computePassEncoder26.dispatchWorkgroupsIndirect(buffer11, 734948);
} catch {}
try {
renderPassEncoder3.setBindGroup(3, bindGroup8);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder20.setBindGroup(1, bindGroup7);
} catch {}
try {
renderBundleEncoder29.drawIndexed(1_842, 289, 421, 118_113_675, 1_396_025_471);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer10, 5_176);
} catch {}
try {
renderBundleEncoder56.setPipeline(pipeline106);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(6, buffer9, 0, 1_749);
} catch {}
try {
commandEncoder32.resolveQuerySet(querySet25, 844, 1657, buffer0, 94720);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 20, height: 15, depthOrArrayLayers: 20}
*/
{
  source: offscreenCanvas4,
  origin: { x: 7, y: 49 },
  flipY: false,
}, {
  texture: texture8,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
let pipeline109 = device0.createComputePipeline({
  label: '\u5b63\u4d09\u023a\u326a\u2c07\u{1f7f5}',
  layout: pipelineLayout1,
  compute: {module: shaderModule23, entryPoint: 'compute0'},
});
try {
  await promise34;
} catch {}
let commandEncoder135 = device1.createCommandEncoder({label: '\u{1f7f8}\u{1f66a}\ua9fd\u0dbc\u09bb\u0a3e\ubc4b\u70dc\u01b6'});
let textureView154 = texture54.createView({
  label: '\u0705\uf676\ubebc\u9997\u{1fa37}\u65e0\u{1ffcf}\ub5ef\u48c5\u{1fde3}\u0996',
  baseMipLevel: 1,
});
let renderBundleEncoder63 = device1.createRenderBundleEncoder({
  label: '\u{1f972}\u7e79\u76fd\uc278\u096c\u4946\u566d\u{1fef7}\u{1ff35}',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
});
let canvas21 = document.createElement('canvas');
let commandEncoder136 = device2.createCommandEncoder({});
let commandBuffer33 = commandEncoder127.finish({label: '\u0615\uc4f0\udc08\u{1fdd5}\u0cd0\u829f\u89f7\u3f67\u{1f8d1}\u{1fc25}'});
let textureView155 = texture86.createView({format: 'rgba8unorm-srgb', baseMipLevel: 1});
try {
commandEncoder128.copyBufferToTexture({
  /* bytesInLastRow: 204 widthInBlocks: 51 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 52268 */
  offset: 52268,
  rowsPerImage: 171,
  buffer: buffer23,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 51, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder128.copyTextureToBuffer({
  texture: texture82,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 412460 */
  offset: 14620,
  bytesPerRow: 256,
  rowsPerImage: 111,
  buffer: buffer23,
}, {width: 4, height: 1, depthOrArrayLayers: 15});
} catch {}
try {
commandEncoder130.copyTextureToTexture({
  texture: texture82,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
},
{
  texture: texture82,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 24, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder136.clearBuffer(buffer23, 322188, 62308);
} catch {}
try {
commandEncoder136.resolveQuerySet(querySet63, 12, 77, buffer23, 141568);
} catch {}
try {
device2.queue.writeBuffer(buffer23, 61752, new BigUint64Array(45226), 14062, 3672);
} catch {}
let promise40 = device2.createComputePipelineAsync({
  label: '\u{1f977}\u0393\u1f22\u082c\u03eb\u454b\ueadb\ue1be\ub4d0\u3e7a\u{1f9f6}',
  layout: 'auto',
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let commandEncoder137 = device0.createCommandEncoder({label: '\u{1fd88}\uddcf\u14d7\u0394'});
let textureView156 = texture29.createView({aspect: 'all', baseMipLevel: 2});
try {
computePassEncoder10.dispatchWorkgroups(4, 5, 2);
} catch {}
try {
renderPassEncoder3.executeBundles([renderBundle73, renderBundle42, renderBundle69]);
} catch {}
try {
renderPassEncoder3.setIndexBuffer(buffer0, 'uint16', 7_452, 73_099);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(1, buffer9, 0, 7_625);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer0, 23_216);
} catch {}
try {
commandEncoder87.copyBufferToBuffer(buffer9, 192556, buffer7, 64988, 4592);
} catch {}
try {
commandEncoder125.copyTextureToTexture({
  texture: texture40,
  mipLevel: 4,
  origin: {x: 6, y: 5, z: 0},
  aspect: 'all',
},
{
  texture: texture40,
  mipLevel: 1,
  origin: {x: 92, y: 236, z: 0},
  aspect: 'all',
},
{width: 39, height: 22, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer31, commandBuffer27, commandBuffer15]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 0,
  origin: {x: 42, y: 5, z: 63},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 86_265 */
{offset: 707, bytesPerRow: 510, rowsPerImage: 234}, {width: 194, height: 168, depthOrArrayLayers: 1});
} catch {}
let promise41 = device0.queue.onSubmittedWorkDone();
try {
gpuCanvasContext4.unconfigure();
} catch {}
document.body.prepend(video4);
let imageData21 = new ImageData(120, 132);
let commandEncoder138 = device0.createCommandEncoder({label: '\u{1f653}\ue37b\u4990\u{1fdf1}\u800e\u7be4\u{1fab3}'});
try {
computePassEncoder10.dispatchWorkgroups(3, 2, 4);
} catch {}
try {
computePassEncoder54.setPipeline(pipeline29);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(6, buffer5, 1_472, 37_662);
} catch {}
try {
renderBundleEncoder29.drawIndexed(2_162, 176, 543, 171_815_591, 205_628_571);
} catch {}
try {
commandEncoder67.copyBufferToBuffer(buffer3, 85836, buffer7, 17956, 752);
} catch {}
try {
commandEncoder103.clearBuffer(buffer14, 19356, 5232);
} catch {}
try {
commandEncoder100.resolveQuerySet(querySet18, 39, 1250, buffer1, 32000);
} catch {}
try {
computePassEncoder46.popDebugGroup();
} catch {}
let pipeline110 = device0.createComputePipeline({
  label: '\u{1fbd2}\u25c8\u{1fb5d}\u7e3b\u5e23\u0f24\u{1fd89}\u672c\u017c',
  layout: pipelineLayout10,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let canvas22 = document.createElement('canvas');
let imageBitmap16 = await createImageBitmap(video19);
let renderBundle87 = renderBundleEncoder53.finish({});
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle69, renderBundle42, renderBundle42]);
} catch {}
try {
renderPassEncoder7.setViewport(50.05, 118.8, 58.87, 0.6972, 0.4745, 0.7814);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline106);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(4, buffer7, 0, 8_519);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer0, 143_356);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(1, buffer4, 21_252, 7_856);
} catch {}
try {
commandEncoder134.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2544 */
  offset: 2544,
  buffer: buffer3,
}, {
  texture: texture77,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder129.copyTextureToTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 0,
  origin: {x: 114, y: 1, z: 0},
  aspect: 'all',
},
{width: 230, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame13 = new VideoFrame(img11, {timestamp: 0});
let bindGroup48 = device2.createBindGroup({
  label: '\u54ae\u{1f8ad}',
  layout: bindGroupLayout34,
  entries: [{binding: 786, resource: externalTexture70}],
});
let pipeline111 = device2.createRenderPipeline({
  label: '\u91bd\u8fac\u060f\u0957\uf6b0\u05cd\u{1fd89}\ufbf6\u0d46\u9cf5',
  layout: pipelineLayout9,
  multisample: {count: 4, mask: 0x7fe795ed},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'dst-alpha'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'src-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one', dstFactor: 'one-minus-constant'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'constant'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA,
}, {format: 'r8sint'}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'dst', dstFactor: 'constant'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 1304, stepMode: 'instance', attributes: []},
      {arrayStride: 468, attributes: []},
      {arrayStride: 100, attributes: []},
      {arrayStride: 104, stepMode: 'instance', attributes: []},
      {arrayStride: 520, stepMode: 'instance', attributes: []},
      {arrayStride: 616, attributes: []},
      {arrayStride: 76, stepMode: 'instance', attributes: []},
      {
        arrayStride: 624,
        attributes: [
          {format: 'uint8x2', offset: 76, shaderLocation: 13},
          {format: 'float32x4', offset: 12, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'back', unclippedDepth: true},
});
let videoFrame14 = new VideoFrame(imageBitmap14, {timestamp: 0});
let bindGroup49 = device2.createBindGroup({
  label: '\u{1faa3}\ucad8',
  layout: bindGroupLayout34,
  entries: [{binding: 786, resource: externalTexture68}],
});
let commandBuffer34 = commandEncoder128.finish({label: '\uc6c5\udcba\u61f6\u0e93\u{1fa14}\u0fae\u0415\u0cb4\u{1f91b}'});
let texture87 = device2.createTexture({
  size: [180, 1, 1],
  mipLevelCount: 6,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32sint', 'rg32sint'],
});
let textureView157 = texture86.createView({
  label: '\u5109\u{1fb6f}\u{1ffe4}\u1b0e\u{1fdd9}\u0284\u09e2',
  dimension: '3d',
  aspect: 'all',
  baseMipLevel: 1,
});
let renderBundleEncoder64 = device2.createRenderBundleEncoder({
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder64.setBindGroup(3, bindGroup47, new Uint32Array(2192), 1349, 0);
} catch {}
try {
renderBundleEncoder57.setVertexBuffer(4_294_967_295, undefined, 172_590_004, 331_668_223);
} catch {}
try {
gpuCanvasContext13.unconfigure();
} catch {}
let imageBitmap17 = await createImageBitmap(video16);
let bindGroup50 = device2.createBindGroup({
  label: '\u98da\uef8a\u{1f7cf}\uc9d8\u04a8\u8993\ubc33\u3b5b\uab91\u03b4\u0e26',
  layout: bindGroupLayout34,
  entries: [{binding: 786, resource: externalTexture68}],
});
let texture88 = device2.createTexture({
  label: '\u172b\u{1f814}\u{1ff4c}\u5d94\u089b\u50e1\u200e',
  size: {width: 180, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['r8unorm', 'r8unorm'],
});
let computePassEncoder74 = commandEncoder136.beginComputePass();
let renderBundleEncoder65 = device2.createRenderBundleEncoder({
  label: '\u{1fc07}\ub442',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
});
try {
renderBundleEncoder57.setVertexBuffer(4_294_967_295, undefined, 101_338_833);
} catch {}
try {
commandEncoder130.copyBufferToTexture({
  /* bytesInLastRow: 236 widthInBlocks: 59 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 32624 */
  offset: 32388,
  buffer: buffer23,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 59, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 30, height: 3, depthOrArrayLayers: 88}
*/
{
  source: imageBitmap17,
  origin: { x: 2, y: 3 },
  flipY: false,
}, {
  texture: texture82,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 17},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline112 = await device2.createComputePipelineAsync({
  label: '\u1846\u0cc0\uc576\u08e8\u{1fd2c}\u4e6b\u93f8\u46d9\u0ebe\u825e',
  layout: pipelineLayout9,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let canvas23 = document.createElement('canvas');
let commandEncoder139 = device1.createCommandEncoder({label: '\u{1ff5f}\uc33c\u0dc3\ub103\u044d'});
let textureView158 = texture49.createView({baseMipLevel: 2});
try {
computePassEncoder47.setPipeline(pipeline63);
} catch {}
try {
renderBundleEncoder34.setBindGroup(3, bindGroup36);
} catch {}
try {
renderBundleEncoder63.setVertexBuffer(5, buffer13, 0);
} catch {}
try {
commandEncoder76.copyTextureToBuffer({
  texture: texture68,
  mipLevel: 1,
  origin: {x: 15, y: 2, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 148 widthInBlocks: 37 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 8100 */
  offset: 784,
  bytesPerRow: 512,
  buffer: buffer13,
}, {width: 37, height: 15, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder135.clearBuffer(buffer12, 6268, 236);
} catch {}
try {
commandEncoder139.resolveQuerySet(querySet29, 303, 433, buffer15, 512);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture78,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer1, /* required buffer size: 1_258 */
{offset: 454, bytesPerRow: 201}, {width: 0, height: 5, depthOrArrayLayers: 1});
} catch {}
try {
  await promise41;
} catch {}
let commandEncoder140 = device0.createCommandEncoder({});
let textureView159 = texture4.createView({
  label: '\u889b\u04eb\u4134\u{1ff50}\ua51c\uf14d\u{1f8bb}\u6de2\u{1fe84}',
  dimension: '2d',
  aspect: 'all',
  baseMipLevel: 5,
  baseArrayLayer: 119,
});
let externalTexture74 = device0.importExternalTexture({
  label: '\u229b\u090e\u{1f801}\ud1f0\u048f\u{1fddf}\u06a7\u0f28\u7c2b\u97d9\u0014',
  source: videoFrame10,
  colorSpace: 'display-p3',
});
try {
renderPassEncoder7.setScissorRect(43, 77, 42, 38);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer7, 'uint32', 14_560, 606);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(0, buffer9);
} catch {}
try {
renderBundleEncoder13.setBindGroup(2, bindGroup2, []);
} catch {}
try {
renderBundleEncoder29.draw(240, 160, 231, 59_621_127);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer5, 54_752);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer0, 48_044);
} catch {}
try {
commandEncoder107.clearBuffer(buffer3, 79988, 7024);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer3), /* required buffer size: 564 */
{offset: 564, bytesPerRow: 655, rowsPerImage: 58}, {width: 129, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext13.unconfigure();
} catch {}
canvas3.width = 138;
let canvas24 = document.createElement('canvas');
let commandEncoder141 = device2.createCommandEncoder();
let querySet66 = device2.createQuerySet({label: '\u0d85\u95b3\uf5a8\u0009\u92d5\u0739\u079b', type: 'occlusion', count: 3077});
try {
renderBundleEncoder65.setBindGroup(3, bindGroup47, new Uint32Array(1194), 1182, 0);
} catch {}
try {
commandEncoder130.copyTextureToTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture79,
  mipLevel: 0,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
},
{width: 72, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8ClampedArray(arrayBuffer4), /* required buffer size: 277_807 */
{offset: 751, bytesPerRow: 296, rowsPerImage: 39}, {width: 84, height: 0, depthOrArrayLayers: 25});
} catch {}
let pipeline113 = await device2.createComputePipelineAsync({
  label: '\u{1fc77}\u3f73\ua256',
  layout: pipelineLayout9,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let gpuCanvasContext15 = canvas23.getContext('webgpu');
let textureView160 = texture23.createView({label: '\u058a\u5fc0\u{1fa47}\udc6f\u0963', aspect: 'all', baseMipLevel: 1});
try {
renderPassEncoder6.setViewport(35.64, 71.74, 78.03, 15.77, 0.8002, 0.9402);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer10, 320);
} catch {}
try {
commandEncoder20.clearBuffer(buffer16, 9008, 2756);
} catch {}
let img13 = await imageWithData(120, 168, '#2f9bcfe5', '#e1ae2850');
let bindGroup51 = device2.createBindGroup({
  label: '\u26a0\u6960\u4083\u1b48\u5e1a\u02ad\u0511\uc2f2\u03e1',
  layout: bindGroupLayout34,
  entries: [{binding: 786, resource: externalTexture70}],
});
let textureView161 = texture88.createView({label: '\u{1fb65}\ub450', dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder73.setBindGroup(0, bindGroup50);
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
let bindGroupLayout38 = device2.createBindGroupLayout({
  label: '\uc384\u0e99\u0cc8\u{1f62e}\u86af',
  entries: [
    {
      binding: 547,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 380,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
  ],
});
let sampler60 = device2.createSampler({
  label: '\u{1f9d1}\ubcc1\u{1f838}',
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 2.746,
  lodMaxClamp: 45.00,
});
try {
renderBundleEncoder64.setBindGroup(3, bindGroup47);
} catch {}
try {
renderBundleEncoder65.setVertexBuffer(4_294_967_295, undefined, 0, 316_738_175);
} catch {}
try {
commandEncoder130.clearBuffer(buffer23, 439944, 6708);
} catch {}
try {
commandEncoder130.resolveQuerySet(querySet65, 4, 4, buffer23, 41984);
} catch {}
let promise42 = device2.queue.onSubmittedWorkDone();
let pipeline114 = await promise40;
let commandEncoder142 = device2.createCommandEncoder({label: '\u05ef\u09cd\u{1f6fb}'});
let computePassEncoder75 = commandEncoder141.beginComputePass();
let renderBundleEncoder66 = device2.createRenderBundleEncoder({
  label: '\u51a8\u5664\u{1f872}\u092b\u376a\u{1fbb3}\u{1fd34}\u124b\ue917',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: false,
});
let renderBundle88 = renderBundleEncoder65.finish({label: '\u0ef1\ub0bf\ud969\u00b3\u924e\u9455'});
try {
computePassEncoder73.setPipeline(pipeline105);
} catch {}
try {
renderBundleEncoder57.setVertexBuffer(1, undefined, 86_828_400, 316_610_951);
} catch {}
try {
commandEncoder130.copyBufferToBuffer(buffer22, 88664, buffer23, 456632, 62368);
} catch {}
try {
commandEncoder130.resolveQuerySet(querySet66, 310, 765, buffer23, 44288);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 30, height: 3, depthOrArrayLayers: 88}
*/
{
  source: videoFrame14,
  origin: { x: 1, y: 4 },
  flipY: false,
}, {
  texture: texture82,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 18},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext16 = canvas24.getContext('webgpu');
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
document.body.prepend(canvas2);
try {
offscreenCanvas9.getContext('webgl');
} catch {}
let bindGroupLayout39 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 483,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 360,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 733,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false },
    },
  ],
});
let commandEncoder143 = device0.createCommandEncoder({label: '\u{1ffcf}\u9c36\u6a55\u07cc\u0a98'});
let texture89 = device0.createTexture({
  label: '\u031f\u00ef\u87a1',
  size: [1320, 960, 324],
  mipLevelCount: 1,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg16uint', 'rg16uint', 'rg16uint'],
});
let textureView162 = texture80.createView({
  label: '\u{1f69f}\u{1f941}\u1481\u02a0\ue024\u0491\u{1f72d}\u1027\ue2ff\u015e',
  dimension: '1d',
  mipLevelCount: 1,
});
let renderPassEncoder8 = commandEncoder40.beginRenderPass({
  label: '\u620e\ud6e8\u595a\u{1fe0b}\u{1fe94}\uebac\u0080\u19cb\u{1fccb}\u9771',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: 714.3, g: 731.4, b: -203.0, a: -977.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 610140675,
});
let externalTexture75 = device0.importExternalTexture({label: '\ub72e\u{1fea4}\u40ee\u{1fc71}', source: video7, colorSpace: 'srgb'});
try {
computePassEncoder29.setBindGroup(1, bindGroup19, new Uint32Array(3000), 1090, 0);
} catch {}
try {
computePassEncoder27.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup42, new Uint32Array(8424), 6596, 0);
} catch {}
try {
renderPassEncoder6.setViewport(125.3, 83.93, 17.55, 12.29, 0.7317, 0.8431);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer7, 'uint32', 24_376, 3_393);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer7, 0);
} catch {}
try {
commandEncoder107.copyBufferToBuffer(buffer3, 55380, buffer9, 296624, 36844);
} catch {}
try {
device0.queue.writeBuffer(buffer6, 1516, new DataView(new ArrayBuffer(27944)), 25082, 896);
} catch {}
let imageData22 = new ImageData(80, 240);
let bindGroupLayout40 = device1.createBindGroupLayout({
  label: '\u3d28\u9567\u95ac\u0ec2\u1159\u0540\u567f\ufc75\u{1fce0}\u73bc\ud524',
  entries: [
    {
      binding: 868,
      visibility: 0,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let bindGroup52 = device1.createBindGroup({
  label: '\u{1fcf8}\u87a0\u{1fead}\u057d',
  layout: bindGroupLayout27,
  entries: [
    {binding: 180, resource: sampler42},
    {binding: 406, resource: sampler41},
    {binding: 354, resource: {buffer: buffer13, offset: 180736}},
  ],
});
let commandBuffer35 = commandEncoder119.finish({label: '\u526a\udf1f\u9ef3\u0533\u0781\u48ba'});
let sampler61 = device1.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 22.37,
  lodMaxClamp: 65.37,
  maxAnisotropy: 3,
});
try {
renderBundleEncoder52.setBindGroup(0, bindGroup41, new Uint32Array(6052), 3187, 0);
} catch {}
try {
commandEncoder126.resolveQuerySet(querySet43, 1029, 207, buffer15, 3584);
} catch {}
try {
device1.queue.submit([]);
} catch {}
let pipeline115 = device1.createComputePipeline({
  label: '\ub331\u2fef\u0894\uaf19\u{1fefa}\u6afb',
  layout: pipelineLayout7,
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let bindGroupLayout41 = device2.createBindGroupLayout({
  entries: [
    {
      binding: 385,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 552,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 473,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' },
    },
  ],
});
let querySet67 = device2.createQuerySet({
  label: '\ud50b\u90aa\u7327\u0f0d\u3d0e\u55a3\u103f\u5b93\u1057\ufd07\u0473',
  type: 'occlusion',
  count: 1271,
});
let commandBuffer36 = commandEncoder130.finish({label: '\ud926\u{1f7c0}\u3559\uc67d\u0f1a\ub18e\uf862\u1e75\uc548\u2767'});
try {
computePassEncoder73.setPipeline(pipeline105);
} catch {}
let arrayBuffer8 = buffer22.getMappedRange(12184, 76472);
try {
commandEncoder142.copyTextureToBuffer({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 128 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 461488 */
  offset: 560,
  bytesPerRow: 256,
  rowsPerImage: 200,
  buffer: buffer23,
}, {width: 96, height: 12, depthOrArrayLayers: 10});
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
let pipeline116 = await device2.createComputePipelineAsync({
  label: '\u0cae\u0dca\u5bcb\u282f',
  layout: pipelineLayout9,
  compute: {module: shaderModule25, entryPoint: 'compute0'},
});
let promise43 = device2.createRenderPipelineAsync({
  label: '\ua676\u85f3\u45e2\ub950\u{1f9e8}\ud0ce\u7fbb\u16cc\u0939\u5f27',
  layout: pipelineLayout9,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: 0}, {format: 'rgba8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'r8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r8sint'}, {format: 'rg8unorm'}, {
  format: 'rgba8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 0, attributes: []},
      {arrayStride: 256, attributes: []},
      {arrayStride: 320, stepMode: 'vertex', attributes: []},
      {arrayStride: 1060, attributes: []},
      {arrayStride: 212, attributes: []},
      {arrayStride: 92, stepMode: 'instance', attributes: []},
      {arrayStride: 56, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'uint32x4', offset: 136, shaderLocation: 13},
          {format: 'unorm8x2', offset: 138, shaderLocation: 0},
        ],
      },
    ],
  },
});
let textureView163 = texture46.createView({dimension: '2d', baseMipLevel: 3, mipLevelCount: 1, baseArrayLayer: 70});
let renderBundle89 = renderBundleEncoder54.finish();
try {
commandEncoder135.pushDebugGroup('\u0bd9');
} catch {}
let pipeline117 = await device1.createRenderPipelineAsync({
  label: '\u8ed3\u880b\u0379\u{1fe9a}\u5d9e\u0d4b\u00eb',
  layout: pipelineLayout5,
  multisample: {count: 4, mask: 0x2dde58cd},
  fragment: {
  module: shaderModule15,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.RED}, {format: 'r8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r16sint', writeMask: 0}, {
  format: 'rg32sint',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'stencil8',
    stencilFront: {compare: 'less-equal', failOp: 'decrement-wrap', depthFailOp: 'decrement-wrap', passOp: 'invert'},
    stencilBack: {compare: 'never', failOp: 'increment-clamp', depthFailOp: 'decrement-wrap', passOp: 'increment-wrap'},
    stencilReadMask: 2540662515,
    stencilWriteMask: 149554690,
    depthBias: -371330356,
  },
  vertex: {
    module: shaderModule15,
    buffers: [
      {arrayStride: 152, attributes: [{format: 'uint32x3', offset: 8, shaderLocation: 14}]},
      {
        arrayStride: 840,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint8x4', offset: 224, shaderLocation: 6},
          {format: 'unorm8x4', offset: 4, shaderLocation: 7},
        ],
      },
      {arrayStride: 96, attributes: [{format: 'sint32', offset: 4, shaderLocation: 10}]},
      {arrayStride: 172, stepMode: 'instance', attributes: []},
      {arrayStride: 24, attributes: []},
      {
        arrayStride: 72,
        stepMode: 'vertex',
        attributes: [
          {format: 'unorm16x2', offset: 0, shaderLocation: 2},
          {format: 'uint32x2', offset: 8, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 396,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 8, shaderLocation: 13},
          {format: 'unorm16x4', offset: 4, shaderLocation: 4},
          {format: 'float32x3', offset: 20, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 896,
        attributes: [
          {format: 'sint8x2', offset: 56, shaderLocation: 0},
          {format: 'unorm10-10-10-2', offset: 40, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 100, shaderLocation: 11},
          {format: 'snorm8x2', offset: 252, shaderLocation: 12},
          {format: 'float16x4', offset: 204, shaderLocation: 1},
          {format: 'unorm8x2', offset: 6, shaderLocation: 5},
          {format: 'unorm16x4', offset: 76, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'back'},
});
let videoFrame15 = new VideoFrame(canvas9, {timestamp: 0});
let querySet68 = device2.createQuerySet({type: 'occlusion', count: 2877});
let computePassEncoder76 = commandEncoder142.beginComputePass({});
try {
computePassEncoder73.setBindGroup(1, bindGroup50, new Uint32Array(5884), 3416, 0);
} catch {}
try {
computePassEncoder76.setPipeline(pipeline112);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
renderBundleEncoder57.insertDebugMarker('\u7356');
} catch {}
let bindGroupLayout42 = device2.createBindGroupLayout({
  label: '\ub7da\u{1fdb6}\ue6f5',
  entries: [
    {
      binding: 316,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32uint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 394,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let pipelineLayout11 = device2.createPipelineLayout({
  label: '\ufe11\u0104\u1b3a\u07c8\u37c8\u{1f684}\u{1fad9}',
  bindGroupLayouts: [bindGroupLayout34, bindGroupLayout38],
});
let commandEncoder144 = device2.createCommandEncoder({label: '\ub056\u0a83'});
let commandBuffer37 = commandEncoder144.finish({label: '\ud693\u0258\u{1fe80}\u1027\u021a\u012f\ufbc1\u{1f657}\u0caf\u{1fc3e}\u1882'});
try {
computePassEncoder75.setBindGroup(2, bindGroup51, []);
} catch {}
try {
computePassEncoder73.setPipeline(pipeline116);
} catch {}
try {
renderBundleEncoder64.setIndexBuffer(buffer23, 'uint32', 92_664, 88_708);
} catch {}
let pipeline118 = device2.createComputePipeline({
  label: '\u9f04\u0563\u5c84',
  layout: pipelineLayout11,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let video20 = await videoWithData();
let videoFrame16 = new VideoFrame(videoFrame14, {timestamp: 0});
let buffer24 = device0.createBuffer({
  label: '\u{1fdda}\u9687\ua0ac\ucd18\u03fc\u1d6d\ue4be\u0ba5\u3d16\ud1b9',
  size: 492935,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let commandEncoder145 = device0.createCommandEncoder({label: '\uc418\u9932\u030b\u53d7\u08cb\u{1ff6e}\ufbe8\u02c6'});
let querySet69 = device0.createQuerySet({label: '\u0588\u5c10\u6230\u06d5\u1905\u{1faf2}\u3b0e', type: 'occlusion', count: 1222});
let texture90 = device0.createTexture({
  size: {width: 165, height: 120, depthOrArrayLayers: 124},
  mipLevelCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder67 = device0.createRenderBundleEncoder({
  label: '\u8371\u301e\u0d81\ud9ce\u0b55\u3779\u44aa\ub5b1\u{1f7a5}\u502b',
  colorFormats: ['rgba8unorm'],
  sampleCount: 4,
});
let renderBundle90 = renderBundleEncoder62.finish({label: '\ufa26\u06e7\ub169\u{1f66b}\uf4e4'});
let externalTexture76 = device0.importExternalTexture({label: '\ud575\ua964\u04b5\u0638\u068e\u2e91\u085b', source: videoFrame2, colorSpace: 'display-p3'});
try {
renderPassEncoder7.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder7.setBlendConstant({ r: 556.3, g: 153.5, b: 934.0, a: -930.0, });
} catch {}
try {
renderPassEncoder7.setScissorRect(142, 34, 17, 30);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer7, 'uint32', 19_280, 276);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.drawIndexed(1_945, 244, 6_289, -2_137_461_974, 658_587_654);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer24, 102_788);
} catch {}
let arrayBuffer9 = buffer14.getMappedRange(32840, 84);
try {
buffer1.unmap();
} catch {}
try {
commandEncoder8.clearBuffer(buffer10);
} catch {}
let offscreenCanvas10 = new OffscreenCanvas(143, 847);
let video21 = await videoWithData();
let commandEncoder146 = device1.createCommandEncoder();
try {
renderBundleEncoder59.setVertexBuffer(7, buffer13, 63_020);
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
try {
commandEncoder124.copyBufferToBuffer(buffer17, 3680, buffer12, 3456, 1456);
} catch {}
try {
commandEncoder146.copyTextureToTexture({
  texture: texture42,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture42,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
},
{width: 5, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder133.resolveQuerySet(querySet30, 166, 48, buffer15, 9984);
} catch {}
let pipeline119 = await promise35;
let pipeline120 = await device1.createRenderPipelineAsync({
  label: '\ueab3\u0faf',
  layout: pipelineLayout7,
  multisample: {mask: 0x2a531a52},
  fragment: {
  module: shaderModule14,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint'}, {format: 'r8uint', writeMask: GPUColorWrite.ALPHA}, {format: 'r16sint', writeMask: 0}, {format: 'rg32sint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule14,
    buffers: [
      {
        arrayStride: 212,
        stepMode: 'vertex',
        attributes: [{format: 'sint32x4', offset: 4, shaderLocation: 6}],
      },
      {
        arrayStride: 624,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x3', offset: 148, shaderLocation: 15},
          {format: 'uint32x2', offset: 308, shaderLocation: 0},
        ],
      },
      {arrayStride: 96, stepMode: 'instance', attributes: []},
      {
        arrayStride: 256,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 40, shaderLocation: 14},
          {format: 'float32x2', offset: 24, shaderLocation: 3},
          {format: 'snorm16x2', offset: 20, shaderLocation: 1},
          {format: 'unorm16x4', offset: 32, shaderLocation: 7},
        ],
      },
      {arrayStride: 508, stepMode: 'instance', attributes: []},
      {
        arrayStride: 764,
        stepMode: 'instance',
        attributes: [{format: 'uint16x2', offset: 0, shaderLocation: 11}],
      },
      {arrayStride: 196, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'float16x2', offset: 348, shaderLocation: 9},
          {format: 'sint32x3', offset: 4, shaderLocation: 2},
          {format: 'float32', offset: 72, shaderLocation: 8},
          {format: 'uint8x4', offset: 84, shaderLocation: 12},
          {format: 'unorm16x2', offset: 320, shaderLocation: 10},
          {format: 'snorm8x4', offset: 60, shaderLocation: 4},
          {format: 'sint16x2', offset: 148, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 44, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front'},
});
let texture91 = device0.createTexture({
  label: '\ub0d2\ubc87\u{1f9d6}\u{1fbec}\u1600\u049c',
  size: {width: 165},
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder77 = commandEncoder137.beginComputePass();
let renderPassEncoder9 = commandEncoder122.beginRenderPass({
  label: '\u039c\u089d\ud980\u{1fee4}\u05f4',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: -293.3, g: 183.2, b: 89.61, a: -82.62, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet3,
  maxDrawCount: 415858065,
});
try {
computePassEncoder69.setBindGroup(2, bindGroup37, new Uint32Array(926), 921, 0);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup3);
} catch {}
try {
renderPassEncoder9.executeBundles([]);
} catch {}
try {
renderPassEncoder9.setViewport(61.47, 88.31, 93.42, 4.254, 0.2599, 0.6725);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline106);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup1, new Uint32Array(4379), 4113, 0);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer10, 14_568);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(0, buffer24, 0, 133_343);
} catch {}
try {
commandEncoder52.copyTextureToTexture({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture14,
  mipLevel: 0,
  origin: {x: 108, y: 0, z: 0},
  aspect: 'all',
},
{width: 107, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder100.resolveQuerySet(querySet62, 89, 638, buffer11, 79872);
} catch {}
try {
device0.queue.submit([commandBuffer26]);
} catch {}
let pipeline121 = device0.createComputePipeline({
  label: '\u01c7\u0501\u008a\u2ee0\u0c07\u{1f67b}\u0e3c\u238f',
  layout: pipelineLayout3,
  compute: {module: shaderModule6, entryPoint: 'compute0', constants: {}},
});
let pipeline122 = await promise33;
try {
gpuCanvasContext13.unconfigure();
} catch {}
canvas2.width = 466;
let imageData23 = new ImageData(152, 160);
let sampler62 = device1.createSampler({
  label: '\ubc7a\ua027\u0deb\u72e2\u6138\u{1f67a}\u074b\u04c9\ub663',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  compare: 'less',
});
let externalTexture77 = device1.importExternalTexture({label: '\u{1fefd}\u031b\ub0ac\u04e5\u5722\u003f\u{1f6b1}\u7230\u0a94', source: videoFrame4});
try {
renderBundleEncoder52.setVertexBuffer(2, buffer13, 12_440, 14_978);
} catch {}
try {
commandEncoder126.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 724 widthInBlocks: 181 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 11316 */
  offset: 11316,
  buffer: buffer13,
}, {width: 181, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder117.resolveQuerySet(querySet60, 430, 14, buffer15, 256);
} catch {}
try {
computePassEncoder35.insertDebugMarker('\u2bf5');
} catch {}
let video22 = await videoWithData();
try {
canvas22.getContext('webgl');
} catch {}
let bindGroupLayout43 = device1.createBindGroupLayout({label: '\u4e84\u{1ff53}\u09d0\u9ae8\ubca1\uc7e0\u18c1\ua325\u62e7', entries: []});
let textureView164 = texture44.createView({label: '\u81b6\u9cd5\u0592\u010b\u4de8\u0da5\u0271\u4ea3\u08b3\u2395\u039c', baseMipLevel: 2});
let renderBundleEncoder68 = device1.createRenderBundleEncoder({colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint']});
try {
renderBundleEncoder68.setBindGroup(1, bindGroup39, new Uint32Array(9533), 8348, 0);
} catch {}
try {
commandEncoder135.popDebugGroup();
} catch {}
try {
device1.queue.writeBuffer(buffer12, 172, new DataView(new ArrayBuffer(62649)), 17574, 752);
} catch {}
try {
computePassEncoder63.setBindGroup(3, bindGroup42, new Uint32Array(8718), 8313, 0);
} catch {}
try {
computePassEncoder0.setPipeline(pipeline52);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline67);
} catch {}
let textureView165 = texture78.createView({label: '\u0c44\u05e5\u88c7\u0dc4\u5fc4'});
let renderBundle91 = renderBundleEncoder32.finish({label: '\u65ea\ud278\u{1ff47}\u{1fd30}\u4ba3'});
let sampler63 = device1.createSampler({
  label: '\u0c48\ud822\u1775\u{1fc1e}\uf49e\u{1f959}\ucb6a',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 39.88,
  lodMaxClamp: 69.77,
});
let externalTexture78 = device1.importExternalTexture({label: '\u6385\ub192\u0464\ua1be\u069a\u{1fda5}\u28cc\u9893', source: videoFrame0});
try {
renderBundleEncoder34.setVertexBuffer(2, buffer13, 0, 17_259);
} catch {}
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 716 widthInBlocks: 179 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 18324 */
  offset: 18324,
  buffer: buffer15,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, {width: 179, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet27, 85, 160, buffer15, 13056);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: video7,
  origin: { x: 3, y: 0 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let commandEncoder147 = device2.createCommandEncoder({label: '\u7067\u06cc\u{1fa6a}\ud702\u0cde\u0c69\u0922'});
let renderBundle92 = renderBundleEncoder57.finish({});
try {
renderBundleEncoder64.setBindGroup(3, bindGroup51, new Uint32Array(7327), 5885, 0);
} catch {}
try {
device2.addEventListener('uncapturederror', e => { log('device2.uncapturederror'); log(e); e.label = device2.label; });
} catch {}
try {
commandEncoder147.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2400 */
  offset: 2400,
  buffer: buffer22,
}, {
  texture: texture87,
  mipLevel: 4,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder148 = device0.createCommandEncoder({label: '\u0c81\ubb51'});
let texture92 = device0.createTexture({
  size: {width: 1320, height: 960, depthOrArrayLayers: 124},
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let renderBundle93 = renderBundleEncoder22.finish({label: '\u274d\ueced\ufb75\u4c3e\u{1f857}'});
try {
renderPassEncoder7.setStencilReference(1308);
} catch {}
try {
renderPassEncoder9.setViewport(26.68, 8.975, 123.1, 60.17, 0.6245, 0.7936);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.draw(246, 193, 40, 2_870_802_577);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer24, 6_404);
} catch {}
try {
commandEncoder100.copyTextureToTexture({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 50, y: 46, z: 69},
  aspect: 'all',
},
{
  texture: texture72,
  mipLevel: 0,
  origin: {x: 461, y: 0, z: 0},
  aspect: 'all',
},
{width: 67, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder45.resolveQuerySet(querySet62, 73, 240, buffer16, 256);
} catch {}
try {
gpuCanvasContext8.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.submit([commandBuffer24]);
} catch {}
let gpuCanvasContext17 = canvas21.getContext('webgpu');
let textureView166 = texture41.createView({
  label: '\u15d0\u0f5a\u08f5\u0789\u0b7c\u3114\u{1f92f}\u0d8f\u0ef4\u{1f90c}\u88e0',
  dimension: '2d',
  baseMipLevel: 7,
  baseArrayLayer: 116,
});
let externalTexture79 = device0.importExternalTexture({source: video18});
try {
computePassEncoder1.setBindGroup(0, bindGroup20, new Uint32Array(1731), 1164, 0);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline106);
} catch {}
let offscreenCanvas11 = new OffscreenCanvas(888, 531);
try {
offscreenCanvas10.getContext('bitmaprenderer');
} catch {}
let querySet70 = device2.createQuerySet({label: '\u45fd\u5975\ucb8e\u275f\u0c31\u{1f8ce}\u1299', type: 'occlusion', count: 3310});
let textureView167 = texture85.createView({label: '\u4d83\u6ce3\u52eb\u{1fdaf}\u0747\u09fa\u7560\u{1f8ab}'});
let renderBundleEncoder69 = device2.createRenderBundleEncoder({
  label: '\u2b3e\ubb4b\ud86b\u9e64\u43d6\u0a5d\u2439',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  sampleCount: 1,
  depthReadOnly: true,
});
try {
renderBundleEncoder64.setBindGroup(2, bindGroup49);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 15, height: 1, depthOrArrayLayers: 88}
*/
{
  source: canvas5,
  origin: { x: 24, y: 1 },
  flipY: false,
}, {
  texture: texture82,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder149 = device1.createCommandEncoder({label: '\u2a34\u{1f6cf}\ue241\u4642\u8250'});
let querySet71 = device1.createQuerySet({type: 'occlusion', count: 2454});
let commandBuffer38 = commandEncoder133.finish({label: '\u{1fb25}\u{1f797}\u8e54\u084d\u4f51\ue71c\u{1f773}'});
let textureView168 = texture47.createView({label: '\u{1fa70}\u187a\u8df6\u9a3e\u0d32\ue9d8'});
let renderBundle94 = renderBundleEncoder30.finish({label: '\u06fe\u27ba\u926d\u0a9d\u935e\u07f1\uf47c\u{1f873}\u{1f8c8}'});
let sampler64 = device1.createSampler({
  label: '\u1818\u048b\u727e\u2bc6\u{1ff90}\u{1f7bd}\u3545\u48e7\u9501\uac05',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 1.950,
  maxAnisotropy: 1,
});
try {
renderBundleEncoder45.setBindGroup(3, bindGroup32, new Uint32Array(3033), 791, 0);
} catch {}
try {
renderBundleEncoder68.setVertexBuffer(0, buffer13, 2_280, 738);
} catch {}
try {
commandEncoder146.copyTextureToTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture37,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
},
{width: 108, height: 0, depthOrArrayLayers: 1});
} catch {}
let bindGroup53 = device0.createBindGroup({
  label: '\ub68e\ufe0b\u4b97\u{1fe1a}\u0158\u04ee\u48ae',
  layout: bindGroupLayout25,
  entries: [{binding: 211, resource: externalTexture15}, {binding: 917, resource: sampler1}],
});
let buffer25 = device0.createBuffer({size: 320116, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true});
let commandEncoder150 = device0.createCommandEncoder({label: '\u{1f8e7}\u0755\u{1ff38}\u7d03\ue57c\ub4ba\u8b18\u095a\u3a87\u{1f6c3}\u00b2'});
let renderPassEncoder10 = commandEncoder44.beginRenderPass({
  label: '\u79da\u0aeb\u29be\u0e87\u6290\u{1f660}\u031a\u43c2\u7074\uc5b4',
  colorAttachments: [{view: textureView73, loadOp: 'clear', storeOp: 'discard'}],
  occlusionQuerySet: querySet56,
  maxDrawCount: 505022770,
});
try {
computePassEncoder33.setPipeline(pipeline64);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(167);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle73, renderBundle73, renderBundle73, renderBundle73]);
} catch {}
try {
renderPassEncoder6.setScissorRect(92, 65, 24, 26);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer11, 65_388);
} catch {}
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder120.copyBufferToBuffer(buffer3, 39884, buffer7, 38628, 11428);
} catch {}
try {
commandEncoder87.clearBuffer(buffer1);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: video4,
  origin: { x: 1, y: 6 },
  flipY: false,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData24 = new ImageData(116, 200);
let bindGroup54 = device0.createBindGroup({label: '\u05ff\u{1f92f}', layout: bindGroupLayout2, entries: []});
let commandEncoder151 = device0.createCommandEncoder({label: '\u9ad6\u{1fd71}\u0e57\u5f78\u5b92\uee5a'});
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder9.executeBundles([]);
} catch {}
try {
renderBundleEncoder29.drawIndexed(3_209, 186, 89, -1_870_158_911, 396_399_532);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer10, 4_052);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(2, buffer9);
} catch {}
try {
commandEncoder95.copyBufferToBuffer(buffer9, 220364, buffer10, 31644, 1084);
} catch {}
let bindGroup55 = device1.createBindGroup({
  label: '\u07ce\u7292',
  layout: bindGroupLayout40,
  entries: [{binding: 868, resource: {buffer: buffer18, offset: 128768, size: 44056}}],
});
let commandEncoder152 = device1.createCommandEncoder({label: '\u11b1\u0d0f\u{1f707}\uca88\u0d47'});
let querySet72 = device1.createQuerySet({label: '\u52c9\u4968\u0085\u0e74\u061f', type: 'occlusion', count: 3647});
let renderBundle95 = renderBundleEncoder33.finish({label: '\ub78f\u1fd8\u{1fcbc}\u03d6\u04b5\u0007\u0335\u08cb\u0e4e\u016b'});
let sampler65 = device1.createSampler({
  label: '\u96cc\u5db1\ua4b4\u3828',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 24.20,
  lodMaxClamp: 76.62,
});
try {
commandEncoder126.copyBufferToBuffer(buffer18, 88952, buffer13, 23600, 126744);
} catch {}
try {
commandEncoder152.resolveQuerySet(querySet36, 9, 9, buffer18, 44544);
} catch {}
try {
gpuCanvasContext6.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let promise44 = device1.createComputePipelineAsync({
  label: '\uf557\u056f\u0b9b\uef42\u{1ff47}\ubaae\u{1f897}\u618d\u5bf8\ua4ba',
  layout: pipelineLayout5,
  compute: {module: shaderModule13, entryPoint: 'compute0', constants: {}},
});
try {
  await adapter4.requestAdapterInfo();
} catch {}
let commandEncoder153 = device2.createCommandEncoder({label: '\u0bb9\u8bc3\u{1f8cc}\u9efa'});
let texture93 = device2.createTexture({
  label: '\u6458\u{1fc5c}\u07b7\u0d8f\u05c0\uf5ef\u{1fe7f}\ua27d\u03e3\u0a9c\u{1ff98}',
  size: {width: 180, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView169 = texture88.createView({label: '\u663f\uf35d\u1275\u7b25\u081a\u{1f7cb}', baseMipLevel: 2, mipLevelCount: 2});
let renderBundle96 = renderBundleEncoder66.finish({label: '\u3202\uecb5\u2bc6\u5e09'});
try {
computePassEncoder73.dispatchWorkgroupsIndirect(buffer23, 455828);
} catch {}
try {
renderBundleEncoder69.setBindGroup(1, bindGroup50, new Uint32Array(666), 643, 0);
} catch {}
try {
commandEncoder147.pushDebugGroup('\u{1fcfa}');
} catch {}
try {
device2.queue.submit([commandBuffer34]);
} catch {}
let offscreenCanvas12 = new OffscreenCanvas(611, 566);
let querySet73 = device2.createQuerySet({label: '\u2eaa\ucd0f', type: 'occlusion', count: 3272});
let textureView170 = texture87.createView({
  label: '\u0f70\uf5f8\u7f76\ua813\u42f0\ueeb1\u0164\ue47e\uff75',
  dimension: '2d-array',
  format: 'rg32sint',
  baseMipLevel: 2,
  mipLevelCount: 3,
  arrayLayerCount: 1,
});
let externalTexture80 = device2.importExternalTexture({
  label: '\uf96a\u0a5e\uad8d\u{1f7db}\u0301\u{1f848}\u9dd1\u5df1',
  source: videoFrame8,
  colorSpace: 'srgb',
});
let promise45 = device2.createComputePipelineAsync({layout: pipelineLayout9, compute: {module: shaderModule25, entryPoint: 'compute0'}});
let pipeline123 = device2.createRenderPipeline({
  layout: 'auto',
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA,
}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'zero'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'constant'},
  },
  writeMask: GPUColorWrite.GREEN,
}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'r8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'r8sint', writeMask: GPUColorWrite.ALPHA}, {format: 'rg8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba8sint'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'never',
    stencilFront: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'zero', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'less-equal', failOp: 'increment-wrap', depthFailOp: 'increment-wrap', passOp: 'invert'},
    stencilReadMask: 3977114108,
    stencilWriteMask: 2901307806,
    depthBias: 1638303220,
    depthBiasSlopeScale: 552.8844990398902,
    depthBiasClamp: 834.0195242234774,
  },
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 312, stepMode: 'instance', attributes: []},
      {arrayStride: 1312, stepMode: 'instance', attributes: []},
      {
        arrayStride: 564,
        stepMode: 'vertex',
        attributes: [{format: 'float16x2', offset: 144, shaderLocation: 0}],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 404, attributes: []},
      {arrayStride: 672, attributes: []},
      {arrayStride: 56, stepMode: 'instance', attributes: []},
      {
        arrayStride: 60,
        stepMode: 'instance',
        attributes: [{format: 'uint16x2', offset: 8, shaderLocation: 13}],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw'},
});
try {
  await promise32;
} catch {}
gc();
let offscreenCanvas13 = new OffscreenCanvas(793, 728);
let img14 = await imageWithData(165, 292, '#8d683b0c', '#a6dcaf7f');
let commandEncoder154 = device2.createCommandEncoder();
let textureView171 = texture93.createView({
  label: '\u92cc\ub599\u{1f88b}\u0d24\u58bc\u0ea2\u01f8\u4a68\u{1fd1f}\u09ad\u5006',
  dimension: '2d-array',
  baseMipLevel: 5,
});
let sampler66 = device2.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 85.62,
  lodMaxClamp: 94.70,
  maxAnisotropy: 11,
});
let externalTexture81 = device2.importExternalTexture({
  label: '\u{1fe99}\uf6c9\u8070\u27a2\u68fe\ua68f\uc4e5\u{1fd7a}\ua6dc\u218a',
  source: videoFrame12,
  colorSpace: 'display-p3',
});
try {
buffer23.destroy();
} catch {}
try {
commandEncoder147.copyTextureToTexture({
  texture: texture82,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 10},
  aspect: 'all',
},
{
  texture: texture82,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder153.resolveQuerySet(querySet66, 434, 187, buffer23, 26880);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 90, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData10,
  origin: { x: 3, y: 0 },
  flipY: true,
}, {
  texture: texture93,
  mipLevel: 1,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline124 = device2.createRenderPipeline({
  layout: pipelineLayout9,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'rgba8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba8unorm-srgb'}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'dst-alpha'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL,
}, {format: 'r8sint'}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'dst-alpha', dstFactor: 'one-minus-dst'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule25,
    buffers: [
      {arrayStride: 68, attributes: []},
      {arrayStride: 372, attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 412, stepMode: 'instance', attributes: []},
      {arrayStride: 44, attributes: []},
      {arrayStride: 0, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 16,
        attributes: [
          {format: 'snorm16x2', offset: 0, shaderLocation: 0},
          {format: 'uint16x2', offset: 0, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'front', unclippedDepth: true},
});
let bindGroupLayout44 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 486,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 85,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 253,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let buffer26 = device1.createBuffer({
  label: '\u{1fdad}\u07da\uc0a3\u6a41\uc5cf\u01a4\u2d7f\u91b6\u6bfd\u6881\u1aa0',
  size: 366110,
  usage: GPUBufferUsage.MAP_READ,
});
let externalTexture82 = device1.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'});
try {
commandEncoder152.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5052 */
  offset: 5052,
  buffer: buffer12,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas10,
  origin: { x: 28, y: 6 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
gc();
let shaderModule26 = device1.createShaderModule({
  label: '\u{1f924}\u{1ff84}\u4197\u2658\ud301\u9bd2\u08ed\ud81a\u{1fbfb}\ue209',
  code: `@group(0) @binding(180)
var<storage, read_write> function9: array<u32>;
@group(1) @binding(522)
var<storage, read_write> global7: array<u32>;
@group(1) @binding(959)
var<storage, read_write> function10: array<u32>;

@compute @workgroup_size(2, 1, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S26 {
  @location(1) f0: vec4<f16>,
  @location(7) f1: vec4<u32>,
  @builtin(front_facing) f2: bool,
  @builtin(sample_index) f3: u32
}
struct FragmentOutput0 {
  @location(2) f0: vec4<f32>,
  @location(0) f1: vec4<i32>,
  @location(6) f2: u32,
  @location(7) f3: vec2<i32>,
  @location(1) f4: vec4<i32>
}

@fragment
fn fragment0(@location(8) a0: i32, @location(5) a1: vec3<f16>, a2: S26, @builtin(sample_mask) a3: u32, @builtin(position) a4: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(7) f167: vec4<u32>,
  @location(8) f168: i32,
  @builtin(position) f169: vec4<f32>,
  @location(1) f170: vec4<f16>,
  @location(5) f171: vec3<f16>
}

@vertex
fn vertex0(@location(9) a0: vec2<i32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
});
let externalTexture83 = device1.importExternalTexture({label: '\ua4f3\u0108\u0130', source: videoFrame10, colorSpace: 'display-p3'});
try {
computePassEncoder67.setBindGroup(2, bindGroup25, new Uint32Array(3070), 1111, 0);
} catch {}
try {
computePassEncoder62.setPipeline(pipeline63);
} catch {}
let pipelineLayout12 = device2.createPipelineLayout({label: '\u0996\u4585\ud3a0\u9238\u1392\ue468', bindGroupLayouts: [bindGroupLayout41]});
let texture94 = device2.createTexture({
  label: '\u111c\u{1fd32}\ub65d\u{1fa23}\ua6b3\u5d4f\u{1fdf5}\u4921',
  size: {width: 720, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder78 = commandEncoder154.beginComputePass();
let externalTexture84 = device2.importExternalTexture({label: '\u6d2b\u{1fc2b}\u25df\u{1fe05}\u2f72\u6de8\ue777\u{1f97b}', source: videoFrame12});
try {
renderBundleEncoder69.setBindGroup(0, bindGroup50, []);
} catch {}
try {
renderBundleEncoder69.setIndexBuffer(buffer23, 'uint32', 26_420, 35_096);
} catch {}
try {
commandEncoder153.copyTextureToTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture79,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 144, height: 12, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder147.popDebugGroup();
} catch {}
try {
device2.queue.writeTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer2, /* required buffer size: 298 */
{offset: 298, rowsPerImage: 279}, {width: 20, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline125 = device2.createComputePipeline({
  label: '\u{1fd7f}\ubb52\u{1fbb4}\u{1ff3c}\u24cb\u{1fb8a}\u9aee\u1527\u0948\uaa11\u{1f83f}',
  layout: pipelineLayout12,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let canvas25 = document.createElement('canvas');
let videoFrame17 = new VideoFrame(imageBitmap9, {timestamp: 0});
let commandEncoder155 = device2.createCommandEncoder();
let querySet74 = device2.createQuerySet({label: '\u951c\u0868', type: 'occlusion', count: 1985});
let texture95 = device2.createTexture({
  size: {width: 720, height: 1, depthOrArrayLayers: 54},
  mipLevelCount: 3,
  dimension: '2d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm'],
});
let textureView172 = texture87.createView({label: '\u{1f808}\u42a3\u6128\u985d\u8159\u892c\u{1f874}\u02a6\u3aaa\u0a06\ufe5a', baseMipLevel: 5});
let renderBundleEncoder70 = device2.createRenderBundleEncoder({
  label: '\u0d32\u0598\ue8a4\u0fd3\u842e\u051a\u293a\ud5f7\u7d18\u17ad\u{1fff4}',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
});
try {
renderBundleEncoder64.setVertexBuffer(0, undefined);
} catch {}
try {
device2.pushErrorScope('out-of-memory');
} catch {}
let promise46 = device2.queue.onSubmittedWorkDone();
try {
device2.queue.copyExternalImageToTexture(/*
{width: 11, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame10,
  origin: { x: 69, y: 31 },
  flipY: true,
}, {
  texture: texture93,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline126 = device2.createRenderPipeline({
  label: '\u{1fef4}\u1cc4\u0bdb\u8ca7\ue8a0\ub472\u09f2\ufc68',
  layout: pipelineLayout11,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  targets: [{format: 'bgra8unorm', writeMask: 0}, {format: 'rgba8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba8unorm-srgb'}, {format: 'r8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'r8sint'}, {format: 'rg8unorm'}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'greater', failOp: 'keep', depthFailOp: 'increment-clamp', passOp: 'increment-wrap'},
    stencilBack: {compare: 'equal', failOp: 'increment-clamp', depthFailOp: 'invert', passOp: 'replace'},
    stencilReadMask: 2176532033,
    stencilWriteMask: 3433120236,
    depthBias: 1805154585,
    depthBiasSlopeScale: -36.77314885221289,
    depthBiasClamp: 138.0927631501977,
  },
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 396, attributes: []},
      {arrayStride: 1060, stepMode: 'vertex', attributes: []},
      {arrayStride: 992, attributes: []},
      {arrayStride: 1120, attributes: []},
      {arrayStride: 468, stepMode: 'instance', attributes: []},
      {arrayStride: 592, stepMode: 'instance', attributes: []},
      {arrayStride: 92, stepMode: 'instance', attributes: []},
      {
        arrayStride: 1092,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 120, shaderLocation: 0},
          {format: 'uint8x4', offset: 112, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', unclippedDepth: true},
});
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let pipelineLayout13 = device2.createPipelineLayout({
  label: '\ud51c\ubb6a\uc84e\u5b36\u0f68\u004e\u8604\u0643\uc633\u2925\ubce0',
  bindGroupLayouts: [bindGroupLayout42, bindGroupLayout34, bindGroupLayout38, bindGroupLayout38],
});
let textureView173 = texture88.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 2});
let renderBundleEncoder71 = device2.createRenderBundleEncoder({
  label: '\u7686\u0a6b\u0739\u{1f916}\ub32b\u0a44\uc907\u0469\ue536',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
});
offscreenCanvas2.width = 131;
let bindGroup56 = device2.createBindGroup({layout: bindGroupLayout34, entries: [{binding: 786, resource: externalTexture80}]});
let textureView174 = texture95.createView({
  label: '\u0619\u366f\u0788\u{1f67e}',
  dimension: '2d',
  format: 'rgba8unorm',
  baseMipLevel: 1,
  baseArrayLayer: 21,
});
let renderBundleEncoder72 = device2.createRenderBundleEncoder({
  label: '\u{1f755}\u7e24\u0218\u0b03\u0737',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
});
let renderBundle97 = renderBundleEncoder72.finish({label: '\ufe91\ua4fa'});
try {
renderBundleEncoder71.setBindGroup(3, bindGroup56, []);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
commandEncoder147.copyBufferToBuffer(buffer22, 147632, buffer23, 473996, 28540);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture95,
  mipLevel: 0,
  origin: {x: 172, y: 0, z: 14},
  aspect: 'all',
}, arrayBuffer9, /* required buffer size: 6_100_352 */
{offset: 172, bytesPerRow: 2010, rowsPerImage: 82}, {width: 460, height: 1, depthOrArrayLayers: 38});
} catch {}
let pipeline127 = await promise43;
let texture96 = device1.createTexture({
  label: '\u7214\u8aeb\udcb9\ud0e8\uf3a1\ue67d\u3369\uc139\u0ba9\u903d',
  size: [1100, 12, 48],
  mipLevelCount: 9,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32sint', 'rgba32sint', 'rgba32sint'],
});
let textureView175 = texture46.createView({
  label: '\ue865\u087e\u124b\u86b7\u0233',
  dimension: '2d',
  baseMipLevel: 1,
  mipLevelCount: 2,
  baseArrayLayer: 20,
});
let renderBundleEncoder73 = device1.createRenderBundleEncoder({
  label: '\u483b\ub2f5\u5c98\u0f1e\u92b6\ued25\ub85a\ub87e\u{1f9ee}\uda1f',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
});
let externalTexture85 = device1.importExternalTexture({source: video22});
try {
computePassEncoder31.end();
} catch {}
try {
computePassEncoder47.setPipeline(pipeline92);
} catch {}
try {
commandEncoder124.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 14376 */
  offset: 14376,
  bytesPerRow: 256,
  buffer: buffer13,
}, {width: 8, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder126.resolveQuerySet(querySet50, 148, 1511, buffer15, 5376);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame8,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let img15 = await imageWithData(51, 160, '#41ec98e3', '#3bce1b1b');
let querySet75 = device2.createQuerySet({label: '\u0514\ufbf0\u4ace\u2526\u665a\u{1fd3a}\u0801', type: 'occlusion', count: 1340});
let texture97 = device2.createTexture({
  size: {width: 240, height: 24, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg8unorm', 'rg8unorm'],
});
let textureView176 = texture97.createView({label: '\u6517\ue7d9\u{1fbd7}\u0671\u0b02\u{1f7e6}\ufa04\u384f\u{1f8a8}\u{1f8c8}', mipLevelCount: 1});
let renderBundleEncoder74 = device2.createRenderBundleEncoder({
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
});
try {
computePassEncoder73.dispatchWorkgroups(3, 3, 5);
} catch {}
try {
computePassEncoder76.setPipeline(pipeline125);
} catch {}
try {
commandEncoder153.resolveQuerySet(querySet66, 327, 3, buffer23, 134912);
} catch {}
let offscreenCanvas14 = new OffscreenCanvas(702, 470);
let videoFrame18 = new VideoFrame(canvas23, {timestamp: 0});
let renderBundleEncoder75 = device0.createRenderBundleEncoder({
  label: '\u0c73\ufe0a\u0f75\u105d\u254f\u175e\u0b9b\u9482',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  stencilReadOnly: true,
});
let renderBundle98 = renderBundleEncoder75.finish({label: '\uf35a\u{1f6c1}'});
let externalTexture86 = device0.importExternalTexture({label: '\u0024\ud891\u86bc\uddf3\u{1f9e1}\ub914\u746a', source: video17, colorSpace: 'display-p3'});
try {
renderPassEncoder6.setBindGroup(2, bindGroup38);
} catch {}
try {
renderPassEncoder10.setVertexBuffer(7, buffer7, 8_396);
} catch {}
try {
renderBundleEncoder41.setPipeline(pipeline13);
} catch {}
let arrayBuffer10 = buffer20.getMappedRange(98584, 1388);
try {
commandEncoder118.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 121480 */
  offset: 6276,
  bytesPerRow: 256,
  rowsPerImage: 45,
  buffer: buffer5,
}, {
  texture: texture27,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 1, depthOrArrayLayers: 11});
} catch {}
try {
commandEncoder87.clearBuffer(buffer16, 9372, 52);
} catch {}
try {
commandEncoder109.resolveQuerySet(querySet6, 182, 13, buffer1, 17920);
} catch {}
try {
gpuCanvasContext17.unconfigure();
} catch {}
let texture98 = device0.createTexture({
  label: '\u0252\ua302',
  size: {width: 1320, height: 960, depthOrArrayLayers: 124},
  mipLevelCount: 4,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC,
});
let textureView177 = texture22.createView({dimension: '2d', baseMipLevel: 7, mipLevelCount: 3, baseArrayLayer: 67});
let computePassEncoder79 = commandEncoder57.beginComputePass({label: '\u{1fa43}\u0030\u95f0\u{1fc1b}'});
let externalTexture87 = device0.importExternalTexture({label: '\ucf5d\u9faf\ubeb9\uac4c', source: video2});
try {
computePassEncoder26.dispatchWorkgroups(1);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup42, new Uint32Array(7549), 2653, 0);
} catch {}
try {
renderPassEncoder6.setViewport(21.05, 41.51, 32.30, 15.41, 0.5864, 0.8865);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline106);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(7, buffer5, 0, 24_673);
} catch {}
try {
renderBundleEncoder46.setBindGroup(1, bindGroup34);
} catch {}
try {
renderBundleEncoder29.draw(66, 104, 40, 383_787_330);
} catch {}
let promise47 = device0.popErrorScope();
try {
renderBundleEncoder36.insertDebugMarker('\u{1f753}');
} catch {}
try {
device0.queue.submit([commandBuffer32]);
} catch {}
let pipeline128 = await promise31;
let canvas26 = document.createElement('canvas');
try {
window.someLabel = externalTexture56.label;
} catch {}
let externalTexture88 = device1.importExternalTexture({label: '\u0ef3\u8e01', source: videoFrame12, colorSpace: 'srgb'});
try {
computePassEncoder62.setBindGroup(2, bindGroup25);
} catch {}
try {
commandEncoder139.copyBufferToBuffer(buffer18, 26320, buffer12, 4220, 2252);
} catch {}
let promise48 = device1.queue.onSubmittedWorkDone();
let bindGroupLayout45 = device1.createBindGroupLayout({
  entries: [
    {
      binding: 379,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 424, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 377, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
  ],
});
let bindGroupLayout46 = pipeline63.getBindGroupLayout(2);
let commandEncoder156 = device1.createCommandEncoder({label: '\u2048\u00de'});
let querySet76 = device1.createQuerySet({label: '\u0eec\u0ec4\u8f07\u073e\u8012\u659e\u99b9\u1eb7\u0fb5', type: 'occlusion', count: 425});
let texture99 = gpuCanvasContext2.getCurrentTexture();
let textureView178 = texture42.createView({
  label: '\u0c1e\u{1fb7c}\ub7e8\ud00a\uc765\u0b8e\ue01c\u0fe5\ub16e',
  dimension: '2d',
  aspect: 'depth-only',
  baseMipLevel: 2,
  mipLevelCount: 1,
});
let externalTexture89 = device1.importExternalTexture({label: '\uacae\uc6f5\u014b\uea04\ubab6\u0a8b', source: videoFrame14});
try {
computePassEncoder62.setPipeline(pipeline63);
} catch {}
try {
renderBundleEncoder59.setVertexBuffer(6, buffer12, 88);
} catch {}
try {
  await device1.popErrorScope();
} catch {}
try {
commandEncoder76.copyBufferToBuffer(buffer18, 21740, buffer13, 164060, 2828);
} catch {}
try {
commandEncoder117.clearBuffer(buffer12, 4040, 504);
} catch {}
document.body.prepend(img0);
let querySet77 = device2.createQuerySet({label: '\u070b\u0dfd\u5953\uaa0e\u016b\u{1ff94}\u0582\u{1fcc7}\u05e4', type: 'occlusion', count: 592});
try {
renderBundleEncoder71.setBindGroup(0, bindGroup47, new Uint32Array(2770), 1023, 0);
} catch {}
try {
renderBundleEncoder70.setIndexBuffer(buffer23, 'uint16', 59_672, 15_693);
} catch {}
try {
commandEncoder153.resolveQuerySet(querySet73, 979, 531, buffer23, 126976);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture97,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(arrayBuffer9), /* required buffer size: 754 */
{offset: 330, bytesPerRow: 248}, {width: 88, height: 2, depthOrArrayLayers: 1});
} catch {}
let pipeline129 = await device2.createComputePipelineAsync({
  label: '\u077c\u{1fb0f}\u0844\ua558\u0714\u0657\u1d79\u4709\ud5cd\u0bfd\u{1fb19}',
  layout: pipelineLayout9,
  compute: {module: shaderModule25, entryPoint: 'compute0'},
});
let adapter5 = await navigator.gpu.requestAdapter({});
let imageBitmap18 = await createImageBitmap(videoFrame0);
try {
canvas25.getContext('webgl');
} catch {}
try {
bindGroup56.label = '\u03d4\uc6da\ufe86\u0bd3\u0932\u{1ff13}\u{1fde0}\uf5a1\u94dd\u0c32';
} catch {}
let textureView179 = texture82.createView({label: '\u056e\u02cb\uca95\u53d4\ue8c1', dimension: '2d', baseArrayLayer: 29});
let computePassEncoder80 = commandEncoder155.beginComputePass();
let pipeline130 = device2.createComputePipeline({
  label: '\u5ea9\u{1f808}\u{1faa9}\udacc\uf279\u0509\u1eeb',
  layout: pipelineLayout11,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
try {
gpuCanvasContext6.unconfigure();
} catch {}
let commandEncoder157 = device1.createCommandEncoder({label: '\ub418\u{1f8ef}\uc08a\u0d7b\u{1f787}\u029c\u40af\uba12\u0818'});
let computePassEncoder81 = commandEncoder152.beginComputePass();
let renderBundle99 = renderBundleEncoder45.finish();
try {
computePassEncoder37.setBindGroup(3, bindGroup33);
} catch {}
try {
  await buffer26.mapAsync(GPUMapMode.READ, 249744, 53548);
} catch {}
try {
commandEncoder156.clearBuffer(buffer12, 6212, 224);
} catch {}
try {
gpuCanvasContext12.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline131 = device1.createRenderPipeline({
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule24,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba8sint', writeMask: 0}, {format: 'rg16uint', writeMask: GPUColorWrite.ALL}, {format: 'rg32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule24,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 888, stepMode: 'instance', attributes: []},
      {arrayStride: 204, attributes: []},
      {arrayStride: 928, attributes: []},
      {arrayStride: 1244, attributes: []},
      {arrayStride: 88, attributes: [{format: 'uint32x4', offset: 0, shaderLocation: 1}]},
      {
        arrayStride: 176,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 20, shaderLocation: 2},
          {format: 'sint8x4', offset: 16, shaderLocation: 10},
        ],
      },
      {arrayStride: 24, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 244,
        attributes: [
          {format: 'sint32x4', offset: 40, shaderLocation: 12},
          {format: 'uint8x4', offset: 8, shaderLocation: 14},
          {format: 'unorm8x2', offset: 16, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw'},
});
let offscreenCanvas15 = new OffscreenCanvas(519, 337);
let pipelineLayout14 = device2.createPipelineLayout({bindGroupLayouts: [bindGroupLayout34, bindGroupLayout41]});
let renderBundle100 = renderBundleEncoder71.finish({label: '\u0f47\u108b\u44dc\u3aa9\ue3c6'});
try {
computePassEncoder80.setBindGroup(2, bindGroup48);
} catch {}
try {
renderBundleEncoder69.setBindGroup(3, bindGroup47);
} catch {}
try {
renderBundleEncoder64.setVertexBuffer(4_294_967_295, undefined, 335_478_951, 112_038_628);
} catch {}
try {
commandEncoder153.copyBufferToTexture({
  /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 12928 */
  offset: 12840,
  buffer: buffer22,
}, {
  texture: texture87,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 11, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder153.clearBuffer(buffer23, 194288, 250020);
} catch {}
try {
commandEncoder153.resolveQuerySet(querySet67, 325, 375, buffer23, 22784);
} catch {}
let img16 = await imageWithData(272, 295, '#37a848a3', '#e0deef0b');
try {
offscreenCanvas13.getContext('webgl2');
} catch {}
let buffer27 = device2.createBuffer({label: '\u{1fffd}\u{1f970}', size: 91186, usage: GPUBufferUsage.MAP_WRITE});
let texture100 = gpuCanvasContext12.getCurrentTexture();
let textureView180 = texture93.createView({
  label: '\ua136\u{1fbce}\ufd42\ua01f\u{1f723}\ud4e4\u{1f9dc}\u0acd\u{1fc4e}',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 0,
});
try {
computePassEncoder80.setBindGroup(1, bindGroup48, new Uint32Array(6560), 5001, 0);
} catch {}
try {
computePassEncoder75.setPipeline(pipeline118);
} catch {}
let commandEncoder158 = device2.createCommandEncoder({label: '\u004c\ud5e6\u7888\u0a28\u0760\uf367\u0588\u6863\uf361\u9819\u0d99'});
let textureView181 = texture86.createView({label: '\u{1fae7}\u044e\u021a\uca0f\u0df3\u0c25\u0176\u4530\u183f\u0073', format: 'rgba8unorm-srgb'});
try {
  await buffer27.mapAsync(GPUMapMode.WRITE, 82584, 6336);
} catch {}
try {
commandEncoder153.copyBufferToBuffer(buffer22, 9604, buffer23, 338840, 14652);
} catch {}
try {
commandEncoder153.clearBuffer(buffer23, 407096, 84212);
} catch {}
try {
commandEncoder153.resolveQuerySet(querySet73, 805, 423, buffer23, 126720);
} catch {}
let promise49 = device2.createRenderPipelineAsync({
  label: '\u0a1b\u{1f8a0}\u{1feeb}',
  layout: pipelineLayout11,
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba8unorm'}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.RED}, {format: 'r8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one', dstFactor: 'constant'},
    alpha: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'zero'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8sint'}],
},
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 1232, stepMode: 'instance', attributes: []},
      {arrayStride: 1936, stepMode: 'vertex', attributes: []},
      {arrayStride: 592, stepMode: 'instance', attributes: []},
      {arrayStride: 24, stepMode: 'instance', attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 404, attributes: []},
      {arrayStride: 184, stepMode: 'instance', attributes: []},
      {
        arrayStride: 192,
        attributes: [
          {format: 'uint8x2', offset: 40, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 20, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'ccw'},
});
try {
gpuCanvasContext13.unconfigure();
} catch {}
let imageData25 = new ImageData(12, 220);
let commandEncoder159 = device2.createCommandEncoder({});
let querySet78 = device2.createQuerySet({label: '\u5edb\u84de\ufe8b\u{1fbe4}\ud91b\u{1f9aa}\u{1fe37}', type: 'occlusion', count: 2790});
let textureView182 = texture82.createView({label: '\u049c\u00c9\u044b', dimension: '2d', baseMipLevel: 1, baseArrayLayer: 67});
let computePassEncoder82 = commandEncoder147.beginComputePass({});
let renderBundleEncoder76 = device2.createRenderBundleEncoder({
  label: '\u{1fbc9}\u{1f771}\u8539',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  stencilReadOnly: true,
});
let externalTexture90 = device2.importExternalTexture({label: '\ufac6\u{1f61e}\u3cde', source: videoFrame13, colorSpace: 'srgb'});
try {
computePassEncoder76.setBindGroup(0, bindGroup49, new Uint32Array(6719), 1830, 0);
} catch {}
try {
commandEncoder153.copyTextureToBuffer({
  texture: texture94,
  mipLevel: 2,
  origin: {x: 47, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 40 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 16108 */
  offset: 16068,
  buffer: buffer23,
}, {width: 20, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder158.copyTextureToTexture({
  texture: texture82,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
},
{
  texture: texture82,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 27, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder158.clearBuffer(buffer23, 156180, 62504);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 30, height: 3, depthOrArrayLayers: 88}
*/
{
  source: imageData15,
  origin: { x: 22, y: 21 },
  flipY: true,
}, {
  texture: texture82,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 15, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise47;
} catch {}
let imageData26 = new ImageData(184, 236);
let commandEncoder160 = device0.createCommandEncoder({label: '\u220d\u0c3c\u179c\u1d42\u9200\u{1f859}\u0565'});
let commandBuffer39 = commandEncoder125.finish({label: '\u585d\u{1f946}\u0107'});
let computePassEncoder83 = commandEncoder140.beginComputePass();
let externalTexture91 = device0.importExternalTexture({
  label: '\u0223\u3181\u{1f7d8}\u7339\ufdec\u873e\u02be\u5c39\uf63d',
  source: videoFrame16,
  colorSpace: 'display-p3',
});
try {
computePassEncoder69.setBindGroup(2, bindGroup34);
} catch {}
try {
computePassEncoder33.dispatchWorkgroups(2, 3, 1);
} catch {}
try {
renderPassEncoder6.setBindGroup(0, bindGroup14);
} catch {}
try {
renderPassEncoder7.setBlendConstant({ r: 976.8, g: 549.2, b: -468.9, a: -735.8, });
} catch {}
try {
renderPassEncoder7.setStencilReference(2052);
} catch {}
try {
renderBundleEncoder29.drawIndexed(2_601, 51, 179, 117_152_745, 386_847_580);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 124}
*/
{
  source: img12,
  origin: { x: 58, y: 4 },
  flipY: true,
}, {
  texture: texture81,
  mipLevel: 1,
  origin: {x: 9, y: 2, z: 4},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView183 = texture100.createView({label: '\u011a\u4963\u0ba5\u030d\u9c9f\u024f\u69c8\u{1f97c}\u694b'});
let renderBundle101 = renderBundleEncoder72.finish({label: '\u62dd\u0dbc\u0c7d\ua097\u0696'});
let externalTexture92 = device2.importExternalTexture({label: '\ud455\u267e', source: video2, colorSpace: 'srgb'});
try {
computePassEncoder74.setPipeline(pipeline118);
} catch {}
try {
renderBundleEncoder70.setBindGroup(1, bindGroup49);
} catch {}
try {
device2.queue.submit([commandBuffer37]);
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 240, height: 24, depthOrArrayLayers: 1}
*/
{
  source: imageData7,
  origin: { x: 16, y: 16 },
  flipY: true,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 66, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 26, height: 10, depthOrArrayLayers: 0});
} catch {}
let pipeline132 = device2.createComputePipeline({
  label: '\u{1fe76}\u79aa',
  layout: pipelineLayout9,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55) };
} catch {}
let device3 = await adapter5.requestDevice({
  label: '\u174e\u07ff\u{1fa25}',
  requiredFeatures: [
    'depth-clip-control',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxColorAttachmentBytesPerSample: 32,
    maxTextureDimension1D: 8192,
    maxUniformBufferBindingSize: 81375927,
    maxStorageBufferBindingSize: 198641840,
    maxSamplersPerShaderStage: 16,
  },
});
let imageBitmap19 = await createImageBitmap(imageBitmap14);
let bindGroup57 = device0.createBindGroup({label: '\ucb50\ua338', layout: bindGroupLayout21, entries: []});
let texture101 = device0.createTexture({
  label: '\uc89a\u{1fd88}\u{1fd29}\u3155\u0426\uea09\u04c4\u005b\u4b30\u1fb9\ub6f2',
  size: [330, 240, 1176],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba16float'],
});
let textureView184 = texture57.createView({label: '\u{1ff38}\u0dab', aspect: 'all', format: 'rg8unorm'});
let computePassEncoder84 = commandEncoder106.beginComputePass({label: '\u00a6\u0443\ud547\uf710\u74db\u195b\u1999'});
try {
computePassEncoder7.end();
} catch {}
try {
renderPassEncoder9.end();
} catch {}
try {
renderPassEncoder6.setScissorRect(90, 39, 16, 17);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline106);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture66,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture77,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
},
{width: 2, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeBuffer(buffer10, 3096, new Float32Array(901));
} catch {}
let promise50 = device0.queue.onSubmittedWorkDone();
let offscreenCanvas16 = new OffscreenCanvas(58, 291);
let commandEncoder161 = device3.createCommandEncoder();
let computePassEncoder85 = commandEncoder161.beginComputePass({label: '\u19ea\u8651'});
let gpuCanvasContext18 = offscreenCanvas11.getContext('webgpu');
let textureView185 = texture74.createView({
  label: '\u033d\udf92\uec78\u08d8\u{1f9ad}\u{1ff93}\u31db',
  dimension: '2d-array',
  format: 'rgba8unorm-srgb',
});
let computePassEncoder86 = commandEncoder135.beginComputePass({label: '\u574a\ue33f\u5859\u0d27\u4457\u2d55\u{1f7e9}\ub97e\ue9b8\u8b9b\u7352'});
try {
renderBundleEncoder59.setBindGroup(3, bindGroup41, []);
} catch {}
let promise51 = device1.popErrorScope();
try {
commandEncoder124.copyTextureToTexture({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture42,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
},
{width: 2, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet71, 221, 337, buffer18, 25088);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas5,
  origin: { x: 34, y: 75 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder162 = device2.createCommandEncoder();
let computePassEncoder87 = commandEncoder162.beginComputePass();
let renderBundleEncoder77 = device2.createRenderBundleEncoder({
  label: '\u7593\u8e0f\u2686\u{1f7a4}\u7f5c\u0ef6\u8d67\u{1fa59}',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  sampleCount: 1,
});
try {
commandEncoder159.resolveQuerySet(querySet77, 18, 53, buffer23, 238080);
} catch {}
let bindGroup58 = device0.createBindGroup({
  label: '\u5d09\u16f5\uf221\u05c2\ucaa4\u{1ffb6}\uba71\ud6a4\u0164\u0f2f',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer10, offset: 8448, size: 740}}],
});
let commandEncoder163 = device0.createCommandEncoder();
let querySet79 = device0.createQuerySet({type: 'occlusion', count: 3196});
let textureView186 = texture83.createView({
  label: '\u0482\u365b\u0e46\u50a9\u86b0\uc989\u5ee9\u07cd\u3932\u90ae\u09cd',
  dimension: '2d',
  format: 'rgba16uint',
  baseMipLevel: 1,
  baseArrayLayer: 35,
});
let renderBundle102 = renderBundleEncoder53.finish({label: '\u059b\ue4f5\u{1f6e9}'});
try {
renderPassEncoder8.beginOcclusionQuery(596);
} catch {}
try {
renderPassEncoder8.setViewport(29.07, 57.98, 12.86, 29.24, 0.9837, 0.9881);
} catch {}
try {
renderBundleEncoder29.drawIndexed(560, 24, 1_194, 24_816_989, 192_711_053);
} catch {}
try {
renderBundleEncoder60.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder67.setVertexBuffer(4, buffer6, 0, 8_981);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
}, new DataView(arrayBuffer10), /* required buffer size: 1_379_421 */
{offset: 81, bytesPerRow: 158, rowsPerImage: 97}, {width: 5, height: 0, depthOrArrayLayers: 91});
} catch {}
let shaderModule27 = device2.createShaderModule({
  label: '\u{1f8b4}\u068d\uca9f\ue4db',
  code: `@group(0) @binding(394)
var<storage, read_write> type6: array<u32>;
@group(1) @binding(786)
var<storage, read_write> global8: array<u32>;
@group(3) @binding(380)
var<storage, read_write> parameter10: array<u32>;
@group(3) @binding(547)
var<storage, read_write> local6: array<u32>;
@group(0) @binding(316)
var<storage, read_write> n10: array<u32>;
@group(2) @binding(380)
var<storage, read_write> function11: array<u32>;
@group(2) @binding(547)
var<storage, read_write> n11: array<u32>;

@compute @workgroup_size(1, 3, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S27 {
  @builtin(front_facing) f0: bool,
  @builtin(position) f1: vec4<f32>,
  @builtin(sample_mask) f2: u32
}
struct FragmentOutput0 {
  @location(4) f0: vec4<i32>,
  @location(1) f1: vec4<f32>,
  @builtin(sample_mask) f2: u32,
  @location(2) f3: vec4<f32>,
  @location(3) f4: vec3<f32>,
  @location(6) f5: vec4<i32>,
  @location(0) f6: vec4<f32>,
  @location(5) f7: vec2<f32>
}

@fragment
fn fragment0(a0: S27) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(9) a0: f32, @location(11) a1: vec3<u32>, @location(2) a2: vec2<u32>, @location(7) a3: vec3<u32>, @location(13) a4: vec2<f16>, @location(0) a5: vec4<u32>, @builtin(instance_index) a6: u32, @location(10) a7: vec4<i32>, @location(14) a8: vec4<u32>, @location(1) a9: vec4<f32>, @location(15) a10: vec4<u32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout47 = device2.createBindGroupLayout({
  label: '\u08d3\uf5c8',
  entries: [
    {
      binding: 84,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {binding: 953, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }},
  ],
});
let commandEncoder164 = device2.createCommandEncoder({label: '\ue351\u387a\u73d5\u{1f868}'});
let texture102 = device2.createTexture({
  label: '\u{1f710}\u{1ff18}',
  size: {width: 1440, height: 1, depthOrArrayLayers: 136},
  mipLevelCount: 11,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['rgba8sint'],
});
let textureView187 = texture95.createView({
  label: '\u{1fed7}\u{1fc42}\u9480\u0173\uf133\u17f8\u9aa1\u61da',
  format: 'rgba8unorm-srgb',
  baseMipLevel: 2,
  baseArrayLayer: 29,
  arrayLayerCount: 18,
});
try {
computePassEncoder78.setBindGroup(1, bindGroup49);
} catch {}
try {
renderBundleEncoder74.setBindGroup(1, bindGroup51, new Uint32Array(7545), 2668, 0);
} catch {}
try {
commandEncoder153.copyBufferToTexture({
  /* bytesInLastRow: 128 widthInBlocks: 32 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 9396 */
  offset: 9396,
  buffer: buffer23,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, {width: 32, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder153.copyTextureToTexture({
  texture: texture95,
  mipLevel: 2,
  origin: {x: 34, y: 0, z: 14},
  aspect: 'all',
},
{
  texture: texture85,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 51, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext14.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 723 */
{offset: 651}, {width: 18, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline133 = device2.createRenderPipeline({
  label: '\u09cd\u0be9\u67b6\u0665',
  layout: pipelineLayout14,
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'rgba8unorm'}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'r8unorm', writeMask: GPUColorWrite.ALPHA}, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-src'},
    alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'zero'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: 0}],
},
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {arrayStride: 880, attributes: []},
      {arrayStride: 576, attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 424, attributes: []},
      {arrayStride: 192, stepMode: 'instance', attributes: []},
      {arrayStride: 16, attributes: []},
      {arrayStride: 904, attributes: []},
      {
        arrayStride: 156,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 8, shaderLocation: 0},
          {format: 'uint8x4', offset: 8, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let imageData27 = new ImageData(132, 60);
try {
adapter4.label = '\uc92f\u01bd\u669e';
} catch {}
let texture103 = device3.createTexture({
  label: '\ud20d\u01d5',
  size: [1450, 5, 73],
  mipLevelCount: 5,
  format: 'astc-10x5-unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['astc-10x5-unorm-srgb', 'astc-10x5-unorm-srgb'],
});
try {
gpuCanvasContext2.configure({
  device: device3,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let shaderModule28 = device2.createShaderModule({
  code: `@group(0) @binding(786)
var<storage, read_write> parameter11: array<u32>;

@compute @workgroup_size(4, 1, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(6) f0: vec4<i32>,
  @location(7) f1: vec3<i32>,
  @location(4) f2: vec4<i32>,
  @builtin(sample_mask) f3: u32,
  @location(5) f4: vec2<f32>,
  @location(1) f5: vec4<f32>,
  @location(0) f6: vec4<f32>,
  @location(3) f7: vec2<f32>,
  @location(2) f8: vec4<f32>
}

@fragment
fn fragment0(@location(0) a0: vec4<f32>, @location(9) a1: vec4<i32>, @location(1) a2: vec2<u32>, @location(6) a3: vec4<i32>, @location(4) a4: vec2<f16>, @location(3) a5: f32, @location(12) a6: vec2<f32>, @location(11) a7: vec4<u32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S28 {
  @location(9) f0: f32,
  @location(8) f1: vec3<f32>,
  @location(0) f2: vec3<f32>,
  @builtin(instance_index) f3: u32,
  @location(14) f4: f16,
  @location(4) f5: vec3<f32>,
  @location(7) f6: vec4<f32>,
  @location(2) f7: f16,
  @location(15) f8: vec4<f32>,
  @location(10) f9: vec4<f32>,
  @location(6) f10: f32,
  @location(1) f11: vec4<u32>,
  @location(12) f12: f32,
  @location(13) f13: vec4<f16>,
  @location(11) f14: vec4<u32>,
  @location(3) f15: u32,
  @location(5) f16: vec3<u32>
}
struct VertexOutput0 {
  @location(12) f172: vec2<f32>,
  @location(1) f173: vec2<u32>,
  @builtin(position) f174: vec4<f32>,
  @location(9) f175: vec4<i32>,
  @location(0) f176: vec4<f32>,
  @location(4) f177: vec2<f16>,
  @location(7) f178: vec3<f32>,
  @location(3) f179: f32,
  @location(11) f180: vec4<u32>,
  @location(6) f181: vec4<i32>,
  @location(13) f182: f32
}

@vertex
fn vertex0(a0: S28) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let textureView188 = texture95.createView({
  label: '\u3aec\u00c1\u04bb',
  format: 'rgba8unorm',
  baseMipLevel: 2,
  baseArrayLayer: 17,
  arrayLayerCount: 5,
});
try {
  await buffer22.mapAsync(GPUMapMode.WRITE, 189536);
} catch {}
try {
commandEncoder158.copyTextureToTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture95,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 13, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await promise42;
} catch {}
let imageBitmap20 = await createImageBitmap(videoFrame17);
let imageData28 = new ImageData(136, 36);
let shaderModule29 = device1.createShaderModule({
  label: '\u2185\ua011\u0d9f\u4976\u{1fb37}\uff22\uac3d',
  code: `

@compute @workgroup_size(1, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<i32>,
  @location(5) f1: vec3<u32>,
  @location(1) f2: vec3<u32>,
  @location(2) f3: vec4<i32>,
  @location(6) f4: vec2<f32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S29 {
  @location(12) f0: vec3<f32>
}

@vertex
fn vertex0(a0: S29, @location(11) a1: i32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
try {
commandEncoder76.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2400 */
  offset: 2400,
  buffer: buffer15,
}, {
  texture: texture50,
  mipLevel: 3,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder156.clearBuffer(buffer12, 2776, 2128);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55) };
} catch {}
let offscreenCanvas17 = new OffscreenCanvas(728, 737);
let video23 = await videoWithData();
offscreenCanvas1.width = 731;
let texture104 = device0.createTexture({
  label: '\ud59a\u0581\u08fb\u04ce\u{1fa76}\u062c\ub6c4\ubdc4\u7e4d\u05a4\u0833',
  size: {width: 660, height: 480, depthOrArrayLayers: 124},
  mipLevelCount: 4,
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb'],
});
let renderPassEncoder11 = commandEncoder145.beginRenderPass({
  label: '\uaebf\u08eb\u05d0\u2929\u8546\ud402\u0127\ub118\u02f9',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: 124.7, g: -384.7, b: 814.4, a: 428.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet40,
  maxDrawCount: 422726892,
});
try {
renderPassEncoder11.end();
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(3572);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: -752.1, g: 595.8, b: 906.4, a: 937.3, });
} catch {}
try {
renderPassEncoder8.setStencilReference(2758);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(7, buffer6, 8_832);
} catch {}
try {
renderBundleEncoder25.setBindGroup(1, bindGroup27);
} catch {}
try {
renderBundleEncoder29.draw(29, 305, 16, 52_737_669);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer3, 'uint32', 9_220, 11_186);
} catch {}
try {
commandEncoder102.popDebugGroup();
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) };
} catch {}
let texture105 = device3.createTexture({
  label: '\uadd0\uab63\u0844',
  size: {width: 672, height: 30, depthOrArrayLayers: 78},
  mipLevelCount: 6,
  format: 'astc-12x10-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['astc-12x10-unorm', 'astc-12x10-unorm'],
});
let textureView189 = texture105.createView({
  label: '\u088e\u0e4b',
  format: 'astc-12x10-unorm',
  baseMipLevel: 4,
  mipLevelCount: 1,
  baseArrayLayer: 19,
  arrayLayerCount: 40,
});
let sampler67 = device3.createSampler({
  label: '\u{1f831}\u{1fee0}\ud257',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 9.275,
  lodMaxClamp: 36.34,
  maxAnisotropy: 3,
});
try {
gpuCanvasContext6.configure({
  device: device3,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm', 'bgra8unorm'],
});
} catch {}
let bindGroup59 = device1.createBindGroup({layout: bindGroupLayout46, entries: []});
let commandEncoder165 = device1.createCommandEncoder({});
let querySet80 = device1.createQuerySet({label: '\u0198\u7778\u301b', type: 'occlusion', count: 2079});
let textureView190 = texture96.createView({baseMipLevel: 8});
let renderBundleEncoder78 = device1.createRenderBundleEncoder({
  label: '\u07f7\u08f0',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  sampleCount: 1,
  depthReadOnly: true,
});
let sampler68 = device1.createSampler({
  label: '\u0d5a\u01a8',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 72.42,
  lodMaxClamp: 86.38,
  maxAnisotropy: 19,
});
try {
commandEncoder139.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7154 */
  offset: 7154,
  bytesPerRow: 0,
  rowsPerImage: 247,
  buffer: buffer13,
}, {width: 0, height: 0, depthOrArrayLayers: 5});
} catch {}
let offscreenCanvas18 = new OffscreenCanvas(706, 781);
let computePassEncoder88 = commandEncoder153.beginComputePass({label: '\uac5b\u3326'});
let sampler69 = device2.createSampler({
  label: '\u0a05\u0f9a',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 4.827,
  lodMaxClamp: 94.97,
  maxAnisotropy: 1,
});
try {
renderBundleEncoder70.setPipeline(pipeline133);
} catch {}
try {
commandEncoder159.clearBuffer(buffer23, 456496, 2392);
} catch {}
try {
commandEncoder159.resolveQuerySet(querySet70, 756, 115, buffer23, 93440);
} catch {}
let gpuCanvasContext19 = offscreenCanvas17.getContext('webgpu');
let videoFrame19 = new VideoFrame(img10, {timestamp: 0});
try {
offscreenCanvas12.getContext('webgl');
} catch {}
let bindGroupLayout48 = device3.createBindGroupLayout({label: '\u{1f66a}\u0b6d\uecd1\u0a0e\u9222\u0ddf', entries: []});
let commandEncoder166 = device3.createCommandEncoder({label: '\uc96d\u0e59\uaa17\u04f9'});
let textureView191 = texture103.createView({
  label: '\uf12d\u{1fd2e}\u7d8d',
  format: 'astc-10x5-unorm-srgb',
  baseMipLevel: 3,
  mipLevelCount: 1,
  baseArrayLayer: 4,
  arrayLayerCount: 3,
});
let computePassEncoder89 = commandEncoder166.beginComputePass({label: '\u0b92\u013f'});
let renderBundleEncoder79 = device3.createRenderBundleEncoder({
  label: '\uf6c1\u{1f7f0}\u038e\u3a4b\u0bca\ue13e',
  colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'],
  stencilReadOnly: true,
});
let sampler70 = device3.createSampler({
  label: '\uabb2\u{1f793}\u{1f70d}\u5ec8\ubadb\u{1fb76}\u0ffd\ua1d2\u8136\u0cb6',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 68.56,
  lodMaxClamp: 88.46,
  maxAnisotropy: 17,
});
video13.width = 17;
let bindGroup60 = device1.createBindGroup({
  layout: bindGroupLayout45,
  entries: [
    {binding: 424, resource: externalTexture30},
    {binding: 377, resource: externalTexture30},
    {binding: 379, resource: {buffer: buffer13, offset: 149248, size: 37600}},
  ],
});
let commandEncoder167 = device1.createCommandEncoder({});
let textureView192 = texture56.createView({label: '\u{1fb30}\u05b2\u004a\u36fb\u50f8', baseMipLevel: 3, baseArrayLayer: 26, arrayLayerCount: 84});
let sampler71 = device1.createSampler({
  label: '\ud05a\u87be\u8593\u{1ffa5}\u60fc\uccbd\u0747\uc8e0',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 45.08,
  lodMaxClamp: 59.23,
});
try {
computePassEncoder61.setPipeline(pipeline75);
} catch {}
try {
renderBundleEncoder78.setPipeline(pipeline80);
} catch {}
try {
commandEncoder76.clearBuffer(buffer12, 5708, 348);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture78,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(arrayBuffer4), /* required buffer size: 378 */
{offset: 378, bytesPerRow: 367}, {width: 8, height: 15, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame17,
  origin: { x: 22, y: 35 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
adapter0.label = '\u{1f809}\u3140\u09ec\ua08b\u67d0\u{1f934}';
} catch {}
let sampler72 = device2.createSampler({
  label: '\ufa6e\u04bc\u183e\ue983\u06d0\u{1f867}\u0667\u{1facb}\u8b66\u4b68',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  lodMinClamp: 80.31,
  lodMaxClamp: 88.58,
});
try {
computePassEncoder87.setPipeline(pipeline118);
} catch {}
try {
renderBundleEncoder64.setVertexBuffer(4_294_967_295, undefined);
} catch {}
try {
texture102.destroy();
} catch {}
try {
commandEncoder158.insertDebugMarker('\ue557');
} catch {}
let promise52 = device2.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) };
} catch {}
let shaderModule30 = device1.createShaderModule({
  label: '\u{1fe07}\uc4ff\uffd6\u{1f75a}\u2f80\u4b47\uec34\u026f\u51d5\u5c11\u{1ff5f}',
  code: `@group(3) @binding(959)
var<storage, read_write> field5: array<u32>;
@group(3) @binding(522)
var<storage, read_write> parameter12: array<u32>;

@compute @workgroup_size(3, 1, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(3) f0: vec2<f32>,
  @location(2) f1: vec4<i32>,
  @location(1) f2: vec3<u32>,
  @location(0) f3: vec4<i32>
}

@fragment
fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(sample_index) a1: u32, @builtin(sample_mask) a2: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S30 {
  @location(5) f0: vec4<f32>,
  @location(12) f1: vec2<f32>,
  @location(13) f2: u32,
  @location(14) f3: vec3<f16>,
  @location(8) f4: vec4<f32>,
  @location(2) f5: vec2<f32>,
  @location(0) f6: vec2<i32>
}

@vertex
fn vertex0(@location(15) a0: vec2<u32>, @location(4) a1: i32, @location(6) a2: vec3<f32>, a3: S30, @location(7) a4: vec4<i32>, @builtin(instance_index) a5: u32, @location(1) a6: i32, @location(9) a7: u32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  hints: {},
});
let bindGroup61 = device1.createBindGroup({label: '\u{1fe15}\u0202\u{1fc45}\u0bea\u16bb\ue285\u01e2', layout: bindGroupLayout46, entries: []});
let textureView193 = texture48.createView({
  label: '\u{1f8c7}\u4f34\u0d22\u09e1\u0c40\u093c\u0e1e\u0b31\u6aeb\u{1fa45}\u{1fe28}',
  baseMipLevel: 7,
});
let externalTexture93 = device1.importExternalTexture({label: '\u{1ff4a}\u13e6\u{1fb89}\ua20b\u0d2a\ud308', source: videoFrame10, colorSpace: 'srgb'});
try {
computePassEncoder61.setBindGroup(3, bindGroup33, new Uint32Array(3613), 510, 0);
} catch {}
try {
commandEncoder117.copyTextureToTexture({
  texture: texture48,
  mipLevel: 3,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture54,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 2, height: 1, depthOrArrayLayers: 1});
} catch {}
let canvas27 = document.createElement('canvas');
let textureView194 = texture51.createView({});
let computePassEncoder90 = commandEncoder163.beginComputePass({});
let renderBundleEncoder80 = device0.createRenderBundleEncoder({
  label: '\u99a7\ue473\u031c\u7939',
  colorFormats: ['r32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder66.setBindGroup(2, bindGroup8, new Uint32Array(6821), 6726, 0);
} catch {}
try {
renderPassEncoder10.setViewport(157.3, 92.54, 2.126, 1.364, 0.2456, 0.6762);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder29.draw(321, 254, 73, 15_450_590);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer10, 5_276);
} catch {}
try {
commandEncoder103.copyBufferToBuffer(buffer21, 24960, buffer25, 169648, 328);
} catch {}
try {
commandEncoder8.clearBuffer(buffer16, 9968, 912);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 6,
  origin: {x: 0, y: 3, z: 2},
  aspect: 'depth-only',
}, new Int32Array(arrayBuffer9), /* required buffer size: 149_113 */
{offset: 873, bytesPerRow: 80, rowsPerImage: 109}, {width: 20, height: 0, depthOrArrayLayers: 18});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 124}
*/
{
  source: video20,
  origin: { x: 2, y: 5 },
  flipY: false,
}, {
  texture: texture62,
  mipLevel: 2,
  origin: {x: 34, y: 15, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise53 = device0.createComputePipelineAsync({layout: pipelineLayout10, compute: {module: shaderModule9, entryPoint: 'compute0'}});
let img17 = await imageWithData(171, 92, '#1d1a63ab', '#d66347a7');
let commandEncoder168 = device3.createCommandEncoder();
let texture106 = gpuCanvasContext7.getCurrentTexture();
let textureView195 = texture105.createView({
  label: '\u072f\u05d4\u3e40\u3fa1\u326b\u98d5\ucd3e',
  format: 'astc-12x10-unorm',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 14,
  arrayLayerCount: 56,
});
try {
device3.queue.writeTexture({
  texture: texture105,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 11},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 136_195 */
{offset: 565, bytesPerRow: 274, rowsPerImage: 33}, {width: 36, height: 0, depthOrArrayLayers: 16});
} catch {}
try {
  await device3.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext20 = offscreenCanvas16.getContext('webgpu');
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let commandEncoder169 = device2.createCommandEncoder({label: '\u{1f987}\u{1f67e}\u{1f9a8}\ua0e2\u05fb\u{1fe67}\u9f63\u0c19\u069d\u{1fa9c}\u{1fbf6}'});
let textureView196 = texture100.createView({label: '\u0307\u0059\u0b87\u0e32\u9062\u35f3\u7f8b\u03fe\u1959\u0afa', dimension: '2d-array'});
let sampler73 = device2.createSampler({
  label: '\u17a8\u9291\u{1fafa}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 59.00,
  lodMaxClamp: 68.98,
});
try {
computePassEncoder82.setPipeline(pipeline132);
} catch {}
try {
renderBundleEncoder76.setBindGroup(0, bindGroup48);
} catch {}
try {
commandEncoder158.clearBuffer(buffer23, 313340, 169668);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture93,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer3, /* required buffer size: 871 */
{offset: 871, bytesPerRow: 19}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline134 = await promise45;
gc();
let bindGroup62 = device3.createBindGroup({label: '\ud6b0\ub2a2\u{1f838}', layout: bindGroupLayout48, entries: []});
let querySet81 = device3.createQuerySet({label: '\u{1fa56}\u{1fdf9}\u0e55\u34fb', type: 'occlusion', count: 2233});
let textureView197 = texture103.createView({
  dimension: '2d',
  format: 'astc-10x5-unorm-srgb',
  baseMipLevel: 2,
  mipLevelCount: 2,
  baseArrayLayer: 56,
  arrayLayerCount: 1,
});
let renderBundle103 = renderBundleEncoder79.finish({label: '\u77f7\u{1fd1b}\u{1f63a}\u{1faf3}\u{1fab2}\u{1f6f2}\u4bbb\u76f9'});
try {
commandEncoder168.copyTextureToTexture({
  texture: texture103,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 8},
  aspect: 'all',
},
{
  texture: texture103,
  mipLevel: 4,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
},
{width: 20, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device3.queue.writeTexture({
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(0), /* required buffer size: 698 */
{offset: 698}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device3.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData6,
  origin: { x: 0, y: 13 },
  flipY: false,
}, {
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let shaderModule31 = device1.createShaderModule({
  label: '\u7b22\ub89a\u9e1c\ufeab\udeae\u5df0\u{1f7f1}\u0f5e\u747c\u25e7',
  code: `@group(1) @binding(522)
var<storage, read_write> parameter13: array<u32>;
@group(0) @binding(354)
var<storage, read_write> type7: array<u32>;
@group(0) @binding(180)
var<storage, read_write> global9: array<u32>;
@group(1) @binding(959)
var<storage, read_write> function12: array<u32>;

@compute @workgroup_size(8, 2, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(1) f0: vec3<u32>,
  @location(3) f1: vec2<i32>,
  @location(0) f2: vec2<u32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(2) a0: vec4<f16>, @location(0) a1: vec2<f16>, @location(4) a2: vec2<f32>, @location(15) a3: f16, @location(12) a4: vec4<i32>, @location(5) a5: vec3<f16>, @location(10) a6: i32, @location(3) a7: vec4<u32>, @location(8) a8: vec3<f32>, @location(1) a9: vec2<f16>, @location(7) a10: vec2<f32>, @location(11) a11: i32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
});
try {
computePassEncoder48.end();
} catch {}
try {
computePassEncoder59.setPipeline(pipeline59);
} catch {}
try {
buffer17.destroy();
} catch {}
try {
commandEncoder149.resolveQuerySet(querySet47, 601, 5, buffer18, 12800);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData15,
  origin: { x: 9, y: 36 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
video16.width = 7;
let bindGroup63 = device2.createBindGroup({
  label: '\u0844\u{1f8f4}\u039d\u64f4\u02db\u9573\uf7de\u9cd6\u{1fa27}\u{1f9e0}\u0d53',
  layout: bindGroupLayout34,
  entries: [{binding: 786, resource: externalTexture68}],
});
let querySet82 = device2.createQuerySet({
  label: '\u{1ff99}\u0ed6\ub4b6\uac02\u0ff2\u{1f9c4}\u3394\u05d3\u{1f754}\u1c09\uc92c',
  type: 'occlusion',
  count: 2267,
});
let textureView198 = texture88.createView({label: '\uf31a\ucf3a\u066f\u2faa\u{1ffdc}', dimension: '2d-array', aspect: 'all', baseMipLevel: 4});
let renderBundleEncoder81 = device2.createRenderBundleEncoder({
  label: '\u{1fc58}\u8e3e\u{1f9d0}\u5727\u296c\ub3cb\u{1fa39}\u553c\u0c82',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
});
try {
renderBundleEncoder69.setBindGroup(0, bindGroup63);
} catch {}
try {
commandEncoder164.copyTextureToBuffer({
  texture: texture93,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 11220 */
  offset: 11192,
  buffer: buffer23,
}, {width: 7, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 7, height: 1, depthOrArrayLayers: 88}
*/
{
  source: imageData26,
  origin: { x: 8, y: 9 },
  flipY: true,
}, {
  texture: texture82,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 15},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext21 = offscreenCanvas14.getContext('webgpu');
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let canvas28 = document.createElement('canvas');
let offscreenCanvas19 = new OffscreenCanvas(131, 287);
let commandEncoder170 = device0.createCommandEncoder({label: '\ub493\u2681'});
let texture107 = device0.createTexture({
  label: '\udea9\u{1f8be}\u734b\u0f1e\u6a38\uc8e9\u860d\u768c\uca74\u{1f63a}',
  size: {width: 330, height: 240, depthOrArrayLayers: 84},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['r16float', 'r16float'],
});
let textureView199 = texture21.createView({
  label: '\u0df7\uca5e\u{1fe83}\u6b05\uc5a3\u{1f6e2}\u7b46\u8114\ufb48\u8644',
  dimension: '2d',
  baseMipLevel: 4,
  mipLevelCount: 1,
  baseArrayLayer: 75,
});
let renderBundle104 = renderBundleEncoder22.finish({label: '\u5a5f\u{1fb1c}\u2684\ue75f\ud2ac\u{1fbdc}'});
try {
renderPassEncoder8.executeBundles([renderBundle73, renderBundle69, renderBundle42, renderBundle73, renderBundle73, renderBundle73]);
} catch {}
try {
renderPassEncoder7.setViewport(136.3, 26.75, 1.159, 25.31, 0.5988, 0.8325);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer6, 'uint16', 708, 1_102);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline106);
} catch {}
try {
renderBundleEncoder29.draw(63, 43, 56, 732_863_108);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer24, 9_772);
} catch {}
try {
renderBundleEncoder50.insertDebugMarker('\uffca');
} catch {}
let pipeline135 = device0.createRenderPipeline({
  label: '\u3a32\ufbc1\u0355\u000c\u286f\u213a\uac27',
  layout: 'auto',
  multisample: {mask: 0x4f48ce58},
  fragment: {module: shaderModule21, entryPoint: 'fragment0', constants: {}, targets: [{format: 'r32float'}]},
  vertex: {module: shaderModule21, entryPoint: 'vertex0', buffers: []},
  primitive: {topology: 'line-list', cullMode: 'none', unclippedDepth: false},
});
let gpuCanvasContext22 = offscreenCanvas15.getContext('webgpu');
try {
canvas26.getContext('webgl');
} catch {}
let pipelineLayout15 = device3.createPipelineLayout({bindGroupLayouts: [bindGroupLayout48, bindGroupLayout48, bindGroupLayout48]});
let commandEncoder171 = device3.createCommandEncoder({label: '\u5472\u{1ff20}\u0eaf\u008e\u066b\u{1fe64}\u{1f8b2}\u7965'});
let textureView200 = texture105.createView({label: '\u6c64\ue2bd\u0b69', dimension: '2d', baseMipLevel: 1, mipLevelCount: 5, baseArrayLayer: 24});
let video24 = await videoWithData();
let imageData29 = new ImageData(48, 44);
let commandEncoder172 = device3.createCommandEncoder({label: '\u047f\u0a5f\uc50c\u8e5c\u58a4'});
let textureView201 = texture106.createView({label: '\u04ae\u1e16\u8c84', format: 'rgba8unorm'});
try {
computePassEncoder89.insertDebugMarker('\u0b9a');
} catch {}
let shaderModule32 = device1.createShaderModule({
  label: '\u23fe\ubadd\ua48c\ue648\udac6\u3813\u{1f9cc}\u0469',
  code: `@group(3) @binding(522)
var<storage, read_write> function13: array<u32>;
@group(3) @binding(959)
var<storage, read_write> type8: array<u32>;

@compute @workgroup_size(4, 1, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(5) f0: u32,
  @location(0) f1: vec4<i32>,
  @location(2) f2: vec4<f32>,
  @location(1) f3: vec2<i32>
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@builtin(instance_index) a0: u32, @location(12) a1: vec4<f16>, @location(11) a2: vec4<f32>, @location(2) a3: i32, @location(15) a4: vec2<f16>, @location(4) a5: u32, @location(13) a6: vec3<f32>, @location(8) a7: vec4<i32>, @location(9) a8: vec4<f16>, @location(10) a9: u32, @location(14) a10: vec2<f16>, @builtin(vertex_index) a11: u32, @location(5) a12: vec2<u32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let textureView202 = texture64.createView({mipLevelCount: 1});
let renderBundleEncoder82 = device1.createRenderBundleEncoder({
  label: '\u03d4\u0f7a\u0e5b\u{1ff57}\udef8\uf293\u1ee6\u26c2\u6735\u944a',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
});
let renderBundle105 = renderBundleEncoder59.finish({label: '\u{1f74f}\u93d5\u089e'});
let sampler74 = device1.createSampler({
  label: '\uadfe\u06e6\u0b9a\u25c4\ua6ad\u{1f99f}\u0f91\u{1fb02}\u{1faa7}\u0775\u{1fca0}',
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 38.21,
  lodMaxClamp: 78.91,
});
try {
computePassEncoder51.end();
} catch {}
try {
renderBundleEncoder61.setBindGroup(3, bindGroup61);
} catch {}
try {
renderBundleEncoder73.setPipeline(pipeline120);
} catch {}
try {
renderBundleEncoder68.setVertexBuffer(1, buffer12, 0);
} catch {}
try {
device1.pushErrorScope('internal');
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet28, 761, 19, buffer15, 7680);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let pipeline136 = device1.createComputePipeline({
  label: '\u0cac\u78a3\u0a27\ufca7\u03a0',
  layout: pipelineLayout7,
  compute: {module: shaderModule13, entryPoint: 'compute0', constants: {}},
});
let textureView203 = texture48.createView({
  label: '\u{1ffbd}\u4440\u52ca\u050e\u68ec\u{1fb0b}\u058f\ua815\u0639',
  baseMipLevel: 1,
  mipLevelCount: 3,
});
let computePassEncoder91 = commandEncoder139.beginComputePass({});
let renderBundle106 = renderBundleEncoder45.finish({label: '\u0fcb\u0cb1\u0c08\u{1fecc}\u2b47\u{1f973}\u{1f710}\ud504\u{1f68c}'});
try {
renderBundleEncoder39.setPipeline(pipeline120);
} catch {}
try {
commandEncoder165.copyBufferToTexture({
  /* bytesInLastRow: 728 widthInBlocks: 182 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 10500 */
  offset: 10500,
  buffer: buffer15,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {width: 182, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder61.copyTextureToBuffer({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 288 widthInBlocks: 72 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 22604 */
  offset: 22604,
  rowsPerImage: 220,
  buffer: buffer13,
}, {width: 72, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer13, 4912, new DataView(new ArrayBuffer(5058)), 2629, 1044);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture50,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer10, /* required buffer size: 456 */
{offset: 456}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let offscreenCanvas20 = new OffscreenCanvas(784, 1000);
let bindGroupLayout49 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 637,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let commandEncoder173 = device0.createCommandEncoder({label: '\u6d5e\u{1f7ea}\u04ae\u{1fbfd}\udcee\u{1feaa}\u3799'});
let renderBundle107 = renderBundleEncoder80.finish();
try {
computePassEncoder39.end();
} catch {}
try {
computePassEncoder90.setPipeline(pipeline35);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle73, renderBundle42, renderBundle69, renderBundle69, renderBundle42, renderBundle73, renderBundle69]);
} catch {}
try {
renderPassEncoder6.setStencilReference(405);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline106);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer11, 192_560);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline95);
} catch {}
try {
renderBundleEncoder19.setVertexBuffer(5, buffer9, 156_332, 22_946);
} catch {}
try {
commandEncoder20.clearBuffer(buffer2, 95872, 10272);
} catch {}
try {
commandEncoder20.resolveQuerySet(querySet34, 607, 428, buffer0, 292608);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline137 = await device0.createRenderPipelineAsync({
  label: '\u{1fa71}\u05b9\u6504\ua5ed',
  layout: pipelineLayout2,
  multisample: {},
  fragment: {
  module: shaderModule4,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm'}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one', dstFactor: 'one-minus-src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'greater', failOp: 'increment-wrap', depthFailOp: 'increment-clamp', passOp: 'increment-wrap'},
    stencilBack: {
      compare: 'greater',
      failOp: 'decrement-clamp',
      depthFailOp: 'increment-clamp',
      passOp: 'increment-wrap',
    },
    stencilReadMask: 845283791,
    stencilWriteMask: 3256425812,
    depthBias: -831356535,
    depthBiasClamp: 0.0,
  },
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 56, attributes: []},
      {arrayStride: 320, stepMode: 'vertex', attributes: []},
      {arrayStride: 216, stepMode: 'instance', attributes: []},
      {arrayStride: 0, stepMode: 'vertex', attributes: []},
      {arrayStride: 92, attributes: []},
      {arrayStride: 216, attributes: []},
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 112,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 24, shaderLocation: 5},
          {format: 'sint16x4', offset: 24, shaderLocation: 7},
          {format: 'unorm8x4', offset: 4, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'},
});
let pipelineLayout16 = device2.createPipelineLayout({
  label: '\u00b9\u0655',
  bindGroupLayouts: [bindGroupLayout41, bindGroupLayout34, bindGroupLayout47, bindGroupLayout34],
});
let querySet83 = device2.createQuerySet({label: '\u597c\u{1f990}\u9c4d', type: 'occlusion', count: 1057});
let texture108 = device2.createTexture({
  label: '\u017c\u8714\u4be8\u0343\u20b2\u828c\uaf9a\u0ebd\ueda6\u5865',
  size: {width: 24, height: 16, depthOrArrayLayers: 104},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm'],
});
let textureView204 = texture100.createView({label: '\u5d03\u01f6\u8eb3\u5173', baseMipLevel: 0, arrayLayerCount: 1});
let renderBundleEncoder83 = device2.createRenderBundleEncoder({
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
});
let renderBundle108 = renderBundleEncoder58.finish({});
try {
computePassEncoder78.end();
} catch {}
try {
renderBundleEncoder64.setPipeline(pipeline133);
} catch {}
try {
commandEncoder164.clearBuffer(buffer23, 424808, 55584);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline138 = device2.createRenderPipeline({
  label: '\ua5ce\u7ad1\u2441\u0eb9\u0d05\u69e0\u8239\u68f1\u{1f8ad}\u0f5f\u{1fe1e}',
  layout: pipelineLayout13,
  fragment: {
  module: shaderModule28,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'dst-alpha'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'r8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {
  format: 'r8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rg8unorm', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilFront: {compare: 'less', failOp: 'replace', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'less-equal', failOp: 'replace', depthFailOp: 'decrement-clamp'},
    stencilReadMask: 3427048232,
    stencilWriteMask: 3324175136,
    depthBias: -83214181,
  },
  vertex: {
    module: shaderModule28,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 580,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 208, shaderLocation: 10},
          {format: 'unorm16x4', offset: 156, shaderLocation: 7},
          {format: 'uint32x4', offset: 136, shaderLocation: 1},
        ],
      },
      {arrayStride: 16, stepMode: 'instance', attributes: []},
      {arrayStride: 248, attributes: [{format: 'float32x4', offset: 32, shaderLocation: 14}]},
      {
        arrayStride: 0,
        attributes: [
          {format: 'snorm16x2', offset: 68, shaderLocation: 6},
          {format: 'uint8x4', offset: 0, shaderLocation: 11},
          {format: 'snorm8x4', offset: 24, shaderLocation: 4},
          {format: 'uint8x4', offset: 588, shaderLocation: 3},
        ],
      },
      {arrayStride: 200, attributes: []},
      {arrayStride: 100, stepMode: 'instance', attributes: []},
      {
        arrayStride: 512,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32', offset: 16, shaderLocation: 5},
          {format: 'unorm16x4', offset: 136, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 60,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm16x2', offset: 36, shaderLocation: 2},
          {format: 'float16x4', offset: 4, shaderLocation: 15},
          {format: 'unorm10-10-10-2', offset: 24, shaderLocation: 0},
          {format: 'snorm16x2', offset: 0, shaderLocation: 13},
          {format: 'snorm16x4', offset: 0, shaderLocation: 9},
          {format: 'snorm16x4', offset: 4, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'back'},
});
let video25 = await videoWithData();
let commandEncoder174 = device2.createCommandEncoder();
let commandBuffer40 = commandEncoder158.finish({label: '\u25c6\uc8c3\u0a2b\u{1fff0}\u0c78'});
let texture109 = device2.createTexture({
  label: '\u6527\u0d09\u2994\u002a\u{1f8c9}\u33ef\u05d0\u{1faec}\u09f5',
  size: {width: 360, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm'],
});
let computePassEncoder92 = commandEncoder174.beginComputePass();
let renderBundle109 = renderBundleEncoder71.finish({label: '\u5c94\u0728\u0fa5\u4724\ub98c\u4e58\ua827\u0bf3'});
try {
renderBundleEncoder81.setPipeline(pipeline133);
} catch {}
try {
buffer23.unmap();
} catch {}
let commandEncoder175 = device0.createCommandEncoder({});
let texture110 = device0.createTexture({
  size: {width: 660, height: 480, depthOrArrayLayers: 244},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView205 = texture98.createView({
  label: '\u6bd2\uc4fd\u0072\u40ee\u{1f7f3}\u{1fe36}\u0d93',
  dimension: '2d',
  baseMipLevel: 2,
  baseArrayLayer: 88,
});
let computePassEncoder93 = commandEncoder143.beginComputePass({label: '\u07b4\u05f3\uedac\u57f2\u{1fbae}\ue751\u5c88'});
let renderBundleEncoder84 = device0.createRenderBundleEncoder({
  label: '\u266f\uf7ba\u{1f7e8}\ub549\u5bd5\u065f\u9849',
  colorFormats: ['r32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder10.dispatchWorkgroups(2, 1, 2);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle69, renderBundle69, renderBundle69, renderBundle73, renderBundle42, renderBundle42, renderBundle73, renderBundle73]);
} catch {}
try {
renderBundleEncoder60.setBindGroup(3, bindGroup19);
} catch {}
try {
renderBundleEncoder29.drawIndexed(647, 165, 1_331, 99_424_158, 880_939_700);
} catch {}
try {
renderBundleEncoder38.setIndexBuffer(buffer6, 'uint32', 1_996, 8_679);
} catch {}
try {
commandEncoder170.copyBufferToTexture({
  /* bytesInLastRow: 1340 widthInBlocks: 335 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 12932 */
  offset: 12932,
  buffer: buffer5,
}, {
  texture: texture14,
  mipLevel: 0,
  origin: {x: 185, y: 0, z: 0},
  aspect: 'all',
}, {width: 335, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder160.resolveQuerySet(querySet18, 805, 95, buffer1, 20992);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture34,
  mipLevel: 2,
  origin: {x: 4, y: 8, z: 1},
  aspect: 'all',
}, new ArrayBuffer(72), /* required buffer size: 214_931 */
{offset: 167, bytesPerRow: 564, rowsPerImage: 304}, {width: 111, height: 77, depthOrArrayLayers: 2});
} catch {}
let pipeline139 = await device0.createRenderPipelineAsync({
  label: '\u0355\u08ee\u263a',
  layout: pipelineLayout8,
  multisample: {count: 4, mask: 0x3a18e554},
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 148, stepMode: 'instance', attributes: []},
      {arrayStride: 216, stepMode: 'instance', attributes: []},
      {arrayStride: 320, stepMode: 'instance', attributes: []},
      {arrayStride: 204, attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 184, stepMode: 'vertex', attributes: [{format: 'float32', offset: 4, shaderLocation: 7}]},
      {arrayStride: 56, stepMode: 'instance', attributes: []},
      {
        arrayStride: 68,
        attributes: [{format: 'unorm8x2', offset: 6, shaderLocation: 13}, {format: 'uint8x4', offset: 4, shaderLocation: 5}],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'front'},
});
try {
commandEncoder159.resolveQuerySet(querySet82, 823, 27, buffer23, 38912);
} catch {}
let imageBitmap21 = await createImageBitmap(canvas12);
let imageData30 = new ImageData(144, 148);
let buffer28 = device1.createBuffer({
  size: 48342,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture111 = device1.createTexture({
  label: '\u5d82\u0585\udaa2\uf67f',
  size: [10, 10, 1786],
  mipLevelCount: 10,
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32sint'],
});
let computePassEncoder94 = commandEncoder157.beginComputePass({label: '\u8ad7\u{1fc7c}\u8995\u0c91\u41c9\uc054\u02cc'});
let renderBundleEncoder85 = device1.createRenderBundleEncoder({
  label: '\ua859\u0723\u0a1c\u{1fe91}\u0d2b\u99a9\u4ea9\u6830\u3b57\u0163',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
});
try {
renderBundleEncoder82.setVertexBuffer(5, buffer13);
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet60, 548, 125, buffer15, 1024);
} catch {}
canvas26.width = 1782;
try {
canvas27.getContext('2d');
} catch {}
let querySet84 = device1.createQuerySet({label: '\u685d\uf37c\u{1f74c}\u4b1a\u2030', type: 'occlusion', count: 1092});
let texture112 = device1.createTexture({
  label: '\u{1fbfe}\u35e7\u82e8\u{1f82c}\uf590\udec6\u06c2\u6e36',
  size: {width: 10},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg32sint'],
});
let textureView206 = texture38.createView({baseArrayLayer: 0});
let computePassEncoder95 = commandEncoder167.beginComputePass({label: '\u0038\u3568\u0c59\u0b7c\u5707\uc666\u{1fc0a}'});
let externalTexture94 = device1.importExternalTexture({source: video22, colorSpace: 'srgb'});
try {
commandEncoder146.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1216 */
  offset: 1216,
  buffer: buffer15,
}, {
  texture: texture50,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder88.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 10756 */
  offset: 10716,
  buffer: buffer13,
}, {width: 10, height: 1, depthOrArrayLayers: 1});
} catch {}
let querySet85 = device2.createQuerySet({label: '\u5635\u{1f84a}\u05c3\u0531', type: 'occlusion', count: 2942});
let texture113 = device2.createTexture({
  size: [48, 32, 46],
  mipLevelCount: 2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm-srgb'],
});
let textureView207 = texture79.createView({label: '\u0e66\uccd7\u51c9\u0983\u{1f6b2}\u39b6', baseArrayLayer: 28, arrayLayerCount: 2});
let renderBundle110 = renderBundleEncoder65.finish({label: '\u054a\u{1f9bd}\ubc41\u1766\u0cae\u04e3\u3cd5\u{1fbb4}\u{1f69a}\u6ee4\u4c4c'});
let sampler75 = device2.createSampler({
  label: '\u01dd\u8171\u099d\uc67e\u{1faf6}\u5f2c\u0699\u03db\u{1ff11}\u83f9\u41bc',
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 34.64,
  lodMaxClamp: 62.76,
  compare: 'less-equal',
});
try {
renderBundleEncoder77.setPipeline(pipeline133);
} catch {}
try {
commandEncoder154.copyTextureToBuffer({
  texture: texture93,
  mipLevel: 5,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 7316 */
  offset: 7316,
  buffer: buffer23,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture87,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(32), /* required buffer size: 738 */
{offset: 738, bytesPerRow: 691}, {width: 80, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 24, height: 16, depthOrArrayLayers: 104}
*/
{
  source: offscreenCanvas14,
  origin: { x: 21, y: 78 },
  flipY: true,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 8},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 7, height: 13, depthOrArrayLayers: 0});
} catch {}
let device4 = await adapter3.requestDevice({
  label: '\u{1fa64}\u0cdc\u066e\u7af8',
  defaultQueue: {label: '\u92d6\u029f'},
  requiredFeatures: [
    'depth-clip-control',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxUniformBufferBindingSize: 19821843,
    maxStorageBufferBindingSize: 195073270,
    maxSampledTexturesPerShaderStage: 16,
  },
});
let textureView208 = texture82.createView({label: '\u0339\uc3b6', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 43, arrayLayerCount: 27});
let externalTexture95 = device2.importExternalTexture({source: videoFrame14, colorSpace: 'display-p3'});
try {
querySet70.destroy();
} catch {}
try {
commandEncoder159.copyTextureToTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 24, y: 0, z: 9},
  aspect: 'all',
},
{
  texture: texture79,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
},
{width: 36, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 360, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas3,
  origin: { x: 1, y: 120 },
  flipY: false,
}, {
  texture: texture109,
  mipLevel: 0,
  origin: {x: 39, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 25, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext23 = canvas28.getContext('webgpu');
let imageData31 = new ImageData(124, 104);
let commandEncoder176 = device1.createCommandEncoder({label: '\ub652\u05f9\u9d0f\u0994\u0649\u0eec\u0f68\uecea\u{1fde9}\u488e\ue244'});
let textureView209 = texture96.createView({
  label: '\u5d08\ud849\u{1fb26}\u754f\u3a3b\u0800\u8c6b\u008e\ua95f\ubd3e',
  baseMipLevel: 6,
  mipLevelCount: 1,
});
let sampler76 = device1.createSampler({
  label: '\uab6e\u0cdf\u055d\u0a59\u5d03\u2d7d\u15a1\u{1fde4}\uf1f2\u985a\u{1fb9f}',
  addressModeU: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 29.37,
  lodMaxClamp: 46.75,
});
try {
renderBundleEncoder73.setBindGroup(0, bindGroup61);
} catch {}
try {
renderBundleEncoder73.setPipeline(pipeline80);
} catch {}
try {
commandEncoder176.copyBufferToBuffer(buffer17, 3276, buffer12, 6068, 100);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: img4,
  origin: { x: 40, y: 25 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await adapter5.requestAdapterInfo();
} catch {}
let bindGroup64 = device3.createBindGroup({layout: bindGroupLayout48, entries: []});
let commandEncoder177 = device3.createCommandEncoder({});
let commandBuffer41 = commandEncoder177.finish({label: '\udd65\u0fe7'});
let textureView210 = texture103.createView({
  label: '\uf3ea\u0e66\u630c\ud42e',
  format: 'astc-10x5-unorm-srgb',
  baseMipLevel: 4,
  baseArrayLayer: 40,
  arrayLayerCount: 9,
});
let renderBundleEncoder86 = device3.createRenderBundleEncoder({
  label: '\ua762\u0de4\u1794\u0f1a\u0458\u{1f7d2}\u05e5\u3468',
  colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'],
});
let renderBundle111 = renderBundleEncoder86.finish({label: '\u{1fbc5}\uac23'});
try {
texture106.destroy();
} catch {}
try {
commandEncoder172.copyTextureToTexture({
  texture: texture103,
  mipLevel: 2,
  origin: {x: 40, y: 0, z: 19},
  aspect: 'all',
},
{
  texture: texture103,
  mipLevel: 2,
  origin: {x: 120, y: 0, z: 0},
  aspect: 'all',
},
{width: 90, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
  await promise46;
} catch {}
let renderBundleEncoder87 = device2.createRenderBundleEncoder({
  label: '\u{1f958}\uacc2\u3291\udce7\uaa14\u0e6a\u{1f8bf}\u9a2e',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  stencilReadOnly: true,
});
let renderBundle112 = renderBundleEncoder66.finish({label: '\u0b5a\u01dd\u{1fba6}\u0d3e\u{1f9af}'});
try {
renderBundleEncoder77.setPipeline(pipeline133);
} catch {}
try {
commandEncoder159.copyBufferToBuffer(buffer22, 327724, buffer23, 22360, 4968);
} catch {}
try {
commandEncoder154.copyTextureToBuffer({
  texture: texture94,
  mipLevel: 5,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 938 */
  offset: 936,
  bytesPerRow: 256,
  buffer: buffer23,
}, {width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 15, height: 1, depthOrArrayLayers: 88}
*/
{
  source: canvas12,
  origin: { x: 25, y: 6 },
  flipY: false,
}, {
  texture: texture82,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 36},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline140 = await device2.createRenderPipelineAsync({
  label: '\u5ba2\u0d94\ua3e9\u{1fc70}\uc1f1\ufa61\u087b\ua17e\u83e8\u6c73',
  layout: pipelineLayout14,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE,
}, {format: 'rgba8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'src-alpha'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'r8unorm', writeMask: GPUColorWrite.ALPHA}, {format: 'r8sint'}, {format: 'rg8unorm'}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 256, attributes: []},
      {arrayStride: 136, attributes: []},
      {arrayStride: 244, stepMode: 'instance', attributes: []},
      {arrayStride: 180, attributes: []},
      {arrayStride: 608, stepMode: 'instance', attributes: []},
      {arrayStride: 740, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 444, shaderLocation: 0},
          {format: 'uint32', offset: 1036, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'ccw'},
});
try {
  await promise27;
} catch {}
let buffer29 = device0.createBuffer({
  label: '\u05eb\u10d2\u0faa\u30bf\u{1f656}\ua7bb\u0200\u0dd4',
  size: 114306,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let renderBundleEncoder88 = device0.createRenderBundleEncoder({
  label: '\u6a7e\u6f29\u0174\u3328',
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle113 = renderBundleEncoder31.finish({label: '\u8ed3\u645f\u{1fb67}\u2bf7'});
let externalTexture96 = device0.importExternalTexture({label: '\u41d6\uae6e\u{1f6e6}\u4979\u0abf\u824f\ud3bb\u4204', source: video14, colorSpace: 'srgb'});
try {
renderPassEncoder8.setBindGroup(2, bindGroup10);
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(2716);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: 994.1, g: 13.30, b: 222.0, a: -694.0, });
} catch {}
try {
renderPassEncoder10.setStencilReference(2475);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer6, 0);
} catch {}
try {
renderBundleEncoder12.setIndexBuffer(buffer6, 'uint32', 4_628, 3_579);
} catch {}
try {
buffer0.unmap();
} catch {}
let bindGroupLayout50 = device2.createBindGroupLayout({
  label: '\u3b52\u07e3\u{1fe93}\uae00\ub8ff',
  entries: [{binding: 308, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }}],
});
let querySet86 = device2.createQuerySet({label: '\u02fd\u{1ffca}\u156d', type: 'occlusion', count: 73});
let texture114 = device2.createTexture({
  label: '\uddab\ube84\u0c3e\u{1fe0d}',
  size: [30, 3, 1],
  mipLevelCount: 5,
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle114 = renderBundleEncoder81.finish({label: '\u{1fae3}\u0455\u360d\u{1fa18}\u9b5e\ue5c3\u004a\u0578\u0552\u{1fd5c}'});
let promise54 = device2.popErrorScope();
try {
commandEncoder164.copyBufferToBuffer(buffer22, 200732, buffer23, 407868, 50824);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 48, height: 32, depthOrArrayLayers: 46}
*/
{
  source: video6,
  origin: { x: 3, y: 0 },
  flipY: true,
}, {
  texture: texture113,
  mipLevel: 0,
  origin: {x: 17, y: 5, z: 21},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline141 = await device2.createComputePipelineAsync({
  label: '\ub40b\u{1fbc9}',
  layout: pipelineLayout12,
  compute: {module: shaderModule27, entryPoint: 'compute0', constants: {}},
});
let promise55 = device2.createRenderPipelineAsync({
  label: '\u{1f72b}\ue4c8\u0feb\u0679\u072c\u0465\u08d3\uce26\u2917',
  layout: pipelineLayout11,
  fragment: {
  module: shaderModule27,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm'}, {format: 'rgba8unorm', writeMask: GPUColorWrite.ALL}, {format: 'rgba8unorm-srgb'}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'constant'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'r8sint', writeMask: GPUColorWrite.BLUE}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'dst'},
    alpha: {operation: 'add', srcFactor: 'dst', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA,
}, {format: 'rgba8sint', writeMask: 0}],
},
  vertex: {
    module: shaderModule27,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 0, attributes: [{format: 'unorm16x2', offset: 244, shaderLocation: 1}]},
      {
        arrayStride: 348,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 28, shaderLocation: 14},
          {format: 'uint32x4', offset: 32, shaderLocation: 11},
          {format: 'uint16x2', offset: 20, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 224,
        attributes: [
          {format: 'sint8x2', offset: 8, shaderLocation: 10},
          {format: 'uint16x4', offset: 88, shaderLocation: 7},
          {format: 'unorm8x2', offset: 74, shaderLocation: 9},
          {format: 'uint32x2', offset: 0, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 160, shaderLocation: 13},
        ],
      },
      {arrayStride: 104, attributes: []},
      {arrayStride: 432, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 988, attributes: []},
      {arrayStride: 172, attributes: [{format: 'uint8x2', offset: 10, shaderLocation: 0}]},
    ],
  },
});
let textureView211 = texture75.createView({label: '\u0349\u{1f6d8}\u{1f83b}\u02cd\u9019\u397a', baseMipLevel: 2, mipLevelCount: 4});
try {
computePassEncoder11.setBindGroup(0, bindGroup4);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle107, renderBundle73, renderBundle73, renderBundle73, renderBundle73, renderBundle42, renderBundle42, renderBundle69, renderBundle107]);
} catch {}
try {
renderBundleEncoder29.draw(92, 256, 75, 293_711_106);
} catch {}
try {
renderBundleEncoder29.drawIndexed(71, 345, 1_281, 1_246_061_076, 2_175_455_678);
} catch {}
try {
commandEncoder134.clearBuffer(buffer9);
} catch {}
try {
commandEncoder110.resolveQuerySet(querySet64, 1192, 1326, buffer24, 92672);
} catch {}
let promise56 = device0.createRenderPipelineAsync({
  label: '\u0de5\u9b84\u0951\u0a1d\u63c7\u4354\u6251\u{1f761}',
  layout: pipelineLayout10,
  multisample: {count: 1, mask: 0x1c549762},
  vertex: {
    module: shaderModule7,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'unorm16x2', offset: 44, shaderLocation: 9},
          {format: 'unorm10-10-10-2', offset: 280, shaderLocation: 12},
          {format: 'sint32x2', offset: 164, shaderLocation: 0},
          {format: 'snorm16x2', offset: 136, shaderLocation: 2},
        ],
      },
      {
        arrayStride: 160,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 72, shaderLocation: 5},
          {format: 'float32x4', offset: 4, shaderLocation: 4},
        ],
      },
      {arrayStride: 480, stepMode: 'instance', attributes: []},
      {
        arrayStride: 632,
        stepMode: 'instance',
        attributes: [{format: 'uint8x2', offset: 164, shaderLocation: 10}],
      },
      {arrayStride: 384, attributes: [{format: 'float32', offset: 252, shaderLocation: 6}]},
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 0, shaderLocation: 11},
          {format: 'uint8x2', offset: 6, shaderLocation: 8},
          {format: 'sint8x2', offset: 0, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 848,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 192, shaderLocation: 13},
          {format: 'unorm16x4', offset: 144, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 244,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x2', offset: 6, shaderLocation: 14},
          {format: 'unorm16x4', offset: 36, shaderLocation: 3},
          {format: 'sint8x4', offset: 160, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-list', cullMode: 'back'},
});
let textureView212 = texture0.createView({
  label: '\u1d82\ufb7b\u252b\u{1fe5e}\u{1fb4b}\u41e0\u{1fd1f}',
  dimension: '2d',
  baseMipLevel: 1,
  baseArrayLayer: 2,
});
let computePassEncoder96 = commandEncoder109.beginComputePass({});
let renderBundle115 = renderBundleEncoder9.finish();
try {
renderPassEncoder10.setPipeline(pipeline106);
} catch {}
try {
renderBundleEncoder29.draw(413, 136, 15, 798_939_312);
} catch {}
try {
renderBundleEncoder50.setPipeline(pipeline135);
} catch {}
try {
commandEncoder175.copyTextureToTexture({
  texture: texture18,
  mipLevel: 1,
  origin: {x: 4, y: 2, z: 8},
  aspect: 'all',
},
{
  texture: texture18,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 23, height: 25, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 10, height: 7, depthOrArrayLayers: 124}
*/
{
  source: imageData2,
  origin: { x: 17, y: 2 },
  flipY: false,
}, {
  texture: texture62,
  mipLevel: 6,
  origin: {x: 1, y: 0, z: 46},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline142 = device0.createComputePipeline({
  label: '\u4565\u{1f656}\u{1fe66}\u{1fc1b}\u{1f86b}\ub471\ua253\u0af9\u4b2a\u058d\u0f7a',
  layout: pipelineLayout1,
  compute: {module: shaderModule6, entryPoint: 'compute0', constants: {}},
});
let renderBundleEncoder89 = device0.createRenderBundleEncoder({
  label: '\u7710\u{1fd1f}\u784a\u{1f62f}\ue31e\u7bdd\u0fe7\u{1fbb7}',
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
});
try {
computePassEncoder10.dispatchWorkgroups(1);
} catch {}
try {
renderPassEncoder10.setBindGroup(2, bindGroup2);
} catch {}
try {
renderPassEncoder7.setStencilReference(1286);
} catch {}
try {
renderPassEncoder10.setViewport(142.4, 64.81, 12.14, 48.43, 0.1697, 0.1983);
} catch {}
try {
renderBundleEncoder67.setBindGroup(0, bindGroup0);
} catch {}
try {
renderBundleEncoder50.setBindGroup(3, bindGroup54, new Uint32Array(9914), 2370, 0);
} catch {}
try {
renderBundleEncoder50.drawIndexed(607, 23, 178, 236_839_526, 788_413_109);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline13);
} catch {}
try {
  await device0.popErrorScope();
} catch {}
try {
commandEncoder175.resolveQuerySet(querySet48, 152, 583, buffer1, 13312);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 10476, new DataView(new ArrayBuffer(11388)));
} catch {}
let textureView213 = texture114.createView({
  label: '\u66e1\u0f16\u{1fdd8}\u1698\u34b5\u7db8\u05fc\u222f\ub507\u07fe',
  baseMipLevel: 3,
  mipLevelCount: 1,
});
let renderBundleEncoder90 = device2.createRenderBundleEncoder({
  label: '\uf52e\u0e8e\u0d3a\u7f34\u7468\u6556\uf9be',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
let renderBundle116 = renderBundleEncoder71.finish({label: '\u{1f70b}\u{1fb8a}\u5a2b\u{1f713}\u923e\u2b0b\u54ea\u7b60\ub6a9\u8f50'});
try {
renderBundleEncoder70.setBindGroup(1, bindGroup48, new Uint32Array(2032), 450, 0);
} catch {}
try {
commandEncoder169.copyTextureToTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 108, y: 0, z: 15},
  aspect: 'all',
},
{
  texture: texture79,
  mipLevel: 0,
  origin: {x: 84, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder154.clearBuffer(buffer23, 60320, 54464);
} catch {}
try {
commandEncoder169.resolveQuerySet(querySet82, 314, 50, buffer23, 3072);
} catch {}
let offscreenCanvas21 = new OffscreenCanvas(727, 519);
let commandEncoder178 = device0.createCommandEncoder({label: '\u0686\u{1f70f}\u05f8\u{1f9e0}\ub551\ua7ab\u040a\u495b\u072e\u65df'});
let querySet87 = device0.createQuerySet({label: '\u6dad\u04ee\u{1ff32}', type: 'occlusion', count: 2227});
let texture115 = device0.createTexture({
  label: '\u679a\u0046\u{1fcda}\u0e81\u00f4\u{1f9fd}',
  size: {width: 1320, height: 960, depthOrArrayLayers: 124},
  mipLevelCount: 2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm-srgb'],
});
let textureView214 = texture5.createView({baseMipLevel: 1, mipLevelCount: 4, baseArrayLayer: 91});
let sampler77 = device0.createSampler({
  label: '\u1b51\ude6b\u3f69\ub6de\ue5ea\u{1fd3c}\u07d2\uee33',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 75.19,
  lodMaxClamp: 75.84,
});
try {
computePassEncoder54.dispatchWorkgroups(5, 3, 4);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer5);
} catch {}
try {
renderBundleEncoder40.setBindGroup(3, bindGroup58, []);
} catch {}
try {
commandEncoder103.clearBuffer(buffer3, 3476, 15144);
} catch {}
try {
commandEncoder8.resolveQuerySet(querySet12, 41, 25, buffer16, 256);
} catch {}
try {
commandEncoder87.insertDebugMarker('\uaf17');
} catch {}
let sampler78 = device4.createSampler({
  label: '\u{1f8cb}\u0b58\u0748\ua5c6\u0147\u3886\u0cdc\u0221\u{1fb95}\u{1fd40}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  lodMinClamp: 91.42,
  lodMaxClamp: 95.61,
});
let promise57 = device4.queue.onSubmittedWorkDone();
let bindGroup65 = device2.createBindGroup({layout: bindGroupLayout34, entries: [{binding: 786, resource: externalTexture84}]});
let renderBundleEncoder91 = device2.createRenderBundleEncoder({
  label: '\u51eb\u2f00\u945f\u0292\u0fb0',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  stencilReadOnly: true,
});
try {
renderBundleEncoder74.setBindGroup(1, bindGroup65);
} catch {}
try {
renderBundleEncoder91.setPipeline(pipeline133);
} catch {}
try {
device2.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder169.clearBuffer(buffer23, 18372, 465996);
} catch {}
try {
commandEncoder164.resolveQuerySet(querySet85, 250, 140, buffer23, 139264);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 48, height: 32, depthOrArrayLayers: 46}
*/
{
  source: video21,
  origin: { x: 1, y: 1 },
  flipY: false,
}, {
  texture: texture113,
  mipLevel: 0,
  origin: {x: 24, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
gc();
let video26 = await videoWithData();
let renderBundleEncoder92 = device4.createRenderBundleEncoder({
  label: '\u0c13\u{1fae1}\u02cc\u0a72\u0096\u0a97\ua428',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  stencilReadOnly: true,
});
let externalTexture97 = device4.importExternalTexture({label: '\u024d\u313c\u63ca\u0d89', source: videoFrame11, colorSpace: 'display-p3'});
try {
gpuCanvasContext18.unconfigure();
} catch {}
try {
  await promise57;
} catch {}
let shaderModule33 = device1.createShaderModule({
  label: '\u747d\udc6f\u{1fd7e}\u0948\ub231\u0f4e\u{1fca5}',
  code: `@group(1) @binding(522)
var<storage, read_write> function14: array<u32>;
@group(0) @binding(354)
var<storage, read_write> n12: array<u32>;
@group(0) @binding(180)
var<storage, read_write> global10: array<u32>;
@group(0) @binding(406)
var<storage, read_write> n13: array<u32>;
@group(1) @binding(959)
var<storage, read_write> type9: array<u32>;

@compute @workgroup_size(6, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(1) f0: vec2<i32>,
  @location(0) f1: vec4<i32>,
  @location(2) f2: vec4<f32>,
  @builtin(sample_mask) f3: u32
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(11) a0: vec4<f32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let texture116 = device1.createTexture({
  label: '\u3928\ud62a\ub8dd\u0c6c\u01c6\u0262\u84ed\u0293\u0b5e\u428c\u{1ff50}',
  size: [75, 24, 66],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
computePassEncoder59.setPipeline(pipeline59);
} catch {}
try {
  await device1.popErrorScope();
} catch {}
try {
commandEncoder146.copyBufferToBuffer(buffer17, 16704, buffer12, 3668, 928);
} catch {}
try {
commandEncoder116.resolveQuerySet(querySet76, 32, 112, buffer28, 4608);
} catch {}
let commandEncoder179 = device0.createCommandEncoder({label: '\ue5c9\u{1fcf6}\ueddb\u{1fdc7}\u7394\ub42d\u09de'});
let renderBundle117 = renderBundleEncoder84.finish({label: '\u0dd7\u0ee2\ufc74\u0ae4\u0740'});
try {
computePassEncoder40.setBindGroup(1, bindGroup20);
} catch {}
try {
renderPassEncoder10.end();
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle107, renderBundle73, renderBundle42, renderBundle107, renderBundle117, renderBundle73, renderBundle117, renderBundle117]);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline106);
} catch {}
try {
renderBundleEncoder20.setBindGroup(0, bindGroup6, new Uint32Array(4445), 3735, 0);
} catch {}
try {
renderBundleEncoder50.drawIndexed(1_228, 29, 866, 42_184_593, 250_347_860);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer11, 44_484);
} catch {}
try {
  await promise48;
} catch {}
let video27 = await videoWithData();
let commandEncoder180 = device4.createCommandEncoder({label: '\ubb4e\u{1f612}\u047c\u0823\u{1f711}\ue6ea\u57e6'});
let querySet88 = device4.createQuerySet({label: '\u{1fd9e}\u5790\u5663', type: 'occlusion', count: 1407});
let commandBuffer42 = commandEncoder180.finish({});
gc();
let renderBundleEncoder93 = device4.createRenderBundleEncoder({
  label: '\u0553\u{1f6dc}\u754a\u18a9\u5f63\u0073',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
});
let offscreenCanvas22 = new OffscreenCanvas(291, 278);
let renderBundleEncoder94 = device4.createRenderBundleEncoder({
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let externalTexture98 = device4.importExternalTexture({label: '\uee0f\u3ee9\u0c0a\u0f11\ub3a1', source: videoFrame2, colorSpace: 'srgb'});
try {
gpuCanvasContext18.configure({
  device: device4,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
window.someLabel = sampler78.label;
} catch {}
let renderBundleEncoder95 = device4.createRenderBundleEncoder({
  label: '\u{1fecd}\u05d1\u{1face}\u083b\u0607\u3309\u{1f8c0}\u4db5\ud005',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: true,
});
try {
renderBundleEncoder95.insertDebugMarker('\u{1f9e3}');
} catch {}
let bindGroupLayout51 = device4.createBindGroupLayout({
  label: '\u0e0e\u53bf\ucb6c',
  entries: [
    {
      binding: 386,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' },
    },
    {
      binding: 910,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let buffer30 = device4.createBuffer({
  label: '\u0e05\ud66c',
  size: 267233,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: false,
});
let sampler79 = device4.createSampler({
  label: '\u0400\u0009\u1f47\u{1f8b2}\u0181\u0a79\u569d',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 99.73,
  lodMaxClamp: 99.82,
  compare: 'greater-equal',
});
let externalTexture99 = device4.importExternalTexture({label: '\u9928\u099b\u{1fa13}', source: videoFrame6, colorSpace: 'display-p3'});
try {
  await promise50;
} catch {}
let canvas29 = document.createElement('canvas');
let commandEncoder181 = device1.createCommandEncoder({label: '\u6f33\ue734\ubf36\u0edc\ufd9c'});
try {
computePassEncoder55.setBindGroup(2, bindGroup33, new Uint32Array(3045), 2640, 0);
} catch {}
try {
renderBundleEncoder61.setBindGroup(0, bindGroup30, new Uint32Array(738), 684, 0);
} catch {}
try {
renderBundleEncoder85.setPipeline(pipeline120);
} catch {}
let arrayBuffer11 = buffer26.getMappedRange(278888, 15892);
try {
commandEncoder146.copyTextureToBuffer({
  texture: texture112,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 80 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 14280 */
  offset: 14280,
  buffer: buffer13,
}, {width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture116,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 2},
  aspect: 'all',
}, arrayBuffer4, /* required buffer size: 338 */
{offset: 338, bytesPerRow: 328, rowsPerImage: 221}, {width: 7, height: 5, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas20);
let textureView215 = texture106.createView({label: '\u1f8d\u64e4\uce68', baseMipLevel: 0});
let gpuCanvasContext24 = offscreenCanvas22.getContext('webgpu');
let videoFrame20 = new VideoFrame(imageBitmap9, {timestamp: 0});
let commandEncoder182 = device1.createCommandEncoder({label: '\uc681\u97b9\u49d8\u{1f680}\u{1f678}\ufb78\u0dd1\uae3f\u00b8'});
let textureView216 = texture78.createView({label: '\u{1f7ad}\uca95\u0c86\udea9\u05db\ud6dd', dimension: '2d-array'});
let computePassEncoder97 = commandEncoder165.beginComputePass({});
try {
renderBundleEncoder85.setBindGroup(0, bindGroup46);
} catch {}
try {
renderBundleEncoder78.setVertexBuffer(3, buffer13, 53_956, 53_768);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
try {
commandEncoder88.copyTextureToTexture({
  texture: texture116,
  mipLevel: 1,
  origin: {x: 5, y: 4, z: 10},
  aspect: 'all',
},
{
  texture: texture112,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 3, height: 1, depthOrArrayLayers: 1});
} catch {}
let offscreenCanvas23 = new OffscreenCanvas(413, 171);
try {
offscreenCanvas18.getContext('webgpu');
} catch {}
let pipelineLayout17 = device4.createPipelineLayout({
  label: '\u098a\u0206\u062c\u7815\u3534\ucb4e',
  bindGroupLayouts: [bindGroupLayout51, bindGroupLayout51],
});
let renderBundle118 = renderBundleEncoder94.finish({label: '\u40e7\u01c0'});
try {
renderBundleEncoder95.setVertexBuffer(4_294_967_295, undefined, 0);
} catch {}
try {
gpuCanvasContext3.configure({device: device4, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, colorSpace: 'display-p3'});
} catch {}
try {
  await device4.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder183 = device2.createCommandEncoder({label: '\u6cce\u0ee2\u0ab8\u005c\u02a8\u0fa7\uda72\u4d27\ucf37\udd5c\u203c'});
let texture117 = device2.createTexture({
  label: '\uac4e\u{1fdc9}\u0756\u3432\uae18\ua0f4\u{1f718}\u1fc1\u06e1\u0b8f',
  size: [720, 1, 493],
  mipLevelCount: 6,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder98 = commandEncoder154.beginComputePass({label: '\u9638\u007c\u049f\u0bde\u1ffc\u01eb\u0baa\u{1f874}\u{1f680}'});
let externalTexture100 = device2.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'});
try {
renderBundleEncoder90.setPipeline(pipeline133);
} catch {}
try {
commandEncoder183.resolveQuerySet(querySet67, 528, 32, buffer23, 161280);
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
let promise58 = device4.queue.onSubmittedWorkDone();
try {
  await promise54;
} catch {}
let img18 = await imageWithData(249, 58, '#2feb34a5', '#4d43d8f4');
let commandEncoder184 = device2.createCommandEncoder({});
let renderBundle119 = renderBundleEncoder64.finish({label: '\u9ea0\ud91a\ua0be\u3313\u3bc1\u4d35\u3ce5'});
let externalTexture101 = device2.importExternalTexture({
  label: '\u5cd1\u2e43\u{1fae2}\u02da\uf71a\u2919\u0e99',
  source: videoFrame19,
  colorSpace: 'display-p3',
});
try {
computePassEncoder75.setPipeline(pipeline130);
} catch {}
try {
renderBundleEncoder87.setBindGroup(1, bindGroup47, []);
} catch {}
try {
commandEncoder184.resolveQuerySet(querySet75, 282, 292, buffer23, 38912);
} catch {}
try {
device2.queue.submit([commandBuffer33]);
} catch {}
let videoFrame21 = new VideoFrame(canvas7, {timestamp: 0});
let texture118 = device2.createTexture({
  label: '\u6047\u356a\u{1f76b}\u08d4',
  size: {width: 24, height: 16, depthOrArrayLayers: 104},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView217 = texture84.createView({
  label: '\u238f\u{1f9b1}\u9d04\u{1fa06}\u{1fef5}\ue17e\uf742\u933d\u{1f955}\u8f1f\u02b1',
  dimension: '2d',
  format: 'rgba8unorm-srgb',
  baseMipLevel: 5,
  mipLevelCount: 1,
  baseArrayLayer: 46,
});
try {
computePassEncoder87.setBindGroup(1, bindGroup65);
} catch {}
try {
computePassEncoder75.setBindGroup(2, bindGroup51, new Uint32Array(8203), 6326, 0);
} catch {}
try {
renderBundleEncoder83.setBindGroup(1, bindGroup47);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture95,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer10, /* required buffer size: 9_783_885 */
{offset: 277, bytesPerRow: 1493, rowsPerImage: 234}, {width: 368, height: 1, depthOrArrayLayers: 29});
} catch {}
try {
gpuCanvasContext10.unconfigure();
} catch {}
try {
adapter2.label = '\u{1f7dc}\uf299\u0bf0\u{1fdb7}\u059e';
} catch {}
let commandEncoder185 = device0.createCommandEncoder({label: '\u05f6\ub9c6\u2522\u{1f690}\u0cf3'});
let texture119 = device0.createTexture({
  label: '\u0414\uc112\u626a',
  size: {width: 660},
  dimension: '1d',
  format: 'rgba16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView218 = texture8.createView({baseMipLevel: 2});
try {
renderPassEncoder8.setBindGroup(1, bindGroup53);
} catch {}
try {
renderBundleEncoder12.setBindGroup(2, bindGroup24, new Uint32Array(136), 63, 0);
} catch {}
try {
renderBundleEncoder50.drawIndexed(1_159, 68, 911, 751_200_341, 65_720_034);
} catch {}
try {
commandEncoder178.copyBufferToTexture({
  /* bytesInLastRow: 1084 widthInBlocks: 542 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 17828 */
  offset: 17828,
  bytesPerRow: 1536,
  buffer: buffer3,
}, {
  texture: texture21,
  mipLevel: 0,
  origin: {x: 7, y: 252, z: 35},
  aspect: 'all',
}, {width: 542, height: 181, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder32.clearBuffer(buffer14, 11468, 9692);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture110,
  mipLevel: 1,
  origin: {x: 3, y: 22, z: 2},
  aspect: 'all',
}, new Float64Array(arrayBuffer7), /* required buffer size: 272_846 */
{offset: 999, bytesPerRow: 249, rowsPerImage: 449}, {width: 94, height: 194, depthOrArrayLayers: 3});
} catch {}
let texture120 = device0.createTexture({
  size: [165, 120, 124],
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba16float'],
});
let computePassEncoder99 = commandEncoder67.beginComputePass();
let renderBundleEncoder96 = device0.createRenderBundleEncoder({
  label: '\u{1fdd2}\uf466\u6b23\u0bdf',
  colorFormats: ['rg16float', 'rgba16float'],
  depthReadOnly: true,
  stencilReadOnly: false,
});
let externalTexture102 = device0.importExternalTexture({
  label: '\u1704\u29e2\u0dd7\ue9b1\u0697\u021a\u{1f67e}\u{1fe48}\u{1fc49}\u4a45\u2711',
  source: videoFrame15,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder25.setBindGroup(3, bindGroup31);
} catch {}
try {
renderBundleEncoder12.setBindGroup(3, bindGroup1, new Uint32Array(8380), 3330, 0);
} catch {}
try {
renderBundleEncoder29.drawIndexed(3_096, 294, 2_181, 188_449_419, 952_329_902);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer11, 109_504);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline19);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder178.copyBufferToTexture({
  /* bytesInLastRow: 316 widthInBlocks: 79 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 275528 */
  offset: 13068,
  bytesPerRow: 512,
  rowsPerImage: 231,
  buffer: buffer5,
}, {
  texture: texture90,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 19},
  aspect: 'all',
}, {width: 79, height: 51, depthOrArrayLayers: 3});
} catch {}
try {
commandEncoder134.resolveQuerySet(querySet51, 37, 2, buffer16, 1536);
} catch {}
let pipeline143 = device0.createRenderPipeline({
  label: '\u32ac\u0ee3\u01cd',
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule8,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'dst-alpha', dstFactor: 'one-minus-src'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rgba8sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'equal',
    stencilFront: {compare: 'greater-equal', failOp: 'keep', depthFailOp: 'increment-clamp', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'never', failOp: 'decrement-wrap', depthFailOp: 'replace', passOp: 'zero'},
    stencilWriteMask: 3654991486,
    depthBiasSlopeScale: 330.6873062661993,
    depthBiasClamp: 334.19103849143704,
  },
  vertex: {
    module: shaderModule8,
    buffers: [
      {arrayStride: 404, stepMode: 'vertex', attributes: []},
      {arrayStride: 92, attributes: []},
      {arrayStride: 272, stepMode: 'instance', attributes: []},
      {arrayStride: 172, stepMode: 'instance', attributes: []},
      {arrayStride: 140, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 64, stepMode: 'instance', attributes: []},
      {
        arrayStride: 124,
        attributes: [
          {format: 'uint16x4', offset: 32, shaderLocation: 5},
          {format: 'snorm8x2', offset: 6, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'},
});
let gpuCanvasContext25 = offscreenCanvas19.getContext('webgpu');
let videoFrame22 = new VideoFrame(canvas2, {timestamp: 0});
try {
adapter2.label = '\u15d1\u{1fcb6}\uc5a6';
} catch {}
let textureView219 = texture118.createView({label: '\u7678\u748a\u{1f9fa}'});
let computePassEncoder100 = commandEncoder169.beginComputePass();
try {
computePassEncoder82.end();
} catch {}
try {
computePassEncoder74.setPipeline(pipeline134);
} catch {}
try {
renderBundleEncoder76.setBindGroup(2, bindGroup50, new Uint32Array(9445), 7579, 0);
} catch {}
try {
renderBundleEncoder87.setPipeline(pipeline133);
} catch {}
try {
commandEncoder164.copyBufferToBuffer(buffer22, 271724, buffer23, 468960, 28592);
} catch {}
let offscreenCanvas24 = new OffscreenCanvas(163, 746);
let bindGroupLayout52 = pipeline69.getBindGroupLayout(1);
let texture121 = device1.createTexture({
  label: '\ua292\u7dca\u02d9\u00fd',
  size: {width: 275, height: 3, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder101 = commandEncoder61.beginComputePass({label: '\u5281\u0296\u7277\udd11\u078c\u64fe\u{1fb7e}\u6997\u43e2\u08e8\ua1f6'});
let renderBundle120 = renderBundleEncoder51.finish({label: '\u{1f6bb}\u{1f74b}\u0246\u1d6d\u628d\u{1fd29}'});
try {
renderBundleEncoder52.setBindGroup(0, bindGroup30);
} catch {}
try {
texture64.destroy();
} catch {}
try {
commandEncoder182.resolveQuerySet(querySet59, 4, 30, buffer18, 23296);
} catch {}
try {
commandEncoder176.insertDebugMarker('\u10a4');
} catch {}
try {
gpuCanvasContext5.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let promise59 = adapter0.requestAdapterInfo();
try {
offscreenCanvas24.getContext('webgl');
} catch {}
try {
computePassEncoder24.dispatchWorkgroups(3);
} catch {}
try {
computePassEncoder58.setPipeline(pipeline35);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle69, renderBundle117, renderBundle69, renderBundle73]);
} catch {}
try {
renderPassEncoder6.setStencilReference(712);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(1, buffer5);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(6, buffer9, 0);
} catch {}
try {
commandEncoder178.copyTextureToTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 163, y: 157, z: 54},
  aspect: 'all',
},
{
  texture: texture58,
  mipLevel: 0,
  origin: {x: 1, y: 5, z: 331},
  aspect: 'all',
},
{width: 119, height: 21, depthOrArrayLayers: 23});
} catch {}
try {
commandEncoder118.clearBuffer(buffer9, 318556);
} catch {}
try {
commandEncoder52.resolveQuerySet(querySet64, 61, 76, buffer0, 17664);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture22,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 5},
  aspect: 'depth-only',
}, arrayBuffer6, /* required buffer size: 1_721_648 */
{offset: 546, bytesPerRow: 267, rowsPerImage: 161}, {width: 10, height: 7, depthOrArrayLayers: 41});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 124}
*/
{
  source: canvas19,
  origin: { x: 1, y: 2 },
  flipY: true,
}, {
  texture: texture81,
  mipLevel: 0,
  origin: {x: 65, y: 34, z: 17},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 19, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline144 = await promise56;
let textureView220 = texture118.createView({label: '\u0a84\ub332\u058b\u0bae\u2104\uc190\u0957\u{1ff93}', mipLevelCount: 2});
try {
buffer27.unmap();
} catch {}
try {
commandEncoder164.clearBuffer(buffer23, 446148, 81788);
} catch {}
let pipeline145 = device2.createRenderPipeline({
  label: '\ua7e2\u2596\u6439\u{1fe8b}\u00c3\ua73b',
  layout: pipelineLayout16,
  multisample: {mask: 0xb5c6f2d2},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'zero'},
  },
}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA,
}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE,
}, {format: 'r8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'dst', dstFactor: 'dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'equal', failOp: 'zero', depthFailOp: 'replace', passOp: 'increment-wrap'},
    stencilBack: {compare: 'greater-equal', failOp: 'zero', depthFailOp: 'zero', passOp: 'increment-clamp'},
    stencilReadMask: 1193846653,
    stencilWriteMask: 2677106872,
    depthBiasClamp: -98.58162936383398,
  },
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 372, attributes: []},
      {arrayStride: 388, stepMode: 'instance', attributes: []},
      {arrayStride: 708, attributes: []},
      {arrayStride: 144, stepMode: 'instance', attributes: []},
      {
        arrayStride: 224,
        stepMode: 'instance',
        attributes: [{format: 'uint32x4', offset: 12, shaderLocation: 13}],
      },
      {arrayStride: 80, stepMode: 'instance', attributes: []},
      {arrayStride: 208, attributes: []},
      {arrayStride: 0, attributes: [{format: 'unorm10-10-10-2', offset: 1900, shaderLocation: 0}]},
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw'},
});
let commandEncoder186 = device2.createCommandEncoder();
let sampler80 = device2.createSampler({
  label: '\u0c27\u{1f72c}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 86.84,
  lodMaxClamp: 87.38,
  maxAnisotropy: 18,
});
try {
computePassEncoder74.setBindGroup(3, bindGroup65);
} catch {}
try {
renderBundleEncoder87.setBindGroup(3, bindGroup50);
} catch {}
try {
commandEncoder183.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 18104 */
  offset: 18048,
  bytesPerRow: 512,
  buffer: buffer23,
}, {
  texture: texture93,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 14, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder186.clearBuffer(buffer23, 491904, 5620);
} catch {}
let pipeline146 = await device2.createComputePipelineAsync({
  label: '\u{1fb95}\ud2aa\ud40d\u2e2c\u08da\u018a',
  layout: pipelineLayout12,
  compute: {module: shaderModule28, entryPoint: 'compute0', constants: {}},
});
let canvas30 = document.createElement('canvas');
let videoFrame23 = new VideoFrame(imageBitmap7, {timestamp: 0});
let renderBundleEncoder97 = device4.createRenderBundleEncoder({
  label: '\u{1fad0}\u{1fd0f}\u033d\u{1fc7d}\u{1fd40}\u0f64\u{1fdca}\ue91b',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
});
let promise60 = device4.queue.onSubmittedWorkDone();
let img19 = await imageWithData(235, 15, '#8d2930ab', '#1acb72d8');
let videoFrame24 = new VideoFrame(img0, {timestamp: 0});
let bindGroupLayout53 = device3.createBindGroupLayout({
  label: '\ucaa0\u07f3\u00b5',
  entries: [
    {
      binding: 381,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 655,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true },
    },
    {binding: 132, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }},
  ],
});
let querySet89 = device3.createQuerySet({label: '\u{1f673}\u25f4\u87d2\u9839\u{1f6f1}', type: 'occlusion', count: 4041});
let texture122 = gpuCanvasContext5.getCurrentTexture();
let textureView221 = texture122.createView({label: '\u71cc\u3f49\u{1fd42}\uf3fd', format: 'rgba8unorm-srgb'});
let renderBundleEncoder98 = device3.createRenderBundleEncoder({
  label: '\u{1f9bf}\ubdc8',
  colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'],
  stencilReadOnly: true,
});
let renderBundle121 = renderBundleEncoder86.finish({label: '\u0e24\u{1f709}'});
let sampler81 = device3.createSampler({
  label: '\u5e5a\u{1f963}\u{1fa0a}\u0be0\u5b18\ubcdd\u{1f693}\u91a3',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  lodMaxClamp: 96.18,
});
try {
computePassEncoder85.setBindGroup(2, bindGroup64, []);
} catch {}
try {
renderBundleEncoder98.setVertexBuffer(1, undefined);
} catch {}
try {
device3.queue.submit([commandBuffer41]);
} catch {}
try {
canvas29.getContext('webgpu');
} catch {}
let buffer31 = device1.createBuffer({
  label: '\u{1f8ff}\u{1fdfd}\u{1fe28}',
  size: 95478,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandBuffer43 = commandEncoder149.finish({label: '\u0d3c\u09f0\u1a1c\u7b9d\ubdac\u39b9\u40d3'});
let computePassEncoder102 = commandEncoder181.beginComputePass({label: '\u051e\ua965\u0ce8'});
try {
renderBundleEncoder68.setIndexBuffer(buffer28, 'uint16', 10_614, 974);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(7, buffer13, 31_888, 41_347);
} catch {}
try {
commandEncoder88.copyBufferToBuffer(buffer31, 73536, buffer12, 492, 2576);
} catch {}
try {
commandEncoder146.copyBufferToTexture({
  /* bytesInLastRow: 242 widthInBlocks: 121 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 666 */
  offset: 666,
  buffer: buffer15,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {width: 121, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder116.copyTextureToBuffer({
  texture: texture68,
  mipLevel: 1,
  origin: {x: 6, y: 15, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 352 widthInBlocks: 88 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 18364 */
  offset: 18012,
  rowsPerImage: 193,
  buffer: buffer28,
}, {width: 88, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder124.clearBuffer(buffer28, 14232, 592);
} catch {}
let pipeline147 = device1.createRenderPipeline({
  label: '\u045f\u0201\u0a40\ub75f\u7c9a\u7cae\u{1fc71}',
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule33,
  entryPoint: 'fragment0',
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r32sint'}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'greater', failOp: 'zero', passOp: 'increment-wrap'},
    stencilBack: {compare: 'less', failOp: 'increment-clamp', depthFailOp: 'invert', passOp: 'increment-wrap'},
    stencilReadMask: 2089139682,
    stencilWriteMask: 3067555864,
    depthBias: -917145539,
    depthBiasSlopeScale: 518.8038036719149,
    depthBiasClamp: 317.8797330199858,
  },
  vertex: {
    module: shaderModule33,
    buffers: [
      {arrayStride: 1004, stepMode: 'instance', attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 876, attributes: []},
      {arrayStride: 136, stepMode: 'instance', attributes: []},
      {arrayStride: 756, stepMode: 'instance', attributes: []},
      {arrayStride: 188, stepMode: 'instance', attributes: []},
      {arrayStride: 144, attributes: []},
      {
        arrayStride: 140,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x4', offset: 8, shaderLocation: 11}],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16'},
});
let texture123 = gpuCanvasContext3.getCurrentTexture();
let renderBundle122 = renderBundleEncoder9.finish({});
try {
computePassEncoder24.setBindGroup(3, bindGroup29, new Uint32Array(1910), 185, 0);
} catch {}
try {
computePassEncoder10.setPipeline(pipeline104);
} catch {}
try {
renderPassEncoder8.setBindGroup(0, bindGroup21, new Uint32Array(2238), 1573, 0);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle69, renderBundle69, renderBundle117, renderBundle69, renderBundle69, renderBundle117]);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1, buffer6);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer10, 22_292);
} catch {}
try {
renderBundleEncoder96.setIndexBuffer(buffer3, 'uint32', 11_716, 801);
} catch {}
let pipeline148 = device0.createRenderPipeline({
  label: '\u{1f816}\u07c2\ube7d\ud4e5\u{1f74b}\u88f1\u07e2\u071a',
  layout: pipelineLayout6,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'greater-equal', failOp: 'invert', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'not-equal', failOp: 'increment-clamp', depthFailOp: 'decrement-wrap', passOp: 'zero'},
    stencilReadMask: 3535561780,
    stencilWriteMask: 3429760405,
    depthBias: 654824380,
    depthBiasClamp: 522.2997893187605,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 212, attributes: []},
      {
        arrayStride: 108,
        attributes: [
          {format: 'uint16x2', offset: 12, shaderLocation: 6},
          {format: 'uint16x2', offset: 0, shaderLocation: 0},
          {format: 'unorm10-10-10-2', offset: 52, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 44,
        stepMode: 'instance',
        attributes: [{format: 'float32x3', offset: 4, shaderLocation: 2}],
      },
      {arrayStride: 760, attributes: [{format: 'unorm10-10-10-2', offset: 184, shaderLocation: 15}]},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x2', offset: 0, shaderLocation: 7}],
      },
      {arrayStride: 392, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 340, shaderLocation: 12},
          {format: 'float16x4', offset: 76, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 56,
        attributes: [
          {format: 'sint8x4', offset: 16, shaderLocation: 13},
          {format: 'sint16x4', offset: 0, shaderLocation: 1},
          {format: 'uint32x4', offset: 0, shaderLocation: 14},
          {format: 'uint32x4', offset: 28, shaderLocation: 10},
          {format: 'unorm8x4', offset: 48, shaderLocation: 3},
          {format: 'uint8x4', offset: 0, shaderLocation: 4},
          {format: 'sint32x2', offset: 0, shaderLocation: 11},
          {format: 'snorm8x2', offset: 4, shaderLocation: 9},
        ],
      },
    ],
  },
});
let videoFrame25 = new VideoFrame(videoFrame16, {timestamp: 0});
let buffer32 = device1.createBuffer({
  label: '\u4363\u02f8\u2c4f\u0b27\u{1ffcd}\uda49\u{1fe3a}\u3f5c\u1ea4\u608a',
  size: 127760,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: true,
});
let commandEncoder187 = device1.createCommandEncoder();
let textureView222 = texture50.createView({dimension: '2d-array', format: 'r32sint', mipLevelCount: 2, arrayLayerCount: 1});
try {
renderBundleEncoder34.draw(1, 0, 1, 0);
} catch {}
try {
commandEncoder76.copyBufferToTexture({
  /* bytesInLastRow: 14 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 20300 */
  offset: 20300,
  bytesPerRow: 256,
  buffer: buffer31,
}, {
  texture: texture54,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 7, height: 9, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder124.copyTextureToTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 105, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture50,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder182.clearBuffer(buffer13);
} catch {}
try {
device1.queue.writeBuffer(buffer13, 20848, new BigUint64Array(8307));
} catch {}
try {
canvas30.getContext('webgl2');
} catch {}
let textureView223 = texture78.createView({mipLevelCount: 2});
let renderBundleEncoder99 = device1.createRenderBundleEncoder({
  label: '\u8149\u6c22',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder34.drawIndexedIndirect(buffer15, 5_520);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer13, 130_468);
} catch {}
try {
renderBundleEncoder63.setVertexBuffer(0, buffer13);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture48,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(new ArrayBuffer(24)), /* required buffer size: 464 */
{offset: 464}, {width: 4, height: 0, depthOrArrayLayers: 1});
} catch {}
let bindGroup66 = device1.createBindGroup({
  label: '\u0c66\u{1fe3e}\u804f\u{1f933}\u92f1\u0b3d\ue683\u1d67\u6a55\u0f29',
  layout: bindGroupLayout46,
  entries: [],
});
let textureView224 = texture49.createView({label: '\uf539\u{1f6ff}\u0eff\u7cef\u{1faae}\ue9c8', format: 'rg8uint', baseMipLevel: 2});
let computePassEncoder103 = commandEncoder146.beginComputePass({label: '\u{1f9e7}\ucfde\u5998'});
try {
renderBundleEncoder73.setPipeline(pipeline120);
} catch {}
try {
renderBundleEncoder78.setVertexBuffer(7, buffer12, 0, 871);
} catch {}
try {
commandEncoder124.copyBufferToTexture({
  /* bytesInLastRow: 544 widthInBlocks: 68 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 29376 */
  offset: 29376,
  buffer: buffer18,
}, {
  texture: texture121,
  mipLevel: 1,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 68, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder116.resolveQuerySet(querySet47, 1485, 68, buffer31, 4096);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(arrayBuffer11), /* required buffer size: 81 */
{offset: 81, rowsPerImage: 185}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline149 = device1.createComputePipeline({
  label: '\u08bc\udbfd\u8d99\u0e6f\u572c\u0773\u{1f66c}\u57c9',
  layout: pipelineLayout7,
  compute: {module: shaderModule11, entryPoint: 'compute0', constants: {}},
});
let video28 = await videoWithData();
let buffer33 = device2.createBuffer({
  label: '\u1e8a\u45e3\uee00\u19a7\u0aad\ueb76\u8014\u3366\u0fe5\u{1f8f4}',
  size: 193186,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let commandEncoder188 = device2.createCommandEncoder({label: '\u5afb\u{1ffb4}\u0c21\u0bc2'});
let querySet90 = device2.createQuerySet({type: 'occlusion', count: 1524});
let renderBundle123 = renderBundleEncoder66.finish();
try {
computePassEncoder73.dispatchWorkgroupsIndirect(buffer23, 134996);
} catch {}
try {
commandEncoder186.copyBufferToBuffer(buffer23, 212796, buffer33, 124164, 63152);
} catch {}
try {
commandEncoder184.resolveQuerySet(querySet86, 2, 1, buffer23, 73728);
} catch {}
let pipeline150 = await device2.createComputePipelineAsync({
  label: '\u93cf\u12a0\u88e5\u{1ff83}\ub5c0',
  layout: pipelineLayout13,
  compute: {module: shaderModule28, entryPoint: 'compute0', constants: {}},
});
let shaderModule34 = device4.createShaderModule({
  label: '\u{1f84e}\u8913\u{1ff46}\u028f\u0558\uad9e\u7afd\u0a75\u77b3\u0f8e\u0c34',
  code: `@group(1) @binding(910)
var<storage, read_write> n14: array<u32>;
@group(0) @binding(910)
var<storage, read_write> parameter14: array<u32>;
@group(1) @binding(386)
var<storage, read_write> n15: array<u32>;
@group(0) @binding(386)
var<storage, read_write> field6: array<u32>;

@compute @workgroup_size(8, 2, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(4) f0: vec2<i32>,
  @location(3) f1: vec3<f32>,
  @location(2) f2: vec3<f32>,
  @location(5) f3: vec3<f32>,
  @location(0) f4: vec4<u32>,
  @builtin(sample_mask) f5: u32
}

@fragment
fn fragment0(@location(11) a0: i32, @location(2) a1: vec3<u32>, @location(9) a2: vec4<u32>, @builtin(position) a3: vec4<f32>, @location(6) a4: vec4<f32>, @location(1) a5: vec4<u32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S31 {
  @location(2) f0: vec4<i32>,
  @location(12) f1: vec3<f16>,
  @builtin(instance_index) f2: u32
}
struct VertexOutput0 {
  @location(1) f183: vec4<u32>,
  @builtin(position) f184: vec4<f32>,
  @location(6) f185: vec4<f32>,
  @location(5) f186: vec3<i32>,
  @location(4) f187: vec2<f32>,
  @location(14) f188: vec3<i32>,
  @location(15) f189: vec3<f16>,
  @location(7) f190: vec3<f32>,
  @location(11) f191: i32,
  @location(9) f192: vec4<u32>,
  @location(12) f193: vec2<f16>,
  @location(13) f194: vec4<u32>,
  @location(10) f195: f32,
  @location(3) f196: vec3<u32>,
  @location(0) f197: vec4<f32>,
  @location(2) f198: vec3<u32>
}

@vertex
fn vertex0(@location(10) a0: vec4<f32>, @location(11) a1: vec2<u32>, @location(15) a2: vec4<f32>, @builtin(vertex_index) a3: u32, @location(7) a4: vec3<f32>, @location(5) a5: vec4<i32>, @location(9) a6: vec4<f32>, @location(3) a7: vec2<f32>, a8: S31, @location(14) a9: vec2<f32>, @location(13) a10: f32, @location(6) a11: vec3<f16>, @location(8) a12: vec4<f16>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout54 = device4.createBindGroupLayout({
  label: '\u1625\u0fa2\u{1fc15}',
  entries: [
    {binding: 142, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 863,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 571,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true },
    },
  ],
});
let externalTexture103 = device4.importExternalTexture({label: '\u{1fa0e}\ue6b2\u{1f94b}\u{1fbd3}', source: video7, colorSpace: 'display-p3'});
try {
device4.queue.writeBuffer(buffer30, 101820, new Int16Array(18198), 2174, 300);
} catch {}
let commandEncoder189 = device1.createCommandEncoder({});
let textureView225 = texture96.createView({label: '\u{1fef0}\ua786\ue145\ubb58\u4b3f\u0e49\u221b\uf241\u9209', baseMipLevel: 4, mipLevelCount: 2});
let computePassEncoder104 = commandEncoder176.beginComputePass({});
try {
commandEncoder80.clearBuffer(buffer28, 14088, 14380);
} catch {}
try {
commandEncoder189.resolveQuerySet(querySet33, 1, 5, buffer15, 4864);
} catch {}
let gpuCanvasContext26 = offscreenCanvas23.getContext('webgpu');
let querySet91 = device4.createQuerySet({label: '\u{1f8bd}\u8614\u{1f6ce}', type: 'occlusion', count: 1732});
let texture124 = device4.createTexture({
  label: '\ub97f\uc6bd\ufb8a\u0697\u{1f99c}\u57a5',
  size: [164],
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let texture125 = gpuCanvasContext5.getCurrentTexture();
let textureView226 = texture125.createView({label: '\u06d7\u036f\u{1f912}\u0c6f\u8af4\ua6b5\ub598\uea35\u0a97\u028e\u3d69'});
let pipeline151 = device4.createComputePipeline({layout: pipelineLayout17, compute: {module: shaderModule34, entryPoint: 'compute0', constants: {}}});
gc();
let offscreenCanvas25 = new OffscreenCanvas(803, 157);
let bindGroupLayout55 = pipeline95.getBindGroupLayout(2);
let buffer34 = device0.createBuffer({
  label: '\u{1fa7a}\u0c8d\u0a57\u0669\u{1f705}\u5c22\u3dea\u2efa\ude95\u1ad7',
  size: 438886,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder190 = device0.createCommandEncoder({label: '\u1059\ud757\u{1f832}\u0674\u{1fa9a}\ub80e\u8678\uf7ae'});
try {
renderPassEncoder7.executeBundles([]);
} catch {}
try {
renderPassEncoder7.setScissorRect(113, 16, 41, 0);
} catch {}
try {
renderBundleEncoder50.drawIndexed(2_985, 261, 1_122, 386_285_036, 154_591_047);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture101,
  mipLevel: 0,
  origin: {x: 4, y: 2, z: 742},
  aspect: 'all',
}, new Float64Array(arrayBuffer10), /* required buffer size: 136 */
{offset: 136, bytesPerRow: 2604, rowsPerImage: 311}, {width: 312, height: 220, depthOrArrayLayers: 0});
} catch {}
let commandEncoder191 = device2.createCommandEncoder({label: '\u0c97\uf001\u{1f935}\u339c'});
let texture126 = device2.createTexture({
  size: {width: 180, height: 768, depthOrArrayLayers: 1},
  mipLevelCount: 7,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder100 = device2.createRenderBundleEncoder({
  label: '\u8a14\u{1f974}\ub8d8\u89aa\u0ced\u9786\u0c4e',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
});
try {
computePassEncoder75.setPipeline(pipeline116);
} catch {}
try {
renderBundleEncoder74.setPipeline(pipeline133);
} catch {}
try {
renderBundleEncoder90.setVertexBuffer(4_294_967_295, undefined, 0);
} catch {}
try {
device2.pushErrorScope('internal');
} catch {}
try {
commandEncoder183.copyBufferToBuffer(buffer22, 311816, buffer33, 58828, 8716);
} catch {}
try {
commandEncoder184.copyTextureToTexture({
  texture: texture94,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture97,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
},
{width: 110, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.writeBuffer(buffer33, 71068, new Float32Array(61347), 59891, 240);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture97,
  mipLevel: 0,
  origin: {x: 13, y: 7, z: 0},
  aspect: 'all',
}, new ArrayBuffer(1_681), /* required buffer size: 1_681 */
{offset: 717, bytesPerRow: 359}, {width: 123, height: 3, depthOrArrayLayers: 1});
} catch {}
gc();
let pipelineLayout18 = device0.createPipelineLayout({
  label: '\u0b83\u5d49\u0b9d\u0ffc\u0d2b\u{1f7d6}\u3b9d\u0e4e\u68c1\u9596',
  bindGroupLayouts: [bindGroupLayout5, bindGroupLayout15, bindGroupLayout19],
});
let buffer35 = device0.createBuffer({
  label: '\u0c3b\u905c\u22b6\u0fa2',
  size: 21788,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder192 = device0.createCommandEncoder();
let textureView227 = texture115.createView({
  label: '\u{1ff69}\u616d\u{1fd9a}\ubf22\u{1ffe1}\u964d',
  dimension: '2d',
  baseMipLevel: 1,
  baseArrayLayer: 80,
});
try {
renderPassEncoder7.executeBundles([renderBundle107, renderBundle69]);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: -668.7, g: -975.5, b: 852.9, a: 555.8, });
} catch {}
try {
renderBundleEncoder60.setBindGroup(2, bindGroup19, []);
} catch {}
try {
renderBundleEncoder29.draw(55, 178, 26, 667_693_233);
} catch {}
try {
renderBundleEncoder50.drawIndexed(7_327, 371, 0, -2_107_769_859, 47_084_822);
} catch {}
try {
renderBundleEncoder40.setIndexBuffer(buffer7, 'uint32', 16_384, 21_566);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 812, new BigUint64Array(40275), 8377, 1568);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1320, height: 960, depthOrArrayLayers: 124}
*/
{
  source: imageBitmap6,
  origin: { x: 1, y: 129 },
  flipY: false,
}, {
  texture: texture115,
  mipLevel: 0,
  origin: {x: 147, y: 58, z: 16},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 6, height: 9, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas26 = new OffscreenCanvas(732, 353);
let imageBitmap22 = await createImageBitmap(videoFrame18);
try {
adapter5.label = '\ue6be\u06ec\u0aaf\u8382\u0728';
} catch {}
try {
window.someLabel = device4.queue.label;
} catch {}
try {
window.someLabel = texture125.label;
} catch {}
let texture127 = device4.createTexture({
  size: [328, 6, 1],
  mipLevelCount: 2,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm', 'rg8unorm'],
});
let textureView228 = texture127.createView({label: '\u0e9b\u{1fd5a}\u5707\u3517\u028e\u029a\u036f\u4e59', dimension: '2d-array', baseMipLevel: 1});
let offscreenCanvas27 = new OffscreenCanvas(851, 578);
let imageBitmap23 = await createImageBitmap(imageBitmap6);
let shaderModule35 = device4.createShaderModule({
  label: '\u94c1\u9491\u{1fc8f}\ueb8f',
  code: `@group(0) @binding(386)
var<storage, read_write> n16: array<u32>;
@group(1) @binding(386)
var<storage, read_write> n17: array<u32>;
@group(1) @binding(910)
var<storage, read_write> n18: array<u32>;
@group(0) @binding(910)
var<storage, read_write> parameter15: array<u32>;

@compute @workgroup_size(6, 3, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(5) f0: vec3<f32>,
  @location(2) f1: vec4<f32>,
  @location(4) f2: vec4<i32>,
  @location(1) f3: vec4<i32>,
  @location(0) f4: vec4<u32>,
  @location(3) f5: vec4<f32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0() -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder193 = device4.createCommandEncoder({label: '\u{1fdde}\u08d6\u0576\ua65c\u03f6\u{1f6f5}'});
let textureView229 = texture125.createView({label: '\ud47a\u{1fa6a}', dimension: '2d-array', format: 'rgba8unorm-srgb', arrayLayerCount: 1});
let renderBundleEncoder101 = device4.createRenderBundleEncoder({
  label: '\u7a64\u{1fef2}\u0e7e\u0715',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
});
try {
device4.queue.writeBuffer(buffer30, 25820, new BigUint64Array(43529), 14905, 1556);
} catch {}
let img20 = await imageWithData(135, 103, '#e748804d', '#b6608283');
let video29 = await videoWithData();
let bindGroup67 = device1.createBindGroup({
  label: '\u0126\u22a2\u6582\u650c\uecec\u{1ffae}\ub4f3\udbb8\u51da\u{1fbfe}\u927b',
  layout: bindGroupLayout20,
  entries: [],
});
let commandEncoder194 = device1.createCommandEncoder({label: '\u0cb8\u60ee\u6aa3\u0acc'});
let renderBundle124 = renderBundleEncoder78.finish({label: '\u01a6\ud1c8\u301a\u9eed'});
let sampler82 = device1.createSampler({
  label: '\u5d50\u0d96\u5d9f\uf8d6',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 55.05,
  lodMaxClamp: 98.59,
});
let externalTexture104 = device1.importExternalTexture({label: '\u818a\u0435\u12cf\u9c20', source: videoFrame22, colorSpace: 'srgb'});
try {
renderBundleEncoder73.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder73.setVertexBuffer(4, buffer13, 18_860, 46_729);
} catch {}
try {
device1.queue.writeBuffer(buffer28, 5788, new DataView(new ArrayBuffer(8735)), 1673, 1024);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas5,
  origin: { x: 5, y: 5 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let video30 = await videoWithData();
let commandBuffer44 = commandEncoder129.finish();
try {
renderPassEncoder8.setBlendConstant({ r: 57.59, g: -491.5, b: 280.9, a: 822.8, });
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder89.setBindGroup(0, bindGroup10, new Uint32Array(2482), 1176, 0);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 318_684);
} catch {}
try {
renderBundleEncoder46.setIndexBuffer(buffer6, 'uint32', 3_036, 4_454);
} catch {}
try {
renderBundleEncoder46.setVertexBuffer(7, buffer5, 0, 64_652);
} catch {}
try {
commandEncoder138.copyBufferToBuffer(buffer9, 62896, buffer10, 7212, 22772);
} catch {}
try {
commandEncoder70.copyTextureToTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture123,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder150.clearBuffer(buffer14, 29420, 236);
} catch {}
try {
commandEncoder131.pushDebugGroup('\u76f2');
} catch {}
let promise61 = device0.queue.onSubmittedWorkDone();
try {
window.someLabel = commandEncoder14.label;
} catch {}
let bindGroup68 = device0.createBindGroup({
  label: '\u91f5\u9b7e\ub1ac\u00ad\u954a\u3c88\u3314\u03e8\u{1fa45}\u73ff',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer5, offset: 15616, size: 73788}}],
});
try {
renderPassEncoder8.setBlendConstant({ r: 655.7, g: 129.1, b: 80.75, a: 886.3, });
} catch {}
try {
renderPassEncoder8.setScissorRect(140, 55, 2, 16);
} catch {}
try {
renderPassEncoder7.setIndexBuffer(buffer35, 'uint16', 1_266, 2_080);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline135);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4_294_967_295, undefined, 511_758_865);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer10, 17_024);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer11, 106_468);
} catch {}
try {
commandEncoder185.copyTextureToTexture({
  texture: texture80,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture70,
  mipLevel: 0,
  origin: {x: 60, y: 0, z: 0},
  aspect: 'all',
},
{width: 113, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder18.clearBuffer(buffer6, 20220, 2680);
} catch {}
let pipeline152 = device0.createComputePipeline({
  label: '\u{1fc53}\u07f4',
  layout: pipelineLayout10,
  compute: {module: shaderModule12, entryPoint: 'compute0'},
});
offscreenCanvas14.width = 766;
let commandEncoder195 = device4.createCommandEncoder({label: '\uf12e\u{1fbc5}'});
let textureView230 = texture124.createView({label: '\u{1fdc4}\u01e3\u085b', baseMipLevel: 0, baseArrayLayer: 0});
try {
renderBundleEncoder93.insertDebugMarker('\u0f1e');
} catch {}
try {
device4.queue.writeBuffer(buffer30, 47592, new Float32Array(21858), 1081, 1400);
} catch {}
try {
offscreenCanvas26.getContext('webgl');
} catch {}
let buffer36 = device1.createBuffer({
  label: '\u{1f7b4}\u54d1\u78e0\u14da\u{1fb6a}\u1785',
  size: 47546,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: false,
});
let renderBundleEncoder102 = device1.createRenderBundleEncoder({
  label: '\u016e\u0dd5\u6515\u85a3\ucfa4\u14cc',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  depthReadOnly: true,
});
let sampler83 = device1.createSampler({
  label: '\u{1fec2}\u0c77\u0a85\u0f74\u{1fa17}\u00ae\u7bb6',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 98.53,
  lodMaxClamp: 99.65,
  maxAnisotropy: 18,
});
try {
renderBundleEncoder34.drawIndexedIndirect(buffer19, 248);
} catch {}
try {
renderBundleEncoder99.setVertexBuffer(0, buffer13, 4, 62_468);
} catch {}
try {
buffer12.unmap();
} catch {}
try {
commandEncoder124.copyBufferToBuffer(buffer32, 125756, buffer13, 70048, 1652);
} catch {}
try {
device1.queue.writeBuffer(buffer28, 3176, new Int16Array(59272), 27871, 1956);
} catch {}
try {
adapter4.label = '\u0755\ufd7b';
} catch {}
let buffer37 = device1.createBuffer({
  label: '\u47cb\u845c\u0953\u35d3\u06b1',
  size: 6793,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder196 = device1.createCommandEncoder({label: '\u{1fe29}\ucfd8\u00be\u92ed'});
let textureView231 = texture99.createView({label: '\u{1ff0d}\u047e', dimension: '2d-array', format: 'bgra8unorm-srgb'});
let computePassEncoder105 = commandEncoder126.beginComputePass({});
let renderBundleEncoder103 = device1.createRenderBundleEncoder({
  label: '\u032d\u{1fb6f}\ub4dc\uf7ff\u{1f8e2}\u0e6b\u02b6',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
});
try {
computePassEncoder59.setBindGroup(1, bindGroup30, new Uint32Array(3272), 1788, 0);
} catch {}
try {
computePassEncoder97.end();
} catch {}
try {
renderBundleEncoder85.setBindGroup(2, bindGroup26);
} catch {}
try {
commandEncoder64.copyBufferToTexture({
  /* bytesInLastRow: 976 widthInBlocks: 122 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 1776 */
  offset: 1776,
  buffer: buffer36,
}, {
  texture: texture121,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 122, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline153 = device1.createRenderPipeline({
  layout: 'auto',
  multisample: {count: 4, mask: 0xe527c2d7},
  fragment: {
  module: shaderModule30,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rg16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilFront: {compare: 'less', failOp: 'increment-clamp', depthFailOp: 'increment-wrap', passOp: 'increment-clamp'},
    stencilBack: {compare: 'less', failOp: 'increment-clamp', depthFailOp: 'increment-clamp', passOp: 'replace'},
    stencilReadMask: 1101726457,
  },
  vertex: {
    module: shaderModule30,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 160,
        attributes: [
          {format: 'sint32x4', offset: 20, shaderLocation: 0},
          {format: 'sint8x2', offset: 32, shaderLocation: 4},
          {format: 'float32', offset: 8, shaderLocation: 14},
        ],
      },
      {arrayStride: 704, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 140, shaderLocation: 1},
          {format: 'snorm8x4', offset: 208, shaderLocation: 8},
          {format: 'float32x2', offset: 360, shaderLocation: 5},
        ],
      },
      {arrayStride: 148, attributes: [{format: 'uint32x3', offset: 36, shaderLocation: 13}]},
      {arrayStride: 768, attributes: []},
      {arrayStride: 44, attributes: []},
      {arrayStride: 528, stepMode: 'instance', attributes: []},
      {
        arrayStride: 132,
        attributes: [
          {format: 'snorm16x4', offset: 12, shaderLocation: 2},
          {format: 'uint8x2', offset: 8, shaderLocation: 9},
          {format: 'float16x2', offset: 8, shaderLocation: 6},
          {format: 'sint32x3', offset: 28, shaderLocation: 7},
          {format: 'float32x4', offset: 32, shaderLocation: 12},
          {format: 'uint8x4', offset: 36, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', cullMode: 'back'},
});
try {
offscreenCanvas27.getContext('2d');
} catch {}
try {
commandEncoder195.copyTextureToBuffer({
  texture: texture125,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 160 */
  offset: 160,
  buffer: buffer30,
}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder193.clearBuffer(buffer30, 127012, 57300);
} catch {}
let pipeline154 = device4.createComputePipeline({layout: pipelineLayout17, compute: {module: shaderModule34, entryPoint: 'compute0', constants: {}}});
let promise62 = adapter3.requestAdapterInfo();
try {
computePassEncoder33.setBindGroup(1, bindGroup12, new Uint32Array(2305), 1428, 0);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup34);
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle42, renderBundle69, renderBundle117, renderBundle69, renderBundle42]);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline135);
} catch {}
try {
renderBundleEncoder50.setVertexBuffer(5, buffer5, 71_656);
} catch {}
try {
commandEncoder121.clearBuffer(buffer34, 64668, 120336);
} catch {}
let promise63 = device0.createRenderPipelineAsync({
  label: '\ue590\u6e3e\u{1fc00}\ud772\u29ea\u2469\u0f9a\u{1f8d7}',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule9,
    buffers: [
      {arrayStride: 0, attributes: []},
      {arrayStride: 20, attributes: []},
      {arrayStride: 324, attributes: [{format: 'sint8x4', offset: 44, shaderLocation: 1}]},
      {
        arrayStride: 152,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 8, shaderLocation: 15},
          {format: 'uint32x4', offset: 4, shaderLocation: 10},
        ],
      },
      {arrayStride: 100, stepMode: 'instance', attributes: []},
      {arrayStride: 48, stepMode: 'instance', attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint8x4', offset: 824, shaderLocation: 11},
          {format: 'uint32x3', offset: 52, shaderLocation: 6},
          {format: 'unorm8x4', offset: 128, shaderLocation: 9},
          {format: 'unorm16x4', offset: 52, shaderLocation: 5},
          {format: 'unorm16x4', offset: 76, shaderLocation: 7},
          {format: 'snorm16x2', offset: 368, shaderLocation: 2},
          {format: 'unorm16x2', offset: 56, shaderLocation: 8},
          {format: 'uint8x4', offset: 348, shaderLocation: 0},
          {format: 'uint32x4', offset: 172, shaderLocation: 4},
          {format: 'snorm8x2', offset: 1982, shaderLocation: 3},
          {format: 'sint32x2', offset: 12, shaderLocation: 13},
          {format: 'unorm16x4', offset: 504, shaderLocation: 12},
          {format: 'uint8x2', offset: 530, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: false},
});
let gpuCanvasContext27 = offscreenCanvas21.getContext('webgpu');
let querySet92 = device4.createQuerySet({label: '\u08a0\ub279\u6533\u079c\u02b8\ubf67\u000e', type: 'occlusion', count: 1188});
let textureView232 = texture127.createView({label: '\u0aab\u42d2\u5809\uf21b\u{1f950}\u{1f74f}\uc62b\u{1f732}', dimension: '2d-array'});
let computePassEncoder106 = commandEncoder193.beginComputePass();
let sampler84 = device4.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMinClamp: 97.38, lodMaxClamp: 98.72});
try {
computePassEncoder106.end();
} catch {}
try {
querySet92.destroy();
} catch {}
let pipeline155 = device4.createRenderPipeline({
  label: '\ufa65\u2e85\u45ef\udd5e\u{1fdd0}\u258c\u06f4',
  layout: 'auto',
  fragment: {
  module: shaderModule34,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint'}, {format: 'rgba8sint', writeMask: 0}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'subtract', srcFactor: 'src', dstFactor: 'src'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-constant'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg8sint', writeMask: 0}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'zero'},
    alpha: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'never', depthFailOp: 'decrement-clamp', passOp: 'invert'},
    stencilBack: {compare: 'not-equal', failOp: 'decrement-clamp', depthFailOp: 'zero', passOp: 'decrement-wrap'},
    stencilReadMask: 3160970299,
    stencilWriteMask: 4076484484,
    depthBias: -1716757513,
    depthBiasSlopeScale: 707.6728555132986,
  },
  vertex: {
    module: shaderModule34,
    buffers: [
      {
        arrayStride: 476,
        stepMode: 'vertex',
        attributes: [{format: 'float32x2', offset: 108, shaderLocation: 14}],
      },
      {arrayStride: 600, attributes: [{format: 'uint8x4', offset: 192, shaderLocation: 11}]},
      {
        arrayStride: 484,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 100, shaderLocation: 12},
          {format: 'float32x3', offset: 44, shaderLocation: 10},
          {format: 'sint32', offset: 24, shaderLocation: 2},
        ],
      },
      {
        arrayStride: 1300,
        attributes: [
          {format: 'snorm8x2', offset: 26, shaderLocation: 6},
          {format: 'float32', offset: 344, shaderLocation: 13},
        ],
      },
      {arrayStride: 396, stepMode: 'vertex', attributes: []},
      {arrayStride: 104, stepMode: 'vertex', attributes: []},
      {arrayStride: 0, attributes: [{format: 'snorm8x4', offset: 48, shaderLocation: 3}]},
      {
        arrayStride: 408,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 180, shaderLocation: 15},
          {format: 'sint32', offset: 16, shaderLocation: 5},
          {format: 'float32', offset: 60, shaderLocation: 8},
          {format: 'float32', offset: 4, shaderLocation: 9},
          {format: 'snorm16x2', offset: 80, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', cullMode: 'back'},
});
let bindGroup69 = device3.createBindGroup({
  label: '\u6c66\u0660\uc9ea\u706f\uaa7b\uf82b\u937f\u00c0\u{1fd3e}\u060b',
  layout: bindGroupLayout48,
  entries: [],
});
let buffer38 = device3.createBuffer({size: 137678, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder197 = device3.createCommandEncoder({label: '\uf3f7\uaf46\u06c7\u6f4c'});
let computePassEncoder107 = commandEncoder172.beginComputePass({label: '\u0121\u83e5\u7dec\u8e8f\u0eaa\u{1fd64}\uf5dc\u{1f850}\uc794\u{1f7f3}'});
try {
commandEncoder171.copyTextureToTexture({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder168.clearBuffer(buffer38, 55052, 6188);
} catch {}
let bindGroup70 = device0.createBindGroup({
  label: '\uc4f7\ud651\u0f45\uf39c\uf7e1\u060e\u0fa8\ua3d6',
  layout: bindGroupLayout30,
  entries: [{binding: 319, resource: {buffer: buffer35, offset: 17920, size: 3360}}],
});
let commandEncoder198 = device0.createCommandEncoder({label: '\u00b9\u5c2e\u{1f719}\u56f6\u5145\u{1f76c}\u58bf\u07c8\u53a5\u0412'});
let texture128 = device0.createTexture({
  label: '\u0a1c\u113d\u0642\uc6b6\u1206\u{1fa54}\uc201\uf951',
  size: {width: 165},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rg8uint'],
});
try {
renderPassEncoder7.executeBundles([renderBundle117, renderBundle107, renderBundle107]);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: -737.1, g: -945.2, b: 950.6, a: -248.6, });
} catch {}
try {
renderPassEncoder8.setScissorRect(93, 103, 5, 10);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer34, 'uint16', 97_406, 25_442);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(7, buffer4, 0);
} catch {}
try {
commandEncoder20.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 27862 */
  offset: 18646,
  bytesPerRow: 512,
  rowsPerImage: 1,
  buffer: buffer5,
}, {
  texture: texture27,
  mipLevel: 5,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 19});
} catch {}
try {
commandEncoder95.clearBuffer(buffer14, 17144, 17048);
} catch {}
try {
commandEncoder13.resolveQuerySet(querySet25, 132, 310, buffer1, 2816);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 1192}
*/
{
  source: imageBitmap6,
  origin: { x: 2, y: 2 },
  flipY: true,
}, {
  texture: texture58,
  mipLevel: 0,
  origin: {x: 88, y: 0, z: 163},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 13, depthOrArrayLayers: 0});
} catch {}
try {
  await promise59;
} catch {}
let video31 = await videoWithData();
let bindGroup71 = device3.createBindGroup({
  label: '\u0fe9\ubfc7\u{1fe2d}\u{1fc6a}\u049e\u07ed\u1662\uae4c\u5c0e\ua437\u0637',
  layout: bindGroupLayout48,
  entries: [],
});
let buffer39 = device3.createBuffer({label: '\u{1fae0}\ucbd1\u3ba5', size: 443731, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE});
let textureView233 = texture103.createView({
  label: '\u{1fa06}\u{1f914}\u7731\u9900\u{1f71e}\u{1faa2}\u4740\ub94b\uf5ea\u{1fc7d}\u{1f80d}',
  baseMipLevel: 4,
  baseArrayLayer: 20,
  arrayLayerCount: 41,
});
let renderBundleEncoder104 = device3.createRenderBundleEncoder({
  colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'],
  depthReadOnly: true,
  stencilReadOnly: false,
});
try {
commandEncoder171.copyTextureToTexture({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
let img21 = await imageWithData(1, 69, '#6e1b8a6c', '#288b2444');
let commandEncoder199 = device4.createCommandEncoder({});
let texture129 = device4.createTexture({
  label: '\u{1f7c7}\u{1f7af}\uad2c\u4801\uc787\ub617\ud0a0\u0aed\u2d18',
  size: [164, 3, 627],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView234 = texture124.createView({aspect: 'all', baseMipLevel: 0});
let computePassEncoder108 = commandEncoder193.beginComputePass({label: '\u{1ff75}\u{1fe63}\u6811\u8e59\ud2b6'});
try {
computePassEncoder108.setPipeline(pipeline154);
} catch {}
let pipeline156 = device4.createRenderPipeline({
  label: '\uee2e\uc2c5',
  layout: pipelineLayout17,
  multisample: {mask: 0xab2b56e9},
  fragment: {
  module: shaderModule34,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint'}, {format: 'rgba8sint', writeMask: 0}, {
  format: 'rg8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'src'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rg8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'never',
    stencilFront: {compare: 'equal', failOp: 'increment-clamp', depthFailOp: 'increment-clamp', passOp: 'increment-clamp'},
    stencilBack: {compare: 'greater', failOp: 'decrement-wrap', depthFailOp: 'replace', passOp: 'replace'},
    stencilWriteMask: 3256944586,
    depthBiasSlopeScale: 50.15394536828995,
    depthBiasClamp: 308.25379209485897,
  },
  vertex: {
    module: shaderModule34,
    buffers: [
      {
        arrayStride: 160,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 13},
          {format: 'unorm16x2', offset: 0, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 68,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 0, shaderLocation: 7},
          {format: 'snorm16x2', offset: 24, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 328,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x2', offset: 324, shaderLocation: 14}],
      },
      {arrayStride: 220, attributes: []},
      {arrayStride: 660, attributes: []},
      {arrayStride: 456, stepMode: 'instance', attributes: []},
      {arrayStride: 36, attributes: []},
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x2', offset: 0, shaderLocation: 11},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 15},
          {format: 'sint8x2', offset: 0, shaderLocation: 2},
          {format: 'sint8x4', offset: 4, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 12},
          {format: 'unorm8x2', offset: 2, shaderLocation: 6},
          {format: 'unorm8x4', offset: 0, shaderLocation: 9},
          {format: 'unorm8x4', offset: 8, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
let querySet93 = device3.createQuerySet({type: 'occlusion', count: 2922});
let computePassEncoder109 = commandEncoder197.beginComputePass();
let externalTexture105 = device3.importExternalTexture({label: '\uf2ed\ud0c4', source: video13, colorSpace: 'srgb'});
try {
renderBundleEncoder104.setBindGroup(3, bindGroup69);
} catch {}
try {
renderBundleEncoder104.setBindGroup(1, bindGroup69, new Uint32Array(5281), 1578, 0);
} catch {}
try {
renderBundleEncoder104.pushDebugGroup('\u0532');
} catch {}
let bindGroupLayout56 = device3.createBindGroupLayout({
  label: '\uf6b7\u6203\u{1fbf8}\u0a8e\u{1f98d}\u{1fa49}\ubb77',
  entries: [
    {
      binding: 75,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
  ],
});
let commandEncoder200 = device3.createCommandEncoder({label: '\u72af\u045e\u{1f8d8}\uacbf\u06c7'});
let querySet94 = device3.createQuerySet({label: '\u4019\u211a', type: 'occlusion', count: 4020});
let commandBuffer45 = commandEncoder200.finish({label: '\u{1f8df}\u{1fd95}\u03c3\u{1fa6c}\u7399\u{1ff97}'});
let computePassEncoder110 = commandEncoder168.beginComputePass({label: '\u05ab\u3ad7'});
let renderBundle125 = renderBundleEncoder79.finish({label: '\u067e\u2957\u8cf4\u1749\u2529\u5112\u4f64\uf101'});
try {
computePassEncoder110.setBindGroup(3, bindGroup62);
} catch {}
try {
renderBundleEncoder98.setBindGroup(0, bindGroup64);
} catch {}
try {
device3.addEventListener('uncapturederror', e => { log('device3.uncapturederror'); log(e); e.label = device3.label; });
} catch {}
try {
buffer39.unmap();
} catch {}
try {
commandEncoder171.copyTextureToBuffer({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3656 */
  offset: 3656,
  buffer: buffer38,
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder171.copyTextureToTexture({
  texture: texture103,
  mipLevel: 2,
  origin: {x: 10, y: 0, z: 51},
  aspect: 'all',
},
{
  texture: texture103,
  mipLevel: 0,
  origin: {x: 230, y: 0, z: 0},
  aspect: 'all',
},
{width: 230, height: 0, depthOrArrayLayers: 1});
} catch {}
let video32 = await videoWithData();
try {
offscreenCanvas20.getContext('webgpu');
} catch {}
let shaderModule36 = device4.createShaderModule({
  label: '\u1fd1\u{1fc86}\u0158',
  code: `@group(0) @binding(386)
var<storage, read_write> type10: array<u32>;
@group(1) @binding(910)
var<storage, read_write> local7: array<u32>;
@group(1) @binding(386)
var<storage, read_write> type11: array<u32>;

@compute @workgroup_size(3, 3, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(5) f0: vec4<f32>,
  @location(4) f1: vec4<i32>,
  @location(2) f2: vec4<f32>,
  @location(1) f3: vec4<i32>,
  @location(0) f4: vec4<u32>,
  @location(6) f5: vec3<i32>,
  @location(3) f6: vec4<f32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S32 {
  @location(5) f0: vec4<i32>,
  @location(8) f1: vec3<f16>,
  @location(3) f2: f32,
  @location(7) f3: vec2<f32>,
  @builtin(vertex_index) f4: u32,
  @location(2) f5: vec2<f16>,
  @location(4) f6: vec3<f16>,
  @location(6) f7: f16,
  @location(15) f8: vec4<u32>,
  @location(1) f9: vec2<f32>,
  @location(0) f10: vec3<i32>,
  @builtin(instance_index) f11: u32,
  @location(14) f12: vec2<i32>
}
struct VertexOutput0 {
  @location(10) f199: vec3<f16>,
  @location(6) f200: vec2<i32>,
  @location(3) f201: vec2<u32>,
  @location(5) f202: vec4<i32>,
  @location(0) f203: vec2<i32>,
  @location(13) f204: f16,
  @location(8) f205: vec4<u32>,
  @location(9) f206: vec3<f16>,
  @location(4) f207: vec2<u32>,
  @builtin(position) f208: vec4<f32>,
  @location(2) f209: f16,
  @location(12) f210: vec2<u32>,
  @location(15) f211: u32,
  @location(1) f212: vec2<u32>
}

@vertex
fn vertex0(@location(11) a0: vec3<i32>, @location(10) a1: vec2<f16>, @location(13) a2: vec3<f32>, a3: S32, @location(9) a4: vec2<f16>, @location(12) a5: vec4<f32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  hints: {},
});
let querySet95 = device4.createQuerySet({
  label: '\uf065\ubce1\u6848\ua040\u6115\ubd19\u04f7\u09c7\u{1f94c}\u82c2\u5e7f',
  type: 'occlusion',
  count: 279,
});
let sampler85 = device4.createSampler({
  label: '\u2944\u0e6b\u4cb6\u{1f631}\u{1f770}\u0ad6\ucd2b\ufac9',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 83.56,
  lodMaxClamp: 93.37,
});
let promise64 = buffer30.mapAsync(GPUMapMode.READ, 126864, 17632);
document.body.prepend(img8);
let commandEncoder201 = device1.createCommandEncoder();
let computePassEncoder111 = commandEncoder88.beginComputePass();
let renderBundleEncoder105 = device1.createRenderBundleEncoder({colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'], depthReadOnly: true});
let sampler86 = device1.createSampler({
  label: '\u0bd7\u{1f989}\ucaea\u029c\ufb99\u0bd1\u{1f8fc}\u{1f6b9}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 19.61,
  lodMaxClamp: 98.56,
  compare: 'always',
  maxAnisotropy: 17,
});
try {
computePassEncoder95.setBindGroup(0, bindGroup61, new Uint32Array(9927), 4072, 0);
} catch {}
try {
renderBundleEncoder63.setBindGroup(3, bindGroup28);
} catch {}
try {
renderBundleEncoder52.setPipeline(pipeline131);
} catch {}
try {
renderBundleEncoder103.setVertexBuffer(5, buffer12, 3_540, 65);
} catch {}
try {
commandEncoder194.copyBufferToTexture({
  /* bytesInLastRow: 120 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 10464 */
  offset: 10464,
  buffer: buffer17,
}, {
  texture: texture121,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 15, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder156.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 40172 */
  offset: 40172,
  buffer: buffer13,
}, {width: 10, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder76.resolveQuerySet(querySet71, 243, 173, buffer31, 21760);
} catch {}
try {
renderBundleEncoder82.insertDebugMarker('\u{1fd18}');
} catch {}
try {
device1.queue.writeBuffer(buffer36, 7932, new Float32Array(29028), 17137, 48);
} catch {}
let gpuCanvasContext28 = offscreenCanvas25.getContext('webgpu');
try {
  await promise60;
} catch {}
let texture130 = device2.createTexture({
  size: [180],
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm-srgb'],
});
let textureView235 = texture109.createView({
  label: '\ud105\u020d\uf59d\u{1fd02}\u{1f8ee}\u980c\u0521\u{1f6da}\u{1fa9d}\u0436',
  dimension: '2d-array',
  format: 'rgba8unorm-srgb',
  mipLevelCount: 1,
});
try {
computePassEncoder73.dispatchWorkgroupsIndirect(buffer23, 469580);
} catch {}
let pipeline157 = await device2.createComputePipelineAsync({
  label: '\uf7ef\u5219\u{1ff18}\u{1f818}\u{1fcce}\u3c7e\u6b58\u08f8',
  layout: pipelineLayout14,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let buffer40 = device0.createBuffer({
  label: '\u81d2\u4c05\u6f83\u3279\u{1fc5a}\u06e2\u0592\u1eb2\uebba',
  size: 479837,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder202 = device0.createCommandEncoder({label: '\u0566\u05ea\u{1f987}\u5142\u{1faaf}\u0564\u799c\u7141\u0f9d\u0b6d'});
let computePassEncoder112 = commandEncoder83.beginComputePass({label: '\u9769\u{1f7a1}'});
let sampler87 = device0.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 97.87,
  lodMaxClamp: 98.45,
});
try {
renderPassEncoder8.setViewport(64.22, 5.091, 96.25, 0.2678, 0.7181, 0.7897);
} catch {}
try {
renderBundleEncoder29.drawIndexed(3_588, 327, 3, 1_001_819_589, 1_754_172_840);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer24, 15_608);
} catch {}
try {
commandEncoder173.copyBufferToBuffer(buffer29, 34160, buffer6, 25636, 1152);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 596}
*/
{
  source: imageData8,
  origin: { x: 5, y: 11 },
  flipY: true,
}, {
  texture: texture58,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 157},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 3, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
  await promise58;
} catch {}
let commandBuffer46 = commandEncoder107.finish({label: '\u0c70\u08cf\u07eb\u350b\u6274\ub1cb\u{1f7e6}\u9a67'});
let renderPassEncoder12 = commandEncoder102.beginRenderPass({
  colorAttachments: [{
  view: textureView227,
  clearValue: { r: -0.6841, g: -601.3, b: -536.1, a: -718.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet79,
});
try {
computePassEncoder11.setBindGroup(0, bindGroup57, new Uint32Array(7251), 4773, 0);
} catch {}
try {
computePassEncoder27.dispatchWorkgroupsIndirect(buffer24, 229172);
} catch {}
try {
renderPassEncoder12.setStencilReference(3317);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(5, buffer6, 396);
} catch {}
try {
renderBundleEncoder29.drawIndexed(145, 13, 1_290, 215_109_438, 58_417_715);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer10, 8_760);
} catch {}
try {
commandEncoder13.copyBufferToBuffer(buffer1, 88368, buffer25, 31892, 198200);
} catch {}
try {
commandEncoder198.copyTextureToTexture({
  texture: texture32,
  mipLevel: 1,
  origin: {x: 13, y: 5, z: 102},
  aspect: 'all',
},
{
  texture: texture2,
  mipLevel: 5,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
},
{width: 2, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder175.resolveQuerySet(querySet69, 26, 53, buffer24, 11776);
} catch {}
try {
device0.queue.writeBuffer(buffer1, 71276, new Float32Array(37871), 14359);
} catch {}
try {
gpuCanvasContext23.unconfigure();
} catch {}
let texture131 = device3.createTexture({
  size: {width: 756, height: 8, depthOrArrayLayers: 155},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle126 = renderBundleEncoder79.finish({label: '\u{1f88b}\u{1ffbd}\u1dcd\ua4dc\u8be5'});
try {
renderBundleEncoder104.setBindGroup(2, bindGroup71);
} catch {}
try {
commandEncoder171.copyTextureToBuffer({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 50056 */
  offset: 50056,
  buffer: buffer38,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext7.configure({
  device: device3,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let bindGroupLayout57 = device2.createBindGroupLayout({
  label: '\u92f5\uedba\u0b43\u{1f6a6}\u{1fddc}\u{1f675}\u{1fb71}\u2a36\u3796\u00f1',
  entries: [
    {
      binding: 999,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 976,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let bindGroup72 = device2.createBindGroup({
  layout: bindGroupLayout47,
  entries: [{binding: 84, resource: sampler80}, {binding: 953, resource: sampler75}],
});
let texture132 = device2.createTexture({
  label: '\u{1fcde}\u{1f95c}\u{1fc36}\u{1f92b}\u2ab7\ufe35\u0f09',
  size: {width: 30, height: 3, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm', 'rg8unorm'],
});
let sampler88 = device2.createSampler({
  addressModeV: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 12.35,
  lodMaxClamp: 78.57,
});
try {
computePassEncoder88.setBindGroup(2, bindGroup47, new Uint32Array(678), 369, 0);
} catch {}
try {
renderBundleEncoder100.setBindGroup(2, bindGroup51);
} catch {}
try {
commandEncoder159.copyTextureToTexture({
  texture: texture132,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture97,
  mipLevel: 0,
  origin: {x: 56, y: 8, z: 0},
  aspect: 'all',
},
{width: 2, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.writeBuffer(buffer33, 33756, new DataView(new ArrayBuffer(60219)), 33613, 2756);
} catch {}
let pipeline158 = await device2.createComputePipelineAsync({
  label: '\u3ef6\u0092\u57ea\u5575\u5082\u10df',
  layout: pipelineLayout11,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let pipeline159 = device2.createRenderPipeline({
  label: '\u74eb\udd68\ub76d\u0094\ueb07\u{1f68a}\u0297\u18f6\u371a\u{1ff4c}',
  layout: pipelineLayout13,
  multisample: {count: 4, mask: 0x30fa83b8},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA,
}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-constant'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-constant', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'add', srcFactor: 'zero', dstFactor: 'dst'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'r8sint', writeMask: GPUColorWrite.RED}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: 0,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilFront: {
      compare: 'not-equal',
      failOp: 'increment-clamp',
      depthFailOp: 'increment-clamp',
      passOp: 'increment-clamp',
    },
    stencilBack: {
      compare: 'less-equal',
      failOp: 'decrement-clamp',
      depthFailOp: 'decrement-clamp',
      passOp: 'increment-clamp',
    },
    stencilReadMask: 1673515477,
    stencilWriteMask: 1294714877,
    depthBias: 2085206091,
    depthBiasClamp: 840.796120393566,
  },
  vertex: {
    module: shaderModule25,
    buffers: [
      {arrayStride: 0, attributes: []},
      {arrayStride: 736, attributes: []},
      {
        arrayStride: 528,
        stepMode: 'vertex',
        attributes: [{format: 'unorm16x2', offset: 76, shaderLocation: 0}],
      },
      {arrayStride: 244, attributes: []},
      {arrayStride: 312, attributes: []},
      {arrayStride: 284, stepMode: 'instance', attributes: []},
      {arrayStride: 28, stepMode: 'instance', attributes: []},
      {arrayStride: 116, attributes: [{format: 'uint32x3', offset: 8, shaderLocation: 13}]},
    ],
  },
  primitive: {topology: 'triangle-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let shaderModule37 = device0.createShaderModule({
  label: '\u5895\u526e\u0635\u{1f62c}\u{1fab5}\ua315\u0ff0\u0fae\u{1fc6f}',
  code: `@group(2) @binding(244)
var<storage, read_write> field7: array<u32>;
@group(1) @binding(379)
var<storage, read_write> local8: array<u32>;
@group(1) @binding(454)
var<storage, read_write> local9: array<u32>;

@compute @workgroup_size(2, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(2) f0: vec2<f32>,
  @location(3) f1: vec2<f32>,
  @location(0) f2: vec3<f32>,
  @location(4) f3: vec4<u32>
}

@fragment
fn fragment0(@builtin(front_facing) a0: bool) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(7) a0: vec2<i32>, @location(12) a1: vec3<f16>, @location(15) a2: vec2<i32>, @location(13) a3: vec2<f32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder203 = device0.createCommandEncoder({label: '\ue076\u1f4a\uac89\u{1fec6}\u{1fe6a}\u8782'});
let textureView236 = texture32.createView({format: 'rg8unorm', baseMipLevel: 5, mipLevelCount: 4});
let sampler89 = device0.createSampler({
  label: '\u7ae8\u1f13\u6e80\u0177\u0c38\u{1fa44}\u{1f93a}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 49.39,
  lodMaxClamp: 71.14,
});
try {
computePassEncoder58.dispatchWorkgroups(4, 5, 2);
} catch {}
try {
computePassEncoder33.dispatchWorkgroupsIndirect(buffer11, 274272);
} catch {}
try {
renderPassEncoder12.setScissorRect(197, 406, 47, 35);
} catch {}
try {
renderPassEncoder8.setStencilReference(475);
} catch {}
try {
renderBundleEncoder50.setBindGroup(2, bindGroup13);
} catch {}
try {
renderBundleEncoder29.drawIndexed(5_538, 31, 42, -2_119_652_109, 66_823_149);
} catch {}
let arrayBuffer12 = buffer9.getMappedRange(265464, 76628);
try {
commandEncoder110.copyTextureToBuffer({
  texture: texture60,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 692 widthInBlocks: 173 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 40908 */
  offset: 40908,
  bytesPerRow: 768,
  buffer: buffer40,
}, {width: 173, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder84.clearBuffer(buffer7);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture29,
  mipLevel: 2,
  origin: {x: 38, y: 19, z: 0},
  aspect: 'all',
}, new BigUint64Array(new ArrayBuffer(8)), /* required buffer size: 380_743 */
{offset: 911, bytesPerRow: 378, rowsPerImage: 96}, {width: 80, height: 45, depthOrArrayLayers: 11});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 660, height: 480, depthOrArrayLayers: 124}
*/
{
  source: img15,
  origin: { x: 3, y: 3 },
  flipY: false,
}, {
  texture: texture115,
  mipLevel: 1,
  origin: {x: 26, y: 79, z: 25},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 11, height: 20, depthOrArrayLayers: 0});
} catch {}
let pipeline160 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule7, entryPoint: 'compute0', constants: {}}});
let commandEncoder204 = device4.createCommandEncoder({label: '\ufe43\u9996\u499e\uc815\u{1fa9f}\ua3c6'});
let textureView237 = texture129.createView({label: '\u7589\u0db1\u{1fb81}\udbd0', baseMipLevel: 2, mipLevelCount: 5});
let computePassEncoder113 = commandEncoder204.beginComputePass({label: '\u0ca6\u{1fca3}\u{1fae2}\u03a0\u0110\ud8aa\u0783\u{1fb0b}\u0b57\u01ed'});
try {
device4.queue.writeTexture({
  texture: texture127,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, new Float32Array(arrayBuffer2), /* required buffer size: 106 */
{offset: 106, bytesPerRow: 488, rowsPerImage: 219}, {width: 135, height: 3, depthOrArrayLayers: 0});
} catch {}
gc();
let bindGroupLayout58 = device1.createBindGroupLayout({
  entries: [
    {binding: 146, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 820,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let pipelineLayout19 = device1.createPipelineLayout({label: '\ud88c\u9754', bindGroupLayouts: [bindGroupLayout24, bindGroupLayout13, bindGroupLayout43]});
let commandEncoder205 = device1.createCommandEncoder({label: '\u25a3\u4c1b\uc745\u0b70\u178d\u1463\uc741\u{1fd74}\u14df\u0c8e'});
try {
renderBundleEncoder34.drawIndexedIndirect(buffer15, 8_992);
} catch {}
try {
commandEncoder201.copyBufferToBuffer(buffer18, 151284, buffer28, 20032, 2608);
} catch {}
try {
commandEncoder156.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 9524 */
  offset: 9524,
  buffer: buffer18,
}, {
  texture: texture54,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder201.resolveQuerySet(querySet27, 1092, 224, buffer28, 256);
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
try {
  await promise62;
} catch {}
gc();
let imageData32 = new ImageData(240, 104);
let commandEncoder206 = device2.createCommandEncoder({label: '\uac83\u280f\u9a07\u{1fe3b}\u5461'});
let computePassEncoder114 = commandEncoder186.beginComputePass();
let renderBundle127 = renderBundleEncoder57.finish({label: '\u9a29\ue207\ucc36\u2f3b\uaf7e\u8d7b\u{1f8d9}\u{1fb4b}\u8bcc\u048e'});
let externalTexture106 = device2.importExternalTexture({
  label: '\u4cf3\u07e9\ub0a1\u0a54\ud384\u{1fab2}\u08d1\ufef4\u1aad\u06fe\u{1f8e5}',
  source: video16,
  colorSpace: 'srgb',
});
let pipeline161 = device2.createRenderPipeline({
  label: '\ucb34\u8597\uacda',
  layout: pipelineLayout11,
  multisample: {count: 4, mask: 0x3b19ced4},
  fragment: {
  module: shaderModule28,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'dst'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-dst-alpha'},
  },
}, {format: 'rgba8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'src-alpha'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE,
}, {format: 'r8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'r8sint', writeMask: 0}, {format: 'rg8unorm'}, {
  format: 'rgba8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'never',
    stencilFront: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'zero', passOp: 'invert'},
    stencilBack: {compare: 'not-equal', failOp: 'decrement-clamp', depthFailOp: 'increment-clamp', passOp: 'zero'},
    stencilReadMask: 893284178,
    depthBiasSlopeScale: 721.4234506128985,
    depthBiasClamp: 792.3201815872312,
  },
  vertex: {
    module: shaderModule28,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 568,
        stepMode: 'instance',
        attributes: [{format: 'uint16x4', offset: 132, shaderLocation: 11}],
      },
      {
        arrayStride: 1056,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 20, shaderLocation: 8},
          {format: 'unorm16x4', offset: 172, shaderLocation: 12},
        ],
      },
      {arrayStride: 972, stepMode: 'instance', attributes: []},
      {
        arrayStride: 524,
        attributes: [
          {format: 'snorm16x2', offset: 36, shaderLocation: 7},
          {format: 'unorm16x2', offset: 32, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 336,
        attributes: [
          {format: 'float16x2', offset: 100, shaderLocation: 14},
          {format: 'uint32x3', offset: 136, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 192,
        attributes: [
          {format: 'float32x3', offset: 0, shaderLocation: 9},
          {format: 'uint16x2', offset: 8, shaderLocation: 5},
        ],
      },
      {arrayStride: 92, stepMode: 'instance', attributes: []},
      {
        arrayStride: 148,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x4', offset: 16, shaderLocation: 3},
          {format: 'float16x2', offset: 44, shaderLocation: 15},
          {format: 'float16x2', offset: 12, shaderLocation: 4},
          {format: 'float16x2', offset: 24, shaderLocation: 13},
          {format: 'float16x2', offset: 36, shaderLocation: 10},
          {format: 'snorm8x4', offset: 8, shaderLocation: 0},
          {format: 'unorm8x2', offset: 6, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'ccw', unclippedDepth: true},
});
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let renderBundleEncoder106 = device2.createRenderBundleEncoder({
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
});
let sampler90 = device2.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 48.95,
  lodMaxClamp: 66.73,
});
try {
computePassEncoder74.setBindGroup(3, bindGroup49);
} catch {}
try {
computePassEncoder75.end();
} catch {}
try {
computePassEncoder80.setPipeline(pipeline141);
} catch {}
try {
commandEncoder184.copyBufferToBuffer(buffer22, 232580, buffer33, 146012, 5164);
} catch {}
let offscreenCanvas28 = new OffscreenCanvas(483, 399);
let commandEncoder207 = device3.createCommandEncoder({});
let texture133 = device3.createTexture({
  label: '\u4568\u0fc4',
  size: [84, 3, 78],
  mipLevelCount: 6,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r8unorm'],
});
let textureView238 = texture106.createView({dimension: '2d-array', format: 'rgba8unorm-srgb'});
let computePassEncoder115 = commandEncoder171.beginComputePass();
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let textureView239 = texture118.createView({
  label: '\u{1f755}\u6064\u{1f6d7}\u255a\uf751\uab5e\u{1ff83}\u6aa8\u{1f96b}\u09b3\u{1fec8}',
  mipLevelCount: 2,
});
try {
computePassEncoder73.dispatchWorkgroupsIndirect(buffer23, 535628);
} catch {}
try {
renderBundleEncoder74.setPipeline(pipeline133);
} catch {}
try {
  await device2.popErrorScope();
} catch {}
let arrayBuffer13 = buffer22.getMappedRange(195512, 4556);
try {
commandEncoder147.copyBufferToBuffer(buffer22, 314692, buffer23, 357640, 22072);
} catch {}
let canvas31 = document.createElement('canvas');
let imageBitmap24 = await createImageBitmap(offscreenCanvas20);
try {
offscreenCanvas28.getContext('bitmaprenderer');
} catch {}
let bindGroupLayout59 = device2.createBindGroupLayout({
  label: '\u9652\u0697\ufd4b\uc5b3\u90db',
  entries: [
    {binding: 59, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 193, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }},
  ],
});
let buffer41 = device2.createBuffer({
  label: '\u0d46\udfec\u3454\u{1f8b1}\uf4f4\u9f25\u{1facc}\u4866\u{1f8e5}',
  size: 19501,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder208 = device2.createCommandEncoder({label: '\u{1ffb0}\uaf92\u0a71\u0ed7\uc2d3\ufff1\ue0f4'});
let textureView240 = texture88.createView({
  label: '\u9cbc\u{1ff1d}\u9479\u51c3\u04c0\u9c7b\u06ea\u0598',
  dimension: '2d-array',
  baseMipLevel: 0,
  mipLevelCount: 3,
});
try {
computePassEncoder73.dispatchWorkgroups(2, 3, 3);
} catch {}
try {
computePassEncoder92.setPipeline(pipeline157);
} catch {}
try {
renderBundleEncoder69.setPipeline(pipeline133);
} catch {}
try {
commandEncoder164.resolveQuerySet(querySet63, 18, 107, buffer23, 111104);
} catch {}
try {
device2.queue.writeBuffer(buffer33, 18304, new BigUint64Array(54817), 15175, 2744);
} catch {}
try {
  await promise52;
} catch {}
let commandEncoder209 = device3.createCommandEncoder({label: '\u1d75\ud0bf\u5c41\u9240'});
let querySet96 = device3.createQuerySet({type: 'occlusion', count: 3618});
let textureView241 = texture105.createView({
  label: '\u17be\u962f\uc91d\u098a\u0951\u{1f73f}\u5712\u07a0\u2f13',
  format: 'astc-12x10-unorm',
  baseMipLevel: 2,
  mipLevelCount: 1,
  baseArrayLayer: 44,
  arrayLayerCount: 3,
});
try {
renderBundleEncoder104.setBindGroup(2, bindGroup64);
} catch {}
try {
renderBundleEncoder98.setBindGroup(1, bindGroup62, new Uint32Array(8975), 7943, 0);
} catch {}
try {
device3.queue.writeBuffer(buffer38, 39792, new Int16Array(26521), 5659, 5652);
} catch {}
let video33 = await videoWithData();
let commandBuffer47 = commandEncoder76.finish({label: '\u28ba\u0524\u7dc6\u09e3\u08ab'});
let textureView242 = texture68.createView({label: '\u62ba\u085d\u0edb\u0893\u{1f904}', dimension: '2d-array', baseMipLevel: 1});
let arrayBuffer14 = buffer26.getMappedRange(249744, 1092);
try {
commandEncoder182.resolveQuerySet(querySet29, 312, 209, buffer15, 2048);
} catch {}
try {
device1.queue.writeBuffer(buffer13, 5880, new BigUint64Array(2093));
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData12,
  origin: { x: 7, y: 19 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder210 = device0.createCommandEncoder({});
let querySet97 = device0.createQuerySet({
  label: '\u{1fdb6}\u621e\u7a8d\u{1fbe1}\u{1f955}\uec0f\u{1fe5b}\u{1f678}\u387e\u28cf\u1ad2',
  type: 'occlusion',
  count: 4080,
});
let renderPassEncoder13 = commandEncoder70.beginRenderPass({
  label: '\u4ab7\u083a\u8dd0\u{1fdfe}\u{1f81a}\u3d06\u79f8',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: 72.63, g: -12.83, b: -4.320, a: -496.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet53,
  maxDrawCount: 750843048,
});
let externalTexture107 = device0.importExternalTexture({label: '\uca64\u7629\u0978\u{1fabe}', source: video33, colorSpace: 'srgb'});
try {
computePassEncoder69.end();
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup42, []);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle117, renderBundle107, renderBundle117, renderBundle107, renderBundle42, renderBundle42, renderBundle73, renderBundle117, renderBundle117]);
} catch {}
try {
renderPassEncoder13.setViewport(127.6, 87.55, 4.780, 12.56, 0.1764, 0.3682);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer24, 4_704, 116_964);
} catch {}
try {
renderBundleEncoder29.setBindGroup(2, bindGroup20, []);
} catch {}
try {
renderBundleEncoder27.setBindGroup(3, bindGroup19, new Uint32Array(8536), 7840, 0);
} catch {}
try {
renderBundleEncoder29.draw(78, 5, 308, 656_875_768);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer0, 12_900);
} catch {}
try {
renderBundleEncoder96.setIndexBuffer(buffer0, 'uint32', 72_516, 27_655);
} catch {}
try {
renderBundleEncoder38.setPipeline(pipeline13);
} catch {}
try {
  await buffer29.mapAsync(GPUMapMode.WRITE, 4872, 12848);
} catch {}
try {
commandEncoder160.resolveQuerySet(querySet19, 412, 568, buffer0, 46848);
} catch {}
try {
computePassEncoder46.insertDebugMarker('\u1248');
} catch {}
try {
device0.queue.writeBuffer(buffer1, 25168, new Float32Array(38826));
} catch {}
let pipeline162 = device0.createComputePipeline({
  label: '\ude69\u4a28\u0f5a',
  layout: pipelineLayout10,
  compute: {module: shaderModule18, entryPoint: 'compute0'},
});
try {
  await promise64;
} catch {}
document.body.prepend(video25);
offscreenCanvas18.width = 37;
let texture134 = device1.createTexture({
  label: '\u089a\u{1f821}\u{1f98e}\u{1f8f3}\u{1f6e4}\u7e36\u0e4c\u07b6\u5c80',
  size: {width: 302},
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32sint', 'r32sint', 'r32sint'],
});
let renderBundle128 = renderBundleEncoder35.finish({});
let externalTexture108 = device1.importExternalTexture({
  label: '\u038c\ua3f7\u092b\u039f\u424c\u{1f620}\u{1ffea}\u8037\u01e2\u0170\u{1f623}',
  source: videoFrame3,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder34.draw(2, 0, 0, 1);
} catch {}
try {
renderBundleEncoder34.drawIndexedIndirect(buffer15, 816);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture121,
  mipLevel: 4,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer12, /* required buffer size: 974 */
{offset: 974, bytesPerRow: 67}, {width: 6, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline163 = device1.createComputePipeline({
  label: '\u74a9\u69ad\u{1f7d7}',
  layout: pipelineLayout7,
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let bindGroupLayout60 = device1.createBindGroupLayout({label: '\ubc2c\u9169\u990f', entries: []});
let textureView243 = texture50.createView({label: '\u53ce\u5ffd\ua408\udc92\u25b2\u895a\u5475\u{1fbcb}', baseMipLevel: 5});
let sampler91 = device1.createSampler({
  label: '\u9262\u{1fd62}\u{1f8b5}\ue4cd\u3112\u07e0\u{1fc40}\u0363\u{1faa1}\u{1fb48}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 30.41,
  lodMaxClamp: 43.16,
});
try {
computePassEncoder47.setPipeline(pipeline92);
} catch {}
try {
renderBundleEncoder34.draw(4, 4);
} catch {}
try {
renderBundleEncoder34.drawIndexed(424, 183, 4_287, 38_159_181, 15_270_518);
} catch {}
try {
renderBundleEncoder39.setPipeline(pipeline120);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
try {
commandEncoder64.resolveQuerySet(querySet59, 2, 3, buffer28, 2816);
} catch {}
let pipeline164 = await promise44;
let gpuCanvasContext29 = canvas31.getContext('webgpu');
video12.width = 118;
let commandEncoder211 = device4.createCommandEncoder({label: '\u4c13\ud815\uc520\u0ac6\u{1fc50}'});
let querySet98 = device4.createQuerySet({label: '\ua093\uc195\u0dab\u01ff\uf0a4\u098d\u{1f6c5}', type: 'occlusion', count: 935});
try {
device4.pushErrorScope('out-of-memory');
} catch {}
let texture135 = device0.createTexture({
  label: '\uc38a\u08bc\u730f',
  size: [330, 240, 124],
  mipLevelCount: 3,
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgb10a2unorm'],
});
let textureView244 = texture81.createView({
  label: '\u521c\ucb7f',
  dimension: '2d',
  format: 'rgba8unorm-srgb',
  baseMipLevel: 3,
  mipLevelCount: 2,
  baseArrayLayer: 14,
});
let computePassEncoder116 = commandEncoder198.beginComputePass({label: '\u0a6a\u{1fda2}\uaf38\u7b70\uffcb\u927d'});
try {
computePassEncoder0.setBindGroup(2, bindGroup18);
} catch {}
try {
computePassEncoder27.dispatchWorkgroups(2, 3, 1);
} catch {}
try {
computePassEncoder79.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder7.end();
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer34, 'uint16', 207_910, 32_978);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer9, 44_724, 2_075);
} catch {}
try {
renderBundleEncoder50.setBindGroup(2, bindGroup3, new Uint32Array(2936), 1179, 0);
} catch {}
try {
renderBundleEncoder50.draw(466, 131, 746_799_425, 622_281_454);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 451_104);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer0, 6_016);
} catch {}
try {
gpuCanvasContext11.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeBuffer(buffer1, 221136, new Int16Array(20279), 11637);
} catch {}
gc();
let bindGroupLayout61 = device4.createBindGroupLayout({
  label: '\uaf9f\u8f4c\u5b47\ucb85\u0130\u1d28\u0765\ua05d\u122d\u{1f7bf}\u19e4',
  entries: [
    {
      binding: 878,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'comparison' },
    },
    {
      binding: 37,
      visibility: GPUShaderStage.COMPUTE,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true },
    },
    {
      binding: 362,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let commandEncoder212 = device4.createCommandEncoder({label: '\uf560\u{1fc7e}\u0e02\u4d51\u{1f973}\u5522'});
let texture136 = device4.createTexture({
  label: '\u0423\u4268',
  size: [328, 6, 585],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rg8unorm', 'rg8unorm'],
});
try {
computePassEncoder108.setPipeline(pipeline151);
} catch {}
try {
texture129.destroy();
} catch {}
try {
commandEncoder211.clearBuffer(buffer30, 37540, 198944);
} catch {}
let bindGroupLayout62 = device0.createBindGroupLayout({
  label: '\u043e\u5148\u0638\u{1ff07}\u075c\u2fdc\u26e0',
  entries: [
    {
      binding: 864,
      visibility: 0,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let textureView245 = texture53.createView({arrayLayerCount: 1});
let renderPassEncoder14 = commandEncoder120.beginRenderPass({
  colorAttachments: [{
  view: textureView227,
  clearValue: { r: 639.7, g: -310.3, b: 506.7, a: -992.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 1024021559,
});
try {
computePassEncoder99.setBindGroup(3, bindGroup44, new Uint32Array(2956), 2778, 2);
} catch {}
try {
renderPassEncoder12.setScissorRect(10, 160, 166, 70);
} catch {}
try {
renderBundleEncoder50.drawIndexed(1_963, 33, 1_458, 36_521_093, 188_189_367);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(1, buffer34, 0, 124_798);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let canvas32 = document.createElement('canvas');
let img22 = await imageWithData(284, 148, '#b360dc7e', '#d08ad5b8');
let video34 = await videoWithData();
let textureView246 = texture124.createView({label: '\u42ca\u7633\ud338\u0991\u0ffc\u00e9\u{1f70c}\ub476\ue2e1'});
let renderBundle129 = renderBundleEncoder95.finish();
let sampler92 = device4.createSampler({
  label: '\uc567\u0382\ud9fc\u79f9\uc867\ude78\u7a82',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 95.71,
  lodMaxClamp: 99.27,
  maxAnisotropy: 5,
});
try {
computePassEncoder113.setPipeline(pipeline154);
} catch {}
try {
gpuCanvasContext16.configure({
  device: device4,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm', 'bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline165 = device4.createComputePipeline({
  label: '\u6799\u05f8\u09b1\u4f8c\u1899',
  layout: pipelineLayout17,
  compute: {module: shaderModule35, entryPoint: 'compute0', constants: {}},
});
let pipeline166 = device4.createRenderPipeline({
  layout: pipelineLayout17,
  fragment: {
  module: shaderModule36,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint'}, {format: 'rgba8sint', writeMask: 0}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rg11b10ufloat', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg8sint', writeMask: GPUColorWrite.ALPHA}, {format: 'rg8unorm'}],
},
  vertex: {
    module: shaderModule36,
    buffers: [
      {arrayStride: 112, attributes: [{format: 'sint32x3', offset: 32, shaderLocation: 5}]},
      {
        arrayStride: 164,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 0, shaderLocation: 9},
          {format: 'unorm8x2', offset: 0, shaderLocation: 1},
          {format: 'float32x3', offset: 72, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 180,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x2', offset: 8, shaderLocation: 10},
          {format: 'float16x4', offset: 36, shaderLocation: 3},
          {format: 'sint32', offset: 92, shaderLocation: 11},
        ],
      },
      {arrayStride: 344, attributes: []},
      {arrayStride: 816, stepMode: 'instance', attributes: []},
      {arrayStride: 340, stepMode: 'instance', attributes: []},
      {arrayStride: 404, attributes: [{format: 'float16x4', offset: 36, shaderLocation: 12}]},
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 4, shaderLocation: 4},
          {format: 'uint8x4', offset: 0, shaderLocation: 15},
          {format: 'snorm8x4', offset: 0, shaderLocation: 7},
          {format: 'unorm16x4', offset: 0, shaderLocation: 6},
          {format: 'sint32x2', offset: 4, shaderLocation: 14},
          {format: 'float16x2', offset: 4, shaderLocation: 2},
          {format: 'unorm16x2', offset: 8, shaderLocation: 13},
          {format: 'sint16x2', offset: 4, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'ccw', cullMode: 'back', unclippedDepth: false},
});
try {
  await promise61;
} catch {}
let offscreenCanvas29 = new OffscreenCanvas(287, 482);
let renderBundle130 = renderBundleEncoder83.finish({label: '\u{1fd07}\u6f02\u{1ffde}\u{1fbc6}'});
let sampler93 = device2.createSampler({
  label: '\uff87\uf3b5\u6529\u71b4\u{1fd0f}\u{1f8d9}\u0330\u0511\ub83b\u2a44\u0e2c',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 32.92,
  lodMaxClamp: 93.28,
  maxAnisotropy: 1,
});
try {
computePassEncoder80.setBindGroup(0, bindGroup48, new Uint32Array(2930), 1454, 0);
} catch {}
try {
computePassEncoder98.setPipeline(pipeline112);
} catch {}
try {
renderBundleEncoder100.setVertexBuffer(4_294_967_295, undefined, 0, 384_535_020);
} catch {}
try {
buffer41.unmap();
} catch {}
try {
gpuCanvasContext25.configure({
  device: device2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 7, height: 1, depthOrArrayLayers: 88}
*/
{
  source: imageData29,
  origin: { x: 6, y: 1 },
  flipY: false,
}, {
  texture: texture82,
  mipLevel: 3,
  origin: {x: 3, y: 0, z: 12},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let img23 = await imageWithData(253, 163, '#7a93e19c', '#e2bb355c');
let commandBuffer48 = commandEncoder209.finish({label: '\u00f0\u0285'});
let sampler94 = device3.createSampler({
  label: '\ub8bd\uae8e\u2b96\ud3b2\u586c\u938b\u09b5\u029b',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 16.08,
});
try {
gpuCanvasContext0.configure({
  device: device3,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  colorSpace: 'display-p3',
});
} catch {}
try {
device3.queue.writeBuffer(buffer38, 17000, new Float32Array(63317), 21138, 588);
} catch {}
let gpuCanvasContext30 = offscreenCanvas29.getContext('webgpu');
let querySet99 = device1.createQuerySet({label: '\ud002\u3ab3\u{1f950}\u3257\ua08a\uf867', type: 'occlusion', count: 1856});
let texture137 = device1.createTexture({
  size: {width: 604, height: 192, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  format: 'r8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView247 = texture52.createView({
  label: '\ue16d\u01fa\u88a9\u588a\u1084\udaac\u0798\ueb49',
  dimension: '2d-array',
  baseMipLevel: 8,
  baseArrayLayer: 10,
  arrayLayerCount: 25,
});
try {
renderBundleEncoder85.setPipeline(pipeline120);
} catch {}
try {
buffer28.destroy();
} catch {}
try {
commandEncoder201.copyTextureToTexture({
  texture: texture137,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture137,
  mipLevel: 5,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 2, depthOrArrayLayers: 0});
} catch {}
let commandEncoder213 = device2.createCommandEncoder({});
let texture138 = device2.createTexture({
  label: '\u06e6\ue311\u{1fe97}\ua326\u53ef',
  size: {width: 48, height: 32, depthOrArrayLayers: 1},
  mipLevelCount: 6,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
});
let textureView248 = texture108.createView({label: '\u{1f652}\ufedb\u8bc7\ufb77\u6c41\u5240\u4fb3', baseMipLevel: 1, arrayLayerCount: 1});
try {
renderBundleEncoder106.setBindGroup(2, bindGroup65, new Uint32Array(5112), 1603, 0);
} catch {}
try {
device2.queue.writeBuffer(buffer33, 28772, new DataView(new ArrayBuffer(56313)), 43360, 632);
} catch {}
try {
canvas32.getContext('2d');
} catch {}
let textureView249 = texture93.createView({label: '\uef49\u{1f9c1}\uf285\u0895\u{1fb0a}\u0eca', mipLevelCount: 5, arrayLayerCount: 1});
let computePassEncoder117 = commandEncoder206.beginComputePass();
let sampler95 = device2.createSampler({
  label: '\u{1f9fa}\uc388\u0dae\u{1fcd6}\u1d6a\u0c46\u0057\u{1f8e6}\u0c43',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  mipmapFilter: 'linear',
  lodMinClamp: 55.11,
  lodMaxClamp: 96.33,
});
try {
computePassEncoder73.dispatchWorkgroups(5);
} catch {}
try {
commandEncoder159.copyBufferToBuffer(buffer33, 8856, buffer23, 39104, 121112);
} catch {}
try {
commandEncoder164.copyTextureToBuffer({
  texture: texture108,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'all',
}, {
  /* bytesInLastRow: 76 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 137228 */
  offset: 8128,
  bytesPerRow: 256,
  rowsPerImage: 245,
  buffer: buffer33,
}, {width: 19, height: 15, depthOrArrayLayers: 3});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture113,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new BigUint64Array(arrayBuffer2), /* required buffer size: 117_444 */
{offset: 608, bytesPerRow: 132, rowsPerImage: 46}, {width: 4, height: 12, depthOrArrayLayers: 20});
} catch {}
let imageBitmap25 = await createImageBitmap(offscreenCanvas11);
let commandEncoder214 = device3.createCommandEncoder({label: '\ueec2\u42c3\u4e7a\u850a\u5e8d\u3969\u{1fa75}\ufccc'});
try {
commandEncoder214.copyTextureToBuffer({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 83864 */
  offset: 83864,
  buffer: buffer38,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder207.clearBuffer(buffer38, 70180, 38420);
} catch {}
try {
device3.queue.submit([commandBuffer45]);
} catch {}
try {
device3.queue.writeBuffer(buffer38, 19372, new BigUint64Array(49509), 10940, 4024);
} catch {}
let canvas33 = document.createElement('canvas');
let texture139 = device0.createTexture({
  label: '\uc4d6\u3aba\u7dd3\uf648\uf719\u0e9a\u{1fed9}',
  size: [1320],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8snorm', 'rgba8snorm'],
});
let textureView250 = texture89.createView({
  label: '\u{1faa9}\u6430\u{1ff6b}\u{1fa01}\u0261\u0bad\u{1fc1b}\u{1f71c}\u05c8',
  baseArrayLayer: 0,
  arrayLayerCount: 1,
});
try {
renderPassEncoder13.executeBundles([renderBundle69, renderBundle69, renderBundle73, renderBundle69, renderBundle69, renderBundle69, renderBundle69]);
} catch {}
try {
renderPassEncoder13.setScissorRect(54, 97, 90, 5);
} catch {}
try {
renderPassEncoder13.setStencilReference(3481);
} catch {}
try {
renderBundleEncoder29.drawIndexed(606, 11, 515, 4_961_222, 481_366_362);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture115,
  mipLevel: 0,
  origin: {x: 64, y: 504, z: 8},
  aspect: 'all',
}, new Float64Array(arrayBuffer6), /* required buffer size: 368_732 */
{offset: 234, bytesPerRow: 1298, rowsPerImage: 215}, {width: 291, height: 69, depthOrArrayLayers: 2});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 124}
*/
{
  source: canvas15,
  origin: { x: 13, y: 3 },
  flipY: true,
}, {
  texture: texture62,
  mipLevel: 3,
  origin: {x: 2, y: 1, z: 20},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 2, depthOrArrayLayers: 0});
} catch {}
let pipeline167 = device0.createComputePipeline({
  label: '\u095b\u0d0f\u{1fbb5}',
  layout: pipelineLayout2,
  compute: {module: shaderModule8, entryPoint: 'compute0'},
});
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55) };
} catch {}
canvas31.height = 1388;
let canvas34 = document.createElement('canvas');
try {
commandEncoder207.copyTextureToBuffer({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 32716 */
  offset: 32716,
  rowsPerImage: 300,
  buffer: buffer38,
}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder214.clearBuffer(buffer38, 88872, 24012);
} catch {}
try {
renderBundleEncoder104.popDebugGroup();
} catch {}
try {
device3.queue.writeBuffer(buffer38, 2444, new Int16Array(29632), 9840, 3504);
} catch {}
let gpuCanvasContext31 = canvas34.getContext('webgpu');
try {
canvas33.getContext('2d');
} catch {}
let bindGroup73 = device1.createBindGroup({
  label: '\u027b\u1a34\uee73\u2a3d\u{1fcfd}',
  layout: bindGroupLayout16,
  entries: [{binding: 32, resource: externalTexture41}],
});
let buffer42 = device1.createBuffer({
  label: '\u0e93\u0b16',
  size: 10623,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView251 = texture111.createView({
  label: '\u{1fe0d}\uc705\uf052\u050e\u011b\ufac1\u2902',
  dimension: '3d',
  baseMipLevel: 7,
  mipLevelCount: 3,
});
let computePassEncoder118 = commandEncoder64.beginComputePass({label: '\u056e\u{1fe9b}\u45b5\u7b2f\u{1fce7}'});
try {
renderBundleEncoder34.drawIndexed(4_591, 193, 677, -1_517_255_707, 598_616_112);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture112,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer11, /* required buffer size: 89 */
{offset: 89}, {width: 7, height: 0, depthOrArrayLayers: 1});
} catch {}
offscreenCanvas25.height = 612;
let texture140 = device2.createTexture({
  label: '\ua24c\u07b0',
  size: [1440, 1, 103],
  mipLevelCount: 7,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm', 'bgra8unorm'],
});
let textureView252 = texture117.createView({baseMipLevel: 3, mipLevelCount: 2});
try {
commandEncoder184.copyTextureToTexture({
  texture: texture93,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture85,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture140,
  mipLevel: 5,
  origin: {x: 6, y: 0, z: 23},
  aspect: 'all',
}, new ArrayBuffer(72), /* required buffer size: 218_360 */
{offset: 476, bytesPerRow: 62, rowsPerImage: 251}, {width: 4, height: 1, depthOrArrayLayers: 15});
} catch {}
try {
gpuCanvasContext16.unconfigure();
} catch {}
gc();
let shaderModule38 = device1.createShaderModule({
  label: '\u090b\ud2e0\u63cf\u9efc',
  code: `@group(0) @binding(966)
var<storage, read_write> global11: array<u32>;

@compute @workgroup_size(7, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(2) f0: vec4<f32>,
  @location(0) f1: vec4<i32>,
  @location(1) f2: vec3<i32>,
  @builtin(frag_depth) f3: f32
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @builtin(position) f213: vec4<f32>
}

@vertex
fn vertex0(@location(3) a0: vec3<i32>, @builtin(instance_index) a1: u32, @location(5) a2: i32, @location(10) a3: vec4<f32>, @location(15) a4: i32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroup74 = device1.createBindGroup({
  layout: bindGroupLayout58,
  entries: [
    {binding: 820, resource: {buffer: buffer19, offset: 7424, size: 1980}},
    {binding: 146, resource: externalTexture55},
  ],
});
let commandEncoder215 = device1.createCommandEncoder({label: '\u{1faee}\u0c66\u0568\u072f\u0328\ufc3a'});
let textureView253 = texture64.createView({label: '\uf23b\u9cb6\u0e54\u584b\uc244', mipLevelCount: 2});
let externalTexture109 = device1.importExternalTexture({label: '\u{1fb91}\u08b9\u146d\ud201\u34cb\ubdcd\u095c', source: video23});
try {
renderBundleEncoder99.setBindGroup(2, bindGroup28, new Uint32Array(1036), 463, 0);
} catch {}
try {
renderBundleEncoder34.drawIndexed(5_050, 30, 1_237, 205_163_358, 912_542_607);
} catch {}
try {
commandEncoder156.resolveQuerySet(querySet59, 6, 53, buffer36, 4096);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Int16Array(arrayBuffer4), /* required buffer size: 111 */
{offset: 111}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData33 = new ImageData(192, 120);
let buffer43 = device2.createBuffer({
  label: '\u8a23\u27ab\u0b74\u90f9',
  size: 7072,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let querySet100 = device2.createQuerySet({type: 'occlusion', count: 1891});
let textureView254 = texture85.createView({label: '\u02ff\uc4ab\u6ae0\u52ad\u4dca\u11be', aspect: 'all', baseArrayLayer: 0});
try {
renderBundleEncoder100.setIndexBuffer(buffer23, 'uint16', 120_324, 104_483);
} catch {}
try {
renderBundleEncoder91.setPipeline(pipeline133);
} catch {}
try {
renderBundleEncoder69.setVertexBuffer(1, buffer43);
} catch {}
try {
commandEncoder164.resolveQuerySet(querySet73, 49, 212, buffer23, 135680);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture108,
  mipLevel: 1,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
}, new DataView(new ArrayBuffer(16)), /* required buffer size: 790 */
{offset: 790}, {width: 7, height: 0, depthOrArrayLayers: 1});
} catch {}
let commandEncoder216 = device2.createCommandEncoder({label: '\ua4d8\u{1fe15}\u04bc\u{1fb14}\udb65\u0617\u270d'});
let textureView255 = texture82.createView({
  label: '\u292d\u{1fecd}\u0f6c\udd23\u{1ffa0}\u655e\u9510',
  dimension: '2d',
  aspect: 'all',
  baseMipLevel: 1,
  baseArrayLayer: 44,
});
try {
commandEncoder188.copyBufferToTexture({
  /* bytesInLastRow: 296 widthInBlocks: 74 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 6928 */
  offset: 6928,
  bytesPerRow: 512,
  buffer: buffer41,
}, {
  texture: texture130,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 74, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder164.copyTextureToTexture({
  texture: texture108,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture130,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder117.insertDebugMarker('\u2a96');
} catch {}
try {
device2.queue.writeTexture({
  texture: texture130,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(437), /* required buffer size: 437 */
{offset: 437}, {width: 117, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 6, height: 4, depthOrArrayLayers: 26}
*/
{
  source: canvas23,
  origin: { x: 39, y: 22 },
  flipY: false,
}, {
  texture: texture118,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 9},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline168 = await promise55;
gc();
let commandEncoder217 = device3.createCommandEncoder({label: '\u103f\u{1f89f}\u{1f610}\ua4b7\u0567\u1ed8\ub67e'});
let texture141 = device3.createTexture({
  size: {width: 72},
  dimension: '1d',
  format: 'r16uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16uint'],
});
let externalTexture110 = device3.importExternalTexture({source: video30});
try {
computePassEncoder110.end();
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55) };
} catch {}
let texture142 = device1.createTexture({
  label: '\u0f19\ua775\u{1fdce}\ue5d2',
  size: {width: 40, height: 40, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  sampleCount: 1,
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32sint', 'r32sint', 'r32sint'],
});
let textureView256 = texture37.createView({label: '\u0e04\u02fc\u15fe', dimension: '1d', mipLevelCount: 1});
let externalTexture111 = device1.importExternalTexture({
  label: '\u{1fe86}\u{1fba3}\u3b73\u{1fc88}\ud0a4\ub61d\u{1f8f4}\ud1fa\u30e8',
  source: video10,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder34.draw(0, 0, 2, 0);
} catch {}
try {
renderBundleEncoder34.drawIndexed(1_322, 6, 3_899, 1_116_691_683, 239_236_828);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer15, 2_104);
} catch {}
try {
renderBundleEncoder39.setPipeline(pipeline120);
} catch {}
try {
commandEncoder124.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 46 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 5506 */
  offset: 5506,
  buffer: buffer13,
}, {width: 23, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder187.clearBuffer(buffer36, 41772, 2328);
} catch {}
try {
commandEncoder201.resolveQuerySet(querySet33, 1, 5, buffer31, 24064);
} catch {}
try {
computePassEncoder95.insertDebugMarker('\u1efd');
} catch {}
try {
device1.queue.submit([commandBuffer25, commandBuffer38]);
} catch {}
try {
device1.queue.writeBuffer(buffer13, 8876, new Int16Array(29787), 6452, 1296);
} catch {}
try {
gpuCanvasContext18.unconfigure();
} catch {}
try {
  await promise51;
} catch {}
let textureView257 = texture88.createView({label: '\u5192\u{1f6b2}\uc93e\u050e\u940b', dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 3});
try {
computePassEncoder92.setBindGroup(2, bindGroup47);
} catch {}
try {
renderBundleEncoder100.setBindGroup(2, bindGroup51);
} catch {}
try {
commandEncoder141.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 117940 */
  offset: 2740,
  bytesPerRow: 256,
  rowsPerImage: 50,
  buffer: buffer23,
}, {
  texture: texture117,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, {width: 14, height: 0, depthOrArrayLayers: 10});
} catch {}
try {
commandEncoder184.copyTextureToTexture({
  texture: texture113,
  mipLevel: 0,
  origin: {x: 9, y: 4, z: 0},
  aspect: 'all',
},
{
  texture: texture113,
  mipLevel: 1,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
},
{width: 6, height: 14, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext14.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device2.queue.submit([commandBuffer40]);
} catch {}
let commandBuffer49 = commandEncoder191.finish();
try {
computePassEncoder117.setPipeline(pipeline158);
} catch {}
try {
renderBundleEncoder77.setBindGroup(1, bindGroup49);
} catch {}
try {
renderBundleEncoder106.insertDebugMarker('\u5107');
} catch {}
let pipeline169 = device2.createComputePipeline({layout: pipelineLayout13, compute: {module: shaderModule27, entryPoint: 'compute0', constants: {}}});
try {
gpuCanvasContext0.unconfigure();
} catch {}
let querySet101 = device1.createQuerySet({label: '\u{1f664}\uc395\u8e18\udb85', type: 'occlusion', count: 3238});
let textureView258 = texture50.createView({label: '\u2f4d\u7124\ub8b5', dimension: '2d-array', baseMipLevel: 5});
let renderBundleEncoder107 = device1.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'r32uint', 'r8unorm', undefined, 'rg8sint'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle131 = renderBundleEncoder73.finish({label: '\u05fd\u{1faf7}\u{1feaa}\u98bd\u05e3\u{1f9e1}'});
let sampler96 = device1.createSampler({
  label: '\u7787\u0629\uee60\ub487',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 32.56,
  lodMaxClamp: 73.15,
});
try {
renderBundleEncoder82.setBindGroup(2, bindGroup59);
} catch {}
try {
renderBundleEncoder34.drawIndexedIndirect(buffer42, 1_576);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer42, 52);
} catch {}
try {
commandEncoder116.copyBufferToTexture({
  /* bytesInLastRow: 432 widthInBlocks: 108 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 33764 */
  offset: 33764,
  buffer: buffer18,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
}, {width: 108, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder117.copyTextureToTexture({
  texture: texture48,
  mipLevel: 1,
  origin: {x: 53, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture48,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise65 = adapter3.requestAdapterInfo();
let querySet102 = device4.createQuerySet({label: '\u{1fe5c}\u{1faf8}\u03ed\u0616\ub8ce\u5425\u{1f81d}', type: 'occlusion', count: 2794});
try {
renderBundleEncoder97.setVertexBuffer(4_294_967_295, undefined, 44_261_319, 627_316_587);
} catch {}
document.body.prepend(video34);
let canvas35 = document.createElement('canvas');
let img24 = await imageWithData(176, 2, '#3c093c0b', '#cad09756');
let imageData34 = new ImageData(208, 64);
let shaderModule39 = device4.createShaderModule({
  label: '\u{1fbf7}\u22da\ud5e8\u92b7\u22f9\u5359\u0e02\u938a\u{1f73f}\u{1f78c}',
  code: `@group(0) @binding(910)
var<storage, read_write> field8: array<u32>;

@compute @workgroup_size(5, 1, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(5) f0: vec3<f32>,
  @location(2) f1: vec4<f32>,
  @location(4) f2: vec4<i32>,
  @location(1) f3: vec4<i32>,
  @location(3) f4: vec3<f32>,
  @location(0) f5: vec4<u32>
}

@fragment
fn fragment0(@builtin(front_facing) a0: bool, @builtin(position) a1: vec4<f32>, @builtin(sample_index) a2: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S33 {
  @location(13) f0: vec3<f32>,
  @location(4) f1: vec4<i32>,
  @location(7) f2: vec3<f16>,
  @location(14) f3: vec2<i32>
}

@vertex
fn vertex0(@location(2) a0: vec4<f32>, @location(5) a1: vec4<f16>, @builtin(vertex_index) a2: u32, @location(12) a3: vec4<u32>, @location(9) a4: u32, @location(3) a5: vec4<i32>, @location(11) a6: i32, @location(0) a7: vec2<u32>, @location(15) a8: i32, @builtin(instance_index) a9: u32, a10: S33, @location(8) a11: vec2<u32>, @location(1) a12: vec4<f16>, @location(10) a13: vec3<f32>, @location(6) a14: vec3<f32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
});
let textureView259 = texture129.createView({
  label: '\u0597\u{1fa97}\u{1fc88}\uae6f\u430f\u{1f9a1}\ufa86\u1dcf\u0924',
  baseMipLevel: 4,
  baseArrayLayer: 0,
});
let sampler97 = device4.createSampler({
  label: '\u0644\u51cd\u{1f76c}\u{1f89b}\u{1fdec}\u9589\u0036\u6c34',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 1.881,
});
try {
computePassEncoder108.setPipeline(pipeline165);
} catch {}
try {
renderBundleEncoder93.setPipeline(pipeline166);
} catch {}
try {
commandEncoder211.clearBuffer(buffer30, 258104, 8760);
} catch {}
let pipeline170 = device4.createRenderPipeline({
  layout: pipelineLayout17,
  fragment: {
  module: shaderModule34,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.GREEN}, {format: 'rgba8sint', writeMask: 0}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg11b10ufloat', writeMask: 0}, {format: 'rg8sint', writeMask: GPUColorWrite.BLUE}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule34,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 152, stepMode: 'vertex', attributes: []},
      {arrayStride: 88, attributes: []},
      {
        arrayStride: 592,
        attributes: [
          {format: 'float16x2', offset: 44, shaderLocation: 3},
          {format: 'uint16x2', offset: 100, shaderLocation: 11},
          {format: 'snorm8x4', offset: 0, shaderLocation: 10},
          {format: 'unorm16x2', offset: 80, shaderLocation: 8},
          {format: 'sint8x4', offset: 84, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 56,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 2},
          {format: 'unorm16x2', offset: 24, shaderLocation: 9},
          {format: 'snorm8x4', offset: 4, shaderLocation: 7},
          {format: 'float16x4', offset: 12, shaderLocation: 6},
          {format: 'float16x4', offset: 8, shaderLocation: 14},
        ],
      },
      {arrayStride: 564, stepMode: 'vertex', attributes: []},
      {arrayStride: 52, stepMode: 'instance', attributes: []},
      {arrayStride: 1572, stepMode: 'instance', attributes: []},
      {
        arrayStride: 64,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm16x4', offset: 12, shaderLocation: 13},
          {format: 'snorm16x2', offset: 4, shaderLocation: 15},
          {format: 'float32x3', offset: 20, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'cw'},
});
let gpuCanvasContext32 = canvas35.getContext('webgpu');
try {
  await promise65;
} catch {}
let commandEncoder218 = device3.createCommandEncoder({label: '\u03de\ubcd2\ubd24\u05e8\u43f0\u051e\u0f26'});
let texture143 = device3.createTexture({
  label: '\u{1f837}\u29a5\ua2e4\u2b94\u0561\udac7\u0c31\u011d',
  size: {width: 87},
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView260 = texture106.createView({label: '\u5010\u13d4\u0146\u{1ff2e}\u5e66', dimension: '2d-array'});
let computePassEncoder119 = commandEncoder217.beginComputePass({label: '\u15f6\udfbd\u3883\u079a\u{1fcf5}\u98a3\u053c\uefbf\u3eee\u3843\u09e5'});
let sampler98 = device3.createSampler({
  label: '\u8804\u{1fa12}\u{1f777}\u2ab2\ubb15\u0a19\uc8bd\u{1fed5}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMaxClamp: 95.75,
});
try {
commandEncoder168.copyTextureToBuffer({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 8222 */
  offset: 8222,
  bytesPerRow: 256,
  buffer: buffer38,
}, {width: 9, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
  await device3.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext22.unconfigure();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
document.body.prepend(video0);
let canvas36 = document.createElement('canvas');
let querySet103 = device2.createQuerySet({
  label: '\ue43e\u0452\udcc5\uab62\uffe3\u051b\ua892\u10ea\u6ddf\u3c85\ud40b',
  type: 'occlusion',
  count: 3505,
});
let renderBundleEncoder108 = device2.createRenderBundleEncoder({
  label: '\u0a17\u025c',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  stencilReadOnly: true,
});
let renderBundle132 = renderBundleEncoder57.finish({label: '\ueba7\ue10a\ub45d\u{1fa97}\u20ef\u082d\uc54d\u5fc3\u083f'});
try {
  await device2.popErrorScope();
} catch {}
try {
commandEncoder159.copyTextureToTexture({
  texture: texture114,
  mipLevel: 1,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture114,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline171 = device2.createComputePipeline({
  label: '\u3c5b\u0966\u0141\u63ca\u0264\u0c49',
  layout: pipelineLayout13,
  compute: {module: shaderModule28, entryPoint: 'compute0'},
});
offscreenCanvas21.width = 978;
gc();
try {
canvas36.getContext('webgl');
} catch {}
let bindGroupLayout63 = device2.createBindGroupLayout({
  label: '\ubfb0\u3e23\uaa3f\u6f7f',
  entries: [
    {
      binding: 593,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 699,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '2d' },
    },
    {
      binding: 461,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 27031655, hasDynamicOffset: true },
    },
  ],
});
let renderBundleEncoder109 = device2.createRenderBundleEncoder({
  label: '\u{1f8ba}\u0837\uaec0\udacc\u{1ff95}\u06b1\u09de\u0471',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
});
try {
computePassEncoder74.setBindGroup(3, bindGroup50, new Uint32Array(9990), 1252, 0);
} catch {}
try {
computePassEncoder73.dispatchWorkgroupsIndirect(buffer33, 151716);
} catch {}
try {
renderBundleEncoder91.setBindGroup(1, bindGroup47);
} catch {}
try {
renderBundleEncoder77.setVertexBuffer(6, buffer43);
} catch {}
try {
commandEncoder147.copyBufferToTexture({
  /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 29700 */
  offset: 972,
  bytesPerRow: 256,
  buffer: buffer33,
}, {
  texture: texture126,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 14, height: 113, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder208.clearBuffer(buffer33, 135336, 28276);
} catch {}
try {
device2.queue.writeBuffer(buffer43, 872, new BigUint64Array(18996), 7739, 124);
} catch {}
let pipeline172 = device2.createComputePipeline({
  label: '\u6a1a\u{1fcaa}',
  layout: pipelineLayout16,
  compute: {module: shaderModule28, entryPoint: 'compute0', constants: {}},
});
let commandBuffer50 = commandEncoder45.finish({});
try {
renderBundleEncoder89.setBindGroup(3, bindGroup42);
} catch {}
try {
renderBundleEncoder50.draw(130, 6, 251_437_458, 616_570_224);
} catch {}
try {
commandEncoder178.copyTextureToBuffer({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 131, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1238 widthInBlocks: 619 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 50366 */
  offset: 50366,
  buffer: buffer2,
}, {width: 619, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder121.copyTextureToTexture({
  texture: texture98,
  mipLevel: 1,
  origin: {x: 389, y: 5, z: 8},
  aspect: 'all',
},
{
  texture: texture16,
  mipLevel: 0,
  origin: {x: 46, y: 0, z: 0},
  aspect: 'all',
},
{width: 52, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline173 = await promise53;
try {
externalTexture84.label = '\u6ee5\u04f2\u{1fda1}\u06c7\u41f4\uf5cb\ucf04';
} catch {}
let bindGroup75 = device2.createBindGroup({
  label: '\u057d\ub64e\u531c\u0ab3\u9ae5\u08fc\u9e17\u4f68',
  layout: bindGroupLayout59,
  entries: [{binding: 193, resource: sampler75}, {binding: 59, resource: externalTexture80}],
});
let commandEncoder219 = device2.createCommandEncoder({label: '\ua9ab\u0c31\u0408\u{1f7e5}\u{1fff8}\u68bf\u45d0'});
let querySet104 = device2.createQuerySet({label: '\u4504\u9056\ua1e9\u{1fa79}\u3102\u0c5f\u688d', type: 'occlusion', count: 1918});
let texture144 = device2.createTexture({
  label: '\u33f8\u6787\u3153\u0da6\u{1fc77}\u{1f63d}\u9217\u0382\u7c63',
  size: {width: 240, height: 24, depthOrArrayLayers: 242},
  mipLevelCount: 7,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8sint', 'rgba8sint'],
});
let textureView261 = texture109.createView({label: '\u3148\u2f21\u0698\u{1f66a}\ucae3', dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1});
let externalTexture112 = device2.importExternalTexture({label: '\u7150\uc323\uc2fa\u6bd5\u7490\ub32a\u{1fa63}\u0af8\u5351', source: videoFrame16});
try {
computePassEncoder88.setBindGroup(2, bindGroup50, new Uint32Array(6578), 2592, 0);
} catch {}
try {
renderBundleEncoder90.setBindGroup(3, bindGroup75);
} catch {}
let commandEncoder220 = device3.createCommandEncoder({label: '\u01ae\udeb8\u09fe\u0543\u{1f6be}\u6652\u{1fe8a}\u{1fc13}\u{1f85d}\u0e95'});
let textureView262 = texture141.createView({aspect: 'all'});
let computePassEncoder120 = commandEncoder218.beginComputePass();
let externalTexture113 = device3.importExternalTexture({
  label: '\ubbca\u6db5\u0360\u{1fff5}\u{1fb90}\u9137\u04cc\u06c0\u0456\u9bb1',
  source: video10,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder98.setBindGroup(2, bindGroup64);
} catch {}
try {
device3.queue.writeBuffer(buffer38, 20716, new Int16Array(24186), 7623, 228);
} catch {}
try {
window.someLabel = renderBundleEncoder22.label;
} catch {}
let pipelineLayout20 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout39, bindGroupLayout39]});
let buffer44 = device0.createBuffer({
  label: '\udc77\u044f\u2db0\u5469',
  size: 23141,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
});
let texture145 = gpuCanvasContext5.getCurrentTexture();
let textureView263 = texture104.createView({
  label: '\u0b51\u{1fa23}\u7e87\u{1f620}\u91b2\u{1f944}\uff33\u05c1\uf5c9\u41d1\u{1fc8f}',
  baseMipLevel: 2,
  baseArrayLayer: 35,
  arrayLayerCount: 88,
});
let renderBundle133 = renderBundleEncoder2.finish({label: '\u0cbc\uf363\u0c56\u091c\u00f8\u2acb\u{1fd7a}\u09d1\u12e0\u02f6\ud4bd'});
try {
renderPassEncoder13.setBindGroup(0, bindGroup20, new Uint32Array(6609), 1645, 0);
} catch {}
try {
renderPassEncoder13.setBlendConstant({ r: 718.5, g: -310.9, b: -377.2, a: 462.6, });
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline106);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 145_248);
} catch {}
try {
commandEncoder134.copyTextureToTexture({
  texture: texture135,
  mipLevel: 1,
  origin: {x: 32, y: 1, z: 13},
  aspect: 'all',
},
{
  texture: texture29,
  mipLevel: 0,
  origin: {x: 875, y: 44, z: 21},
  aspect: 'all',
},
{width: 87, height: 108, depthOrArrayLayers: 1});
} catch {}
try {
window.someLabel = sampler67.label;
} catch {}
let buffer45 = device3.createBuffer({size: 48780, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder221 = device3.createCommandEncoder({label: '\u{1fc75}\u{1fec8}\u{1f884}\u9056\u0406\u{1ffb4}\ua76b'});
try {
device3.queue.writeTexture({
  texture: texture103,
  mipLevel: 2,
  origin: {x: 10, y: 0, z: 6},
  aspect: 'all',
}, new Float64Array(arrayBuffer0), /* required buffer size: 1_868_390 */
{offset: 514, bytesPerRow: 514, rowsPerImage: 158}, {width: 180, height: 0, depthOrArrayLayers: 24});
} catch {}
let bindGroupLayout64 = device3.createBindGroupLayout({entries: [{binding: 852, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}]});
let textureView264 = texture105.createView({
  label: '\u8082\u0c4f\u0cd6\u0aa9\u77cc\u{1fb23}\uf241\u7e0d\u{1f858}\uf0db\u5b8d',
  dimension: '2d',
  format: 'astc-12x10-unorm',
  baseArrayLayer: 35,
});
try {
device3.queue.writeTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(arrayBuffer10), /* required buffer size: 384 */
{offset: 384, rowsPerImage: 194}, {width: 13, height: 0, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas30 = new OffscreenCanvas(125, 372);
let commandEncoder222 = device1.createCommandEncoder({label: '\u0d33\ua9d6\ub3dd\ufdae\u{1fe3f}'});
let texture146 = device1.createTexture({
  label: '\u{1fc9a}\udad1',
  size: [1100, 12, 48],
  mipLevelCount: 6,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32uint'],
});
let sampler99 = device1.createSampler({
  label: '\u{1ffcd}\u5bdc',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 73.58,
  lodMaxClamp: 85.14,
  maxAnisotropy: 1,
});
try {
computePassEncoder81.setPipeline(pipeline75);
} catch {}
try {
renderBundleEncoder61.setBindGroup(0, bindGroup30);
} catch {}
try {
renderBundleEncoder34.drawIndexed(3_575, 510, 5_082, 554_949_601, 810_653_349);
} catch {}
try {
renderBundleEncoder34.drawIndexedIndirect(buffer15, 6_100);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer13, 42_348);
} catch {}
try {
commandEncoder182.copyBufferToBuffer(buffer15, 27808, buffer28, 38836, 1188);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture137,
  mipLevel: 2,
  origin: {x: 4, y: 2, z: 0},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 59 */
{offset: 59, bytesPerRow: 265}, {width: 66, height: 16, depthOrArrayLayers: 0});
} catch {}
let querySet105 = device0.createQuerySet({label: '\u9a66\u{1f732}\u08a4\u0295\u6d39\u0ffb\u0d70\u0f26', type: 'occlusion', count: 1034});
let texture147 = device0.createTexture({
  label: '\ue2b6\u{1f686}\u1629\u{1f972}\u1399\u01e9\u3b01\u1768\u{1fcf6}',
  size: [660, 480, 124],
  mipLevelCount: 4,
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder121 = commandEncoder20.beginComputePass({label: '\u{1fa1b}\u{1f824}\uf6c8\u0f08\u910d\u996e'});
let renderPassEncoder15 = commandEncoder52.beginRenderPass({
  colorAttachments: [{
  view: textureView227,
  clearValue: { r: 822.3, g: 533.2, b: -119.4, a: -679.5, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet19,
});
try {
renderPassEncoder15.setBindGroup(0, bindGroup70);
} catch {}
try {
renderPassEncoder8.executeBundles([renderBundle107, renderBundle42, renderBundle107, renderBundle73, renderBundle69, renderBundle117, renderBundle107, renderBundle117, renderBundle73, renderBundle42]);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: 994.9, g: 643.9, b: 854.2, a: -26.22, });
} catch {}
try {
renderPassEncoder8.setStencilReference(1372);
} catch {}
try {
renderPassEncoder8.setViewport(123.2, 8.272, 38.58, 70.91, 0.7501, 0.9461);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline67);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(6, buffer24, 175_908, 24_745);
} catch {}
try {
renderBundleEncoder50.drawIndexed(92, 489, 1_961, 491_116_097, 1_607_639_637);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer0, 53_896);
} catch {}
try {
commandEncoder103.copyTextureToTexture({
  texture: texture135,
  mipLevel: 1,
  origin: {x: 7, y: 14, z: 3},
  aspect: 'all',
},
{
  texture: texture60,
  mipLevel: 0,
  origin: {x: 81, y: 0, z: 0},
  aspect: 'all',
},
{width: 126, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder131.popDebugGroup();
} catch {}
try {
renderBundleEncoder88.insertDebugMarker('\u0321');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture27,
  mipLevel: 3,
  origin: {x: 0, y: 2, z: 8},
  aspect: 'all',
}, arrayBuffer2, /* required buffer size: 1_324_298 */
{offset: 762, bytesPerRow: 78, rowsPerImage: 261}, {width: 16, height: 4, depthOrArrayLayers: 66});
} catch {}
let pipeline174 = device0.createComputePipeline({
  label: '\u0b09\u{1f723}\ud27e\u0d4a\ub0dc\ub174\u412a\u4bf7\u{1ff43}',
  layout: pipelineLayout3,
  compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}},
});
let pipeline175 = await promise63;
try {
gpuCanvasContext18.unconfigure();
} catch {}
let video35 = await videoWithData();
try {
externalTexture113.label = '\uc5ad\u0842\ua9e2\u0927\u{1fd28}\u{1fba4}';
} catch {}
let bindGroup76 = device3.createBindGroup({
  label: '\u866e\u8108\ub3b3\u45f7\u45fc\u7a25',
  layout: bindGroupLayout64,
  entries: [{binding: 852, resource: externalTexture105}],
});
let buffer46 = device3.createBuffer({
  label: '\ue2ef\ud53a\uc224\u041c\ud7cf\u{1f9b4}\u72b1\u{1fc1d}',
  size: 769447,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder223 = device3.createCommandEncoder();
try {
renderBundleEncoder104.setBindGroup(2, bindGroup69);
} catch {}
try {
commandEncoder221.clearBuffer(buffer46, 555856, 177532);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
video17.width = 98;
let promise66 = navigator.gpu.requestAdapter();
let commandEncoder224 = device4.createCommandEncoder({label: '\u{1fef5}\u{1febb}\u2cfa\u1b11\u0c30\u0ae6\u0c46\u70e4\u{1fe78}\u6e81'});
let commandBuffer51 = commandEncoder212.finish({label: '\ucf4d\u4b53\u6132\u{1f98c}\u47bd'});
let renderBundle134 = renderBundleEncoder97.finish({label: '\uafc5\u0c41\ue043\ub4e2\u4deb\u{1fc77}\u0e18'});
let externalTexture114 = device4.importExternalTexture({
  label: '\u104f\u0f2a\u12ed\u203f\ue4e2\u985c\u2f91\u5dc8\u0878\u06c3',
  source: video23,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder101.setPipeline(pipeline170);
} catch {}
try {
buffer30.unmap();
} catch {}
canvas23.height = 1318;
let computePassEncoder122 = commandEncoder205.beginComputePass();
let renderBundleEncoder110 = device1.createRenderBundleEncoder({
  label: '\u8c35\u14cb\u0fa6',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder50.setPipeline(pipeline136);
} catch {}
let promise67 = device1.queue.onSubmittedWorkDone();
let pipeline176 = await device1.createComputePipelineAsync({
  label: '\u0553\u1100\u76a1\ub612\u4730\udbae\uf27e\u55d7\u033f\u07ea\u1029',
  layout: pipelineLayout5,
  compute: {module: shaderModule11, entryPoint: 'compute0'},
});
let img25 = await imageWithData(27, 18, '#1be4c278', '#db8cdce8');
let commandEncoder225 = device3.createCommandEncoder();
let renderBundleEncoder111 = device3.createRenderBundleEncoder({
  label: '\u5e5b\ue0e2\u9933\u1f39\u{1f74e}\u3ca1\ua175\u0132',
  colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'],
  depthReadOnly: true,
});
try {
renderBundleEncoder104.setVertexBuffer(4_294_967_295, undefined, 210_079_898);
} catch {}
try {
commandEncoder221.copyTextureToBuffer({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 136 widthInBlocks: 68 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7860 */
  offset: 7860,
  buffer: buffer38,
}, {width: 68, height: 0, depthOrArrayLayers: 1});
} catch {}
let commandBuffer52 = commandEncoder224.finish({label: '\u{1f7b5}\ua64e\u{1fade}\u089f\u9685\u9528\ufe22\u0e16'});
try {
renderBundleEncoder92.setPipeline(pipeline170);
} catch {}
try {
commandEncoder199.copyTextureToBuffer({
  texture: texture125,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1252 */
  offset: 1252,
  buffer: buffer30,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
let video36 = await videoWithData();
let commandEncoder226 = device2.createCommandEncoder();
let texture148 = device2.createTexture({
  label: '\ud06a\u{1f8f2}\u{1f95f}\u{1fb1e}\u0ada\u{1fd36}',
  size: {width: 180, height: 1, depthOrArrayLayers: 123},
  mipLevelCount: 8,
  sampleCount: 1,
  dimension: '3d',
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let textureView265 = texture87.createView({label: '\u{1f93a}\u{1ff98}\u2605', baseMipLevel: 5});
try {
renderBundleEncoder77.setBindGroup(0, bindGroup72);
} catch {}
try {
commandEncoder184.resolveQuerySet(querySet63, 298, 131, buffer23, 44288);
} catch {}
let pipeline177 = await device2.createComputePipelineAsync({
  label: '\u03ae\u{1f71d}\u0295\u5823\u08a6\u1df8\ubaeb\u01ae\ueaf1',
  layout: pipelineLayout14,
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let pipeline178 = device2.createRenderPipeline({
  layout: pipelineLayout9,
  multisample: {count: 4, mask: 0xaf5da1de},
  fragment: {
  module: shaderModule27,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rgba8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE,
}, {format: 'r8unorm'}, {format: 'r8sint', writeMask: GPUColorWrite.BLUE}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba8sint', writeMask: 0}],
},
  vertex: {
    module: shaderModule27,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 292, stepMode: 'instance', attributes: []},
      {
        arrayStride: 488,
        attributes: [
          {format: 'float32', offset: 40, shaderLocation: 13},
          {format: 'uint32x3', offset: 32, shaderLocation: 11},
          {format: 'snorm16x2', offset: 276, shaderLocation: 9},
        ],
      },
      {arrayStride: 96, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 112,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 40, shaderLocation: 1}],
      },
      {arrayStride: 108, attributes: []},
      {arrayStride: 176, stepMode: 'instance', attributes: []},
      {arrayStride: 36, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 328,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 4, shaderLocation: 15},
          {format: 'uint32', offset: 32, shaderLocation: 14},
          {format: 'uint32', offset: 24, shaderLocation: 0},
          {format: 'sint32', offset: 12, shaderLocation: 10},
          {format: 'uint8x4', offset: 20, shaderLocation: 2},
          {format: 'uint16x4', offset: 80, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'ccw'},
});
let adapter6 = await navigator.gpu.requestAdapter({});
let videoFrame26 = new VideoFrame(offscreenCanvas3, {timestamp: 0});
let commandEncoder227 = device4.createCommandEncoder({label: '\u86a2\ua163\u4e07\u08fe'});
try {
renderBundleEncoder93.setPipeline(pipeline170);
} catch {}
try {
device4.queue.writeTexture({
  texture: texture124,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new DataView(arrayBuffer11), /* required buffer size: 783 */
{offset: 783}, {width: 150, height: 0, depthOrArrayLayers: 1});
} catch {}
let promise68 = device4.queue.onSubmittedWorkDone();
let gpuCanvasContext33 = offscreenCanvas30.getContext('webgpu');
let canvas37 = document.createElement('canvas');
let imageData35 = new ImageData(168, 212);
let videoFrame27 = new VideoFrame(img23, {timestamp: 0});
let bindGroup77 = device0.createBindGroup({
  label: '\u7b6c\u{1f65d}\u{1f763}\u25da\u4d0a\u0138\u0660\u04f0\u{1fe6d}\u0e29\ude76',
  layout: bindGroupLayout30,
  entries: [{binding: 319, resource: {buffer: buffer35, offset: 0, size: 3252}}],
});
let texture149 = device0.createTexture({
  size: {width: 165},
  dimension: '1d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView266 = texture67.createView({format: 'rgba8unorm', baseArrayLayer: 0});
try {
computePassEncoder24.dispatchWorkgroups(1, 4, 1);
} catch {}
try {
computePassEncoder83.end();
} catch {}
try {
computePassEncoder90.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder8.setViewport(0.9344, 111.1, 24.19, 1.046, 0.2405, 0.9607);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer3, 'uint32', 10_292, 3_808);
} catch {}
try {
renderPassEncoder8.setPipeline(pipeline106);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(4, buffer6, 9_636, 3_353);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer24, 64_696);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer0, 7_756);
} catch {}
try {
commandEncoder89.copyTextureToBuffer({
  texture: texture67,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 14672 */
  offset: 14672,
  buffer: buffer2,
}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder84.clearBuffer(buffer40, 424384, 42324);
} catch {}
try {
computePassEncoder99.pushDebugGroup('\u9aae');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: img5,
  origin: { x: 2, y: 5 },
  flipY: true,
}, {
  texture: texture9,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await adapter5.requestAdapterInfo();
} catch {}
try {
canvas37.getContext('bitmaprenderer');
} catch {}
let texture150 = device2.createTexture({
  label: '\u6e2f\u{1ffb3}\u0ebd\u76bc\u24e1\u0d00\u4749\u{1fb5f}',
  size: {width: 720, height: 1, depthOrArrayLayers: 222},
  mipLevelCount: 2,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView267 = texture84.createView({dimension: '2d', format: 'rgba8unorm-srgb', baseMipLevel: 4, baseArrayLayer: 71});
let sampler100 = device2.createSampler({
  label: '\u{1f773}\u{1f6ca}\u7ca6\u475a',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 88.93,
  lodMaxClamp: 90.78,
});
try {
renderBundleEncoder108.setBindGroup(1, bindGroup63);
} catch {}
try {
renderBundleEncoder106.setVertexBuffer(0, buffer43, 0, 394);
} catch {}
try {
commandEncoder141.copyBufferToBuffer(buffer41, 7148, buffer23, 417348, 6420);
} catch {}
try {
commandEncoder219.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 261232 */
  offset: 11592,
  bytesPerRow: 256,
  rowsPerImage: 57,
  buffer: buffer23,
}, {
  texture: texture108,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 5},
  aspect: 'all',
}, {width: 10, height: 7, depthOrArrayLayers: 18});
} catch {}
try {
commandEncoder188.copyTextureToTexture({
  texture: texture93,
  mipLevel: 5,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture93,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder183.resolveQuerySet(querySet78, 210, 801, buffer23, 112384);
} catch {}
let promise69 = device2.queue.onSubmittedWorkDone();
try {
device2.queue.copyExternalImageToTexture(/*
{width: 24, height: 16, depthOrArrayLayers: 104}
*/
{
  source: video13,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 45},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder228 = device2.createCommandEncoder({label: '\u377e\u87f1\ube5e\u861f\u601f\u0a3f'});
let textureView268 = texture85.createView({label: '\u65b4\u{1fa29}\u{1ff1c}\u0069\uff57\u0ab6\uda5b\u0b9f\ub70e\u04de\u4010'});
try {
renderBundleEncoder70.setBindGroup(3, bindGroup50, new Uint32Array(354), 313, 0);
} catch {}
try {
renderBundleEncoder90.setPipeline(pipeline133);
} catch {}
try {
buffer23.destroy();
} catch {}
try {
commandEncoder228.copyTextureToBuffer({
  texture: texture140,
  mipLevel: 1,
  origin: {x: 68, y: 0, z: 84},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2360 widthInBlocks: 590 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 14844 */
  offset: 14844,
  buffer: buffer33,
}, {width: 590, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.submit([commandBuffer36]);
} catch {}
let bindGroupLayout65 = device4.createBindGroupLayout({
  label: '\u0fca\uc0a7',
  entries: [
    {
      binding: 736,
      visibility: GPUShaderStage.FRAGMENT,
      buffer: { type: 'storage', minBindingSize: 74064691, hasDynamicOffset: false },
    },
    {binding: 901, visibility: GPUShaderStage.COMPUTE, externalTexture: {}},
  ],
});
let textureView269 = texture129.createView({baseMipLevel: 3, arrayLayerCount: 1});
let renderBundle135 = renderBundleEncoder94.finish({label: '\u6760\ub1ef\u9b96'});
try {
device4.addEventListener('uncapturederror', e => { log('device4.uncapturederror'); log(e); e.label = device4.label; });
} catch {}
try {
commandEncoder211.clearBuffer(buffer30, 60852, 44248);
} catch {}
let commandEncoder229 = device2.createCommandEncoder({label: '\u34ee\u{1fb63}\u0835'});
let computePassEncoder123 = commandEncoder184.beginComputePass({label: '\u974f\u04f2\u7611\u0935\u{1fd76}\u8a3d'});
try {
computePassEncoder73.dispatchWorkgroups(3);
} catch {}
try {
renderBundleEncoder106.setIndexBuffer(buffer43, 'uint32', 1_004, 455);
} catch {}
try {
device2.queue.writeBuffer(buffer33, 6168, new Int16Array(33130), 12866, 15028);
} catch {}
try {
gpuCanvasContext33.unconfigure();
} catch {}
let commandEncoder230 = device0.createCommandEncoder();
let textureView270 = texture22.createView({
  label: '\ucd82\u{1fd0c}\ub60d\u0d70',
  dimension: '2d',
  aspect: 'depth-only',
  format: 'depth16unorm',
  baseMipLevel: 6,
  mipLevelCount: 4,
  baseArrayLayer: 72,
});
let renderBundle136 = renderBundleEncoder9.finish({});
try {
renderPassEncoder12.setBlendConstant({ r: 385.4, g: -938.2, b: -583.4, a: -938.4, });
} catch {}
try {
renderPassEncoder6.setScissorRect(9, 71, 49, 15);
} catch {}
try {
renderBundleEncoder29.draw(72, 213, 57, 314_309_216);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.writeBuffer(buffer34, 63364, new Float32Array(52342), 24551, 1552);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture147,
  mipLevel: 2,
  origin: {x: 0, y: 15, z: 4},
  aspect: 'all',
}, new Float32Array(arrayBuffer13), /* required buffer size: 5_571_345 */
{offset: 317, bytesPerRow: 371, rowsPerImage: 158}, {width: 23, height: 7, depthOrArrayLayers: 96});
} catch {}
try {
  await promise68;
} catch {}
let canvas38 = document.createElement('canvas');
let commandEncoder231 = device0.createCommandEncoder({});
let renderBundle137 = renderBundleEncoder0.finish();
try {
renderPassEncoder8.setIndexBuffer(buffer6, 'uint16', 2_920, 3_771);
} catch {}
try {
renderBundleEncoder29.drawIndexed(117, 207, 2_503, 314_622_595, 462_970_100);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 10, height: 7, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap25,
  origin: { x: 122, y: 118 },
  flipY: true,
}, {
  texture: texture2,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 6, height: 0, depthOrArrayLayers: 0});
} catch {}
let querySet106 = device2.createQuerySet({label: '\udd04\u{1ff76}\u89f0\u{1fa4e}\u{1ff10}\u{1f831}\u5234', type: 'occlusion', count: 505});
try {
computePassEncoder114.setBindGroup(3, bindGroup50);
} catch {}
try {
computePassEncoder98.setPipeline(pipeline113);
} catch {}
try {
renderBundleEncoder90.setBindGroup(2, bindGroup48);
} catch {}
try {
commandEncoder164.copyBufferToBuffer(buffer41, 16256, buffer43, 472, 3132);
} catch {}
try {
commandEncoder188.clearBuffer(buffer43);
} catch {}
try {
commandEncoder229.resolveQuerySet(querySet63, 40, 42, buffer23, 179712);
} catch {}
try {
device2.queue.submit([]);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 24, height: 16, depthOrArrayLayers: 46}
*/
{
  source: imageData3,
  origin: { x: 14, y: 0 },
  flipY: false,
}, {
  texture: texture113,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 24, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
canvas38.getContext('webgpu');
} catch {}
let textureView271 = texture113.createView({dimension: '2d', format: 'bgra8unorm-srgb', baseMipLevel: 1, baseArrayLayer: 41});
try {
renderBundleEncoder76.setPipeline(pipeline168);
} catch {}
try {
commandEncoder159.copyBufferToTexture({
  /* bytesInLastRow: 244 widthInBlocks: 122 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 23754 */
  offset: 23254,
  bytesPerRow: 256,
  buffer: buffer23,
}, {
  texture: texture97,
  mipLevel: 0,
  origin: {x: 4, y: 8, z: 0},
  aspect: 'all',
}, {width: 122, height: 2, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder208.copyTextureToBuffer({
  texture: texture114,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 10 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 9513 */
  offset: 9513,
  bytesPerRow: 256,
  buffer: buffer23,
}, {width: 10, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder219.copyTextureToTexture({
  texture: texture140,
  mipLevel: 0,
  origin: {x: 339, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture108,
  mipLevel: 1,
  origin: {x: 0, y: 4, z: 3},
  aspect: 'all',
},
{width: 11, height: 0, depthOrArrayLayers: 16});
} catch {}
let pipeline179 = device2.createComputePipeline({
  label: '\u{1f910}\uf095\u0ec4\uc8a2\u{1f689}\u{1ff4d}\uca24\u06e4',
  layout: pipelineLayout14,
  compute: {module: shaderModule28, entryPoint: 'compute0'},
});
let commandEncoder232 = device3.createCommandEncoder({label: '\u9bf4\u9fd3\u04f7\u{1f633}\u4d9e\u{1fdca}\ube78\u4bdf\u00ab'});
let querySet107 = device3.createQuerySet({
  label: '\u09d4\u21e7\uaa4c\u24a5\u{1fc4a}\u092c\ucdff\u{1f7e6}\uad2f\u8bb5',
  type: 'occlusion',
  count: 2082,
});
let textureView272 = texture141.createView({label: '\u7fea\u0434', aspect: 'all'});
let sampler101 = device3.createSampler({
  label: '\u0303\u{1f65c}\u34ff\u818e\u448a\u1b4b',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 22.85,
  lodMaxClamp: 99.03,
  maxAnisotropy: 5,
});
try {
renderBundleEncoder111.setBindGroup(2, bindGroup64);
} catch {}
try {
renderBundleEncoder104.setBindGroup(1, bindGroup76, new Uint32Array(8656), 2695, 0);
} catch {}
try {
  await device3.popErrorScope();
} catch {}
try {
  await device3.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder233 = device3.createCommandEncoder({label: '\u0cbc\u0176\u08b0\u{1fa8e}\u7d71\u08d1\u{1f6f0}\u0719'});
let querySet108 = device3.createQuerySet({label: '\u076b\u0b5b\u00f4\ue8dc\uc8a6\u5c11\u7dae\u08de\ue318', type: 'occlusion', count: 3306});
let renderBundleEncoder112 = device3.createRenderBundleEncoder({
  label: '\u{1fe8a}\u{1fadb}\u{1fbb7}\uad60\u00bf\u8fc3\u{1fc7d}\udc8a\u7d00',
  colorFormats: ['rg8sint', 'rgba8unorm-srgb', 'rgba8uint', undefined, 'rgba8sint', 'rg32uint', 'rg8unorm'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle138 = renderBundleEncoder112.finish();
try {
commandEncoder223.copyTextureToTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture131,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 3},
  aspect: 'all',
},
{width: 12, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device3.queue.writeTexture({
  texture: texture105,
  mipLevel: 1,
  origin: {x: 60, y: 0, z: 2},
  aspect: 'all',
}, new ArrayBuffer(6_047_226), /* required buffer size: 6_047_226 */
{offset: 636, bytesPerRow: 502, rowsPerImage: 219}, {width: 192, height: 0, depthOrArrayLayers: 56});
} catch {}
try {
commandEncoder186.label = '\u5895\u0b8c\u0b11\u983d\u398d\u{1ff0f}\ucae0\u307c\ufcee\u{1f771}';
} catch {}
let commandEncoder234 = device2.createCommandEncoder({label: '\u0589\u{1fa2c}\u{1fb4c}\u0c24'});
let commandBuffer53 = commandEncoder141.finish({label: '\u{1f712}\u3cb4\u{1fa97}\ua411\u00f2\ua1ea\u0b68\u0a26'});
let textureView273 = texture102.createView({
  label: '\ub1b9\u3f91\u0c9c\u0696\uda09\u36d6\u7700\u0fce\u{1fee9}',
  baseMipLevel: 6,
  mipLevelCount: 2,
  baseArrayLayer: 126,
});
let computePassEncoder124 = commandEncoder219.beginComputePass({label: '\u386f\u6b0a\u0854\u{1faaa}\u5cbe\u09ce\u92cd\u0160\uf9ee\u0e49\ucdab'});
let externalTexture115 = device2.importExternalTexture({source: video0, colorSpace: 'srgb'});
try {
renderBundleEncoder106.setBindGroup(1, bindGroup63, new Uint32Array(7349), 3317, 0);
} catch {}
try {
renderBundleEncoder100.setVertexBuffer(0, buffer43, 1_796, 959);
} catch {}
try {
commandEncoder234.clearBuffer(buffer33, 117592, 22532);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture118,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 5},
  aspect: 'all',
}, arrayBuffer7, /* required buffer size: 474_602 */
{offset: 23, bytesPerRow: 63, rowsPerImage: 243}, {width: 8, height: 0, depthOrArrayLayers: 32});
} catch {}
let device5 = await adapter2.requestDevice({
  label: '\u{1f9b5}\u{1f6a8}\ue19d',
  defaultQueue: {label: '\u2271\u0cfc\uedd6\u32bb\u93e2\u4ac1\u0adb\ud1f7\u908f'},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
});
let imageBitmap26 = await createImageBitmap(offscreenCanvas4);
let buffer47 = device3.createBuffer({
  size: 226088,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let texture151 = device3.createTexture({
  size: [672],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['bgra8unorm'],
});
let renderBundleEncoder113 = device3.createRenderBundleEncoder({
  colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
device3.queue.writeTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer3), /* required buffer size: 587 */
{offset: 587}, {width: 72, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device4.queue.label = '\u0dfa\u{1fa0d}\ub621\u0a75\u0d7c\u0517';
} catch {}
let buffer48 = device4.createBuffer({
  size: 206204,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE,
  mappedAtCreation: false,
});
let commandEncoder235 = device4.createCommandEncoder({label: '\uee08\u{1f922}\u5976\u{1f706}'});
let querySet109 = device4.createQuerySet({type: 'occlusion', count: 211});
let commandBuffer54 = commandEncoder195.finish({label: '\u23f0\u2b19\u9dca\u70f2\u43dd'});
let computePassEncoder125 = commandEncoder235.beginComputePass({label: '\u{1fdbb}\u05af\u0146\u{1fb03}\u8c28'});
let renderBundle139 = renderBundleEncoder94.finish({label: '\u827b\u0314\u1fe2\u0f6e\uadb5\u0fdb\ud793\u0646\u{1fdfe}\u02a6'});
try {
renderBundleEncoder92.setPipeline(pipeline170);
} catch {}
try {
commandEncoder227.copyTextureToBuffer({
  texture: texture125,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5784 */
  offset: 5784,
  buffer: buffer30,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device4.queue.writeBuffer(buffer30, 52656, new Float32Array(64946), 13717, 760);
} catch {}
let pipeline180 = await device4.createRenderPipelineAsync({
  label: '\u0b1e\ufae6\u07fb\u0a47\ub586\ud797\u4145\u091f\ua0c0',
  layout: pipelineLayout17,
  fragment: {
  module: shaderModule34,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rgb10a2uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: 0}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'src'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'dst'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'rg8sint'}, {format: 'rg8unorm', writeMask: 0}],
},
  vertex: {
    module: shaderModule34,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 428, stepMode: 'instance', attributes: []},
      {arrayStride: 1516, stepMode: 'instance', attributes: []},
      {arrayStride: 184, attributes: [{format: 'unorm16x2', offset: 0, shaderLocation: 15}]},
      {arrayStride: 404, stepMode: 'instance', attributes: []},
      {arrayStride: 124, stepMode: 'instance', attributes: []},
      {arrayStride: 60, attributes: []},
      {arrayStride: 336, stepMode: 'instance', attributes: []},
      {
        arrayStride: 1748,
        attributes: [
          {format: 'snorm16x4', offset: 24, shaderLocation: 8},
          {format: 'sint8x4', offset: 268, shaderLocation: 2},
          {format: 'float32x4', offset: 160, shaderLocation: 7},
          {format: 'unorm16x2', offset: 308, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 440, shaderLocation: 12},
          {format: 'sint16x2', offset: 160, shaderLocation: 5},
          {format: 'uint32x3', offset: 160, shaderLocation: 11},
          {format: 'float32x2', offset: 8, shaderLocation: 9},
          {format: 'snorm8x4', offset: 688, shaderLocation: 3},
          {format: 'float32x2', offset: 268, shaderLocation: 13},
          {format: 'float16x2', offset: 72, shaderLocation: 14},
          {format: 'float32x2', offset: 928, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let bindGroupLayout66 = device4.createBindGroupLayout({
  entries: [
    {
      binding: 750,
      visibility: 0,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
    {
      binding: 703,
      visibility: GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '1d' },
    },
    {
      binding: 378,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      externalTexture: {},
    },
  ],
});
let textureView274 = texture136.createView({label: '\u243d\ua3b0\ud037\u{1f9fe}', baseMipLevel: 3});
try {
commandEncoder211.copyBufferToBuffer(buffer48, 178916, buffer30, 78460, 2608);
} catch {}
try {
commandEncoder227.copyBufferToTexture({
  /* bytesInLastRow: 186 widthInBlocks: 93 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 56516 */
  offset: 55050,
  bytesPerRow: 256,
  buffer: buffer48,
}, {
  texture: texture127,
  mipLevel: 0,
  origin: {x: 84, y: 0, z: 0},
  aspect: 'all',
}, {width: 93, height: 6, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder227.copyTextureToBuffer({
  texture: texture125,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 8560 */
  offset: 8560,
  buffer: buffer30,
}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder199.resolveQuerySet(querySet98, 97, 142, buffer48, 52224);
} catch {}
try {
device4.queue.submit([commandBuffer52, commandBuffer42]);
} catch {}
let pipeline181 = device4.createComputePipeline({layout: pipelineLayout17, compute: {module: shaderModule34, entryPoint: 'compute0'}});
let shaderModule40 = device2.createShaderModule({
  label: '\u4992\u83ef\uf7b0\u07d3\uef1e\u{1f7ae}\u0b10\ud1e8\u044e\u{1fa67}\u5f66',
  code: `@group(0) @binding(552)
var<storage, read_write> local10: array<u32>;

@compute @workgroup_size(8, 1, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(5) f0: vec2<f32>,
  @builtin(sample_mask) f1: u32,
  @location(6) f2: vec4<i32>,
  @location(1) f3: vec4<f32>,
  @location(4) f4: vec3<i32>,
  @location(3) f5: f32,
  @location(2) f6: vec4<f32>,
  @location(0) f7: vec4<f32>
}

@fragment
fn fragment0(@builtin(sample_mask) a0: u32, @builtin(position) a1: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(0) a0: i32, @location(6) a1: vec4<i32>, @location(15) a2: vec3<i32>, @location(14) a3: vec2<u32>, @builtin(instance_index) a4: u32, @location(9) a5: vec4<f32>, @location(3) a6: vec2<i32>, @location(2) a7: vec3<i32>, @location(13) a8: vec3<f32>, @location(10) a9: vec3<u32>, @location(5) a10: vec2<f16>, @location(12) a11: vec4<f16>, @location(11) a12: vec4<f32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
});
let commandEncoder236 = device2.createCommandEncoder();
let textureView275 = texture118.createView({
  label: '\u{1fa4a}\u{1f8c3}\u{1f6e8}\u4796\u0838\u826f\ua1d6\u{1f6fa}',
  mipLevelCount: 2,
  arrayLayerCount: 1,
});
let renderBundleEncoder114 = device2.createRenderBundleEncoder({
  label: '\u{1fd62}\u{1fc16}\u03d2\u086e\u{1fac1}\u{1fa39}\u9970\u8d49\u7095\u0485\u9ba2',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
});
let sampler102 = device2.createSampler({
  label: '\u59de\u{1fe50}\ub9cb\u0aa0\u{1ff00}',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 87.36,
  maxAnisotropy: 19,
});
try {
computePassEncoder76.setPipeline(pipeline130);
} catch {}
try {
commandEncoder226.clearBuffer(buffer33, 84408, 41504);
} catch {}
let shaderModule41 = device4.createShaderModule({
  label: '\u0b97\u290a\uc7b0\ubf40\uf268',
  code: `@group(0) @binding(910)
var<storage, read_write> local11: array<u32>;
@group(0) @binding(386)
var<storage, read_write> function15: array<u32>;
@group(1) @binding(386)
var<storage, read_write> field9: array<u32>;

@compute @workgroup_size(5, 3, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(5) f0: vec4<f32>,
  @location(2) f1: vec3<f32>,
  @builtin(sample_mask) f2: u32,
  @location(0) f3: vec4<u32>,
  @location(4) f4: vec4<i32>,
  @location(3) f5: vec3<f32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(15) f214: vec3<i32>,
  @location(0) f215: vec3<u32>,
  @location(10) f216: vec4<f16>,
  @location(11) f217: vec2<i32>,
  @location(4) f218: i32,
  @location(9) f219: vec2<u32>,
  @location(14) f220: f32,
  @location(3) f221: i32,
  @location(6) f222: f32,
  @location(7) f223: vec2<i32>,
  @location(2) f224: vec3<u32>,
  @builtin(position) f225: vec4<f32>,
  @location(1) f226: vec3<i32>
}

@vertex
fn vertex0(@location(2) a0: vec4<f16>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
try {
commandEncoder227.copyBufferToTexture({
  /* bytesInLastRow: 308 widthInBlocks: 154 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 16110 */
  offset: 16110,
  buffer: buffer48,
}, {
  texture: texture127,
  mipLevel: 0,
  origin: {x: 19, y: 0, z: 0},
  aspect: 'all',
}, {width: 154, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder211.clearBuffer(buffer30, 145152, 12460);
} catch {}
try {
commandEncoder199.resolveQuerySet(querySet91, 652, 419, buffer48, 37888);
} catch {}
let pipeline182 = await device4.createComputePipelineAsync({
  label: '\u0a5f\u{1fb04}\u3ea5\u7d60\u521d\u{1f8d9}',
  layout: pipelineLayout17,
  compute: {module: shaderModule39, entryPoint: 'compute0', constants: {}},
});
let querySet110 = device3.createQuerySet({label: '\u0022\u0c41\uec57\u0acb\u4fbd\u03b3\u0ade', type: 'occlusion', count: 2241});
let textureView276 = texture141.createView({label: '\u1833\u086c\u032f\u01fb\uee81\u945e\u95a8\ud51d\ud96d\uae52\u56de', baseArrayLayer: 0});
let renderBundleEncoder115 = device3.createRenderBundleEncoder({
  label: '\u03dd\u{1fbd9}\ub8ff',
  colorFormats: ['rgba32sint', 'rg32uint', 'rg16sint', 'r32uint'],
  sampleCount: 4,
});
try {
renderBundleEncoder113.setBindGroup(2, bindGroup64);
} catch {}
try {
device3.addEventListener('uncapturederror', e => { log('device3.uncapturederror'); log(e); e.label = device3.label; });
} catch {}
try {
commandEncoder168.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 28364 */
  offset: 28364,
  bytesPerRow: 256,
  buffer: buffer47,
}, {
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder221.resolveQuerySet(querySet89, 874, 774, buffer47, 117248);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(40), /* required buffer size: 266 */
{offset: 122}, {width: 72, height: 1, depthOrArrayLayers: 1});
} catch {}
let video37 = await videoWithData();
let buffer49 = device3.createBuffer({
  label: '\u0cdf\u{1f9de}\ua1d4\u5d15\ue971\ud8eb\u1a29\u019c\u060e',
  size: 28256,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder237 = device3.createCommandEncoder({label: '\u7016\u8d58\u0ed7\u{1fdf7}'});
let texture152 = device3.createTexture({
  label: '\u0df1\u067a\u05e3\u2a5d\u4291\u6b43\ubef4\u{1f699}\u{1fd56}\u84e9',
  size: [168, 7, 211],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder126 = commandEncoder207.beginComputePass({});
let renderBundleEncoder116 = device3.createRenderBundleEncoder({colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'], stencilReadOnly: true});
let renderBundle140 = renderBundleEncoder111.finish({label: '\ua26b\u4428\uf0c5\u0ff1\u0630\u{1f8ef}\u1441'});
let sampler103 = device3.createSampler({
  label: '\u{1f6f0}\u20f5\uca78\uc073\u1307\u2bc3',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 49.53,
  lodMaxClamp: 79.00,
  compare: 'not-equal',
  maxAnisotropy: 13,
});
try {
computePassEncoder120.setBindGroup(2, bindGroup64);
} catch {}
try {
device3.pushErrorScope('internal');
} catch {}
try {
commandEncoder237.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1020 */
  offset: 1020,
  buffer: buffer47,
}, {
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
let querySet111 = device0.createQuerySet({
  label: '\u05b5\uf18e\u454b\u{1fe48}\u01f1\u{1f9b8}\ua4f6\u04ba\u0f0c\u0a68\uc102',
  type: 'occlusion',
  count: 3470,
});
let textureView277 = texture70.createView({label: '\u{1f617}\u794c\ua746\u886c\ub313\u{1ffd8}\u1161\u0d7b\udf06\u9a80'});
let renderBundle141 = renderBundleEncoder7.finish({label: '\u0ec2\u1bce\u1e1c\u{1f96e}\u60d4\uc48d\ucce6\u7316\u7d2c\u9c18'});
try {
renderPassEncoder8.setScissorRect(103, 79, 50, 32);
} catch {}
try {
renderPassEncoder8.setStencilReference(2542);
} catch {}
try {
renderBundleEncoder27.setBindGroup(1, bindGroup11, new Uint32Array(209), 21, 0);
} catch {}
try {
renderBundleEncoder29.draw(13, 53, 25, 1_097_609_895);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer10, 3_184);
} catch {}
try {
renderBundleEncoder96.setVertexBuffer(7, buffer5, 0, 199_787);
} catch {}
try {
commandEncoder87.copyBufferToBuffer(buffer1, 159384, buffer7, 1072, 46284);
} catch {}
try {
commandEncoder134.copyTextureToBuffer({
  texture: texture98,
  mipLevel: 0,
  origin: {x: 189, y: 7, z: 46},
  aspect: 'all',
}, {
  /* bytesInLastRow: 996 widthInBlocks: 249 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 224192 */
  offset: 8156,
  bytesPerRow: 1024,
  buffer: buffer1,
}, {width: 249, height: 211, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder179.copyTextureToTexture({
  texture: texture66,
  mipLevel: 0,
  origin: {x: 42, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture101,
  mipLevel: 2,
  origin: {x: 29, y: 7, z: 56},
  aspect: 'all',
},
{width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 45432, new DataView(new ArrayBuffer(11117)), 10069);
} catch {}
let pipeline183 = device0.createRenderPipeline({
  layout: pipelineLayout6,
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm'}, {format: 'rg16float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {compare: 'greater-equal', failOp: 'increment-clamp', depthFailOp: 'invert', passOp: 'zero'},
    stencilBack: {compare: 'never', failOp: 'replace', depthFailOp: 'increment-clamp', passOp: 'replace'},
    stencilReadMask: 3206075276,
    stencilWriteMask: 3667060373,
  },
  vertex: {
    module: shaderModule1,
    buffers: [
      {
        arrayStride: 768,
        stepMode: 'instance',
        attributes: [{format: 'uint8x4', offset: 512, shaderLocation: 3}],
      },
      {
        arrayStride: 1724,
        stepMode: 'instance',
        attributes: [{format: 'sint8x2', offset: 134, shaderLocation: 4}],
      },
      {
        arrayStride: 184,
        stepMode: 'instance',
        attributes: [{format: 'sint32x3', offset: 16, shaderLocation: 15}],
      },
      {
        arrayStride: 80,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 8, shaderLocation: 14}],
      },
      {arrayStride: 0, attributes: []},
      {arrayStride: 760, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 548, shaderLocation: 11},
          {format: 'unorm8x4', offset: 564, shaderLocation: 0},
          {format: 'uint32x3', offset: 108, shaderLocation: 12},
          {format: 'float32x2', offset: 604, shaderLocation: 9},
          {format: 'float16x4', offset: 968, shaderLocation: 10},
          {format: 'snorm16x2', offset: 296, shaderLocation: 8},
          {format: 'unorm8x4', offset: 248, shaderLocation: 5},
          {format: 'sint32x2', offset: 632, shaderLocation: 6},
          {format: 'snorm16x4', offset: 512, shaderLocation: 1},
          {format: 'sint16x2', offset: 32, shaderLocation: 2},
          {format: 'sint16x2', offset: 64, shaderLocation: 7},
          {format: 'sint32', offset: 196, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw'},
});
let bindGroupLayout67 = device4.createBindGroupLayout({label: '\u5a02\u09a2\u2e52\u01ba\ua93a\uc07f', entries: []});
let commandEncoder238 = device4.createCommandEncoder({label: '\uc292\uaae5\u075b\u{1fb5c}'});
let commandBuffer55 = commandEncoder211.finish({label: '\u69e6\u{1f7f7}\u0520\u{1f765}\u0f39\u06d8\u049c\u{1fd50}\u6d4e\ue5d1'});
let textureView278 = texture136.createView({label: '\u0dab\u3cac\u7259\uf5db\ub69d\u4cbe\ud6fc\u0a0d\u{1fb22}\u{1fa77}', baseMipLevel: 7});
try {
device4.queue.writeTexture({
  texture: texture124,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(0), /* required buffer size: 202 */
{offset: 202}, {width: 34, height: 0, depthOrArrayLayers: 0});
} catch {}
offscreenCanvas14.width = 70;
let commandEncoder239 = device4.createCommandEncoder({label: '\u{1f716}\ud85d\u031e\u4915\u0268\u7fc2'});
let commandBuffer56 = commandEncoder239.finish({label: '\u0180\u534d'});
let texture153 = device4.createTexture({
  size: {width: 328, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 9,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm'],
});
let renderBundleEncoder117 = device4.createRenderBundleEncoder({
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  stencilReadOnly: true,
});
let externalTexture116 = device4.importExternalTexture({label: '\u06fe\u042a\u7284\u0aed\u7000', source: video37, colorSpace: 'display-p3'});
try {
renderBundleEncoder93.setVertexBuffer(4, undefined, 433_347_757, 496_930_759);
} catch {}
try {
device4.pushErrorScope('validation');
} catch {}
try {
commandEncoder238.copyTextureToBuffer({
  texture: texture153,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 78 widthInBlocks: 39 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3448 */
  offset: 2602,
  bytesPerRow: 256,
  rowsPerImage: 95,
  buffer: buffer30,
}, {width: 39, height: 4, depthOrArrayLayers: 1});
} catch {}
let commandBuffer57 = commandEncoder199.finish({});
let texture154 = device4.createTexture({
  label: '\u{1f8d0}\u{1fa72}',
  size: [328, 6, 851],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg8unorm'],
});
let externalTexture117 = device4.importExternalTexture({
  label: '\u7f8b\u857b\u06c3\u{1ffab}\u{1f85a}\u{1fd43}\u0fe6\uaa7f\u0513',
  source: videoFrame11,
  colorSpace: 'display-p3',
});
try {
computePassEncoder125.setPipeline(pipeline151);
} catch {}
try {
  await buffer30.mapAsync(GPUMapMode.READ, 58192, 144872);
} catch {}
let bindGroup78 = device0.createBindGroup({
  label: '\u0bd3\u{1fc0e}\u0283\u2b9c\ua43b\u094d\u8027',
  layout: bindGroupLayout9,
  entries: [{binding: 900, resource: externalTexture102}],
});
let commandEncoder240 = device0.createCommandEncoder({label: '\u07be\u{1fce8}\u{1f6c5}\u365b'});
let querySet112 = device0.createQuerySet({label: '\uaef8\u0fd5\u0b15', type: 'occlusion', count: 2949});
let renderPassEncoder16 = commandEncoder192.beginRenderPass({
  label: '\u8ef8\u0917\u05bc\u{1fac5}\u2520\u{1f6bc}\u{1ffbd}\u0cc1',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: 911.6, g: 26.22, b: 460.7, a: 939.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet24,
  maxDrawCount: 1071847595,
});
let externalTexture118 = device0.importExternalTexture({label: '\u{1f8aa}\u{1f7f9}\u6df2\u05d5\u{1fdc4}\u01a3\u04c5\uc1e1', source: video27});
try {
renderPassEncoder8.setBlendConstant({ r: 34.11, g: 970.7, b: -255.9, a: -784.7, });
} catch {}
try {
renderPassEncoder6.setScissorRect(49, 4, 73, 114);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4, buffer4, 0, 38_254);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 596}
*/
{
  source: video6,
  origin: { x: 0, y: 0 },
  flipY: false,
}, {
  texture: texture58,
  mipLevel: 1,
  origin: {x: 13, y: 3, z: 41},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 8, depthOrArrayLayers: 0});
} catch {}
video7.width = 92;
let commandEncoder241 = device3.createCommandEncoder({label: '\u{1f8f2}\u5d7f\uc7ce\u0ef2\u0d91'});
let computePassEncoder127 = commandEncoder223.beginComputePass({});
let renderBundleEncoder118 = device3.createRenderBundleEncoder({
  colorFormats: ['rgba32sint', 'rg32uint', 'rg16sint', 'r32uint'],
  sampleCount: 4,
  stencilReadOnly: true,
});
try {
commandEncoder237.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 27832 */
  offset: 27832,
  buffer: buffer47,
}, {
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder225.resolveQuerySet(querySet93, 265, 234, buffer47, 256);
} catch {}
try {
device3.queue.writeBuffer(buffer49, 6288, new Int16Array(28015), 5484, 2644);
} catch {}
let imageData36 = new ImageData(56, 188);
let querySet113 = device1.createQuerySet({type: 'occlusion', count: 1250});
let texture155 = device1.createTexture({
  label: '\u1f9a\u6a6f\ud9d4\u3b25\ua179\u1909\u{1f93b}\u62f7\u{1fe99}',
  size: [550],
  dimension: '1d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rgb10a2unorm', 'rgb10a2unorm', 'rgb10a2unorm'],
});
try {
computePassEncoder111.end();
} catch {}
try {
renderBundleEncoder34.draw(1, 3);
} catch {}
try {
renderBundleEncoder34.drawIndexed(9_238, 10, 1_510, 226_603_133, 2_064_140_928);
} catch {}
video2.width = 156;
let computePassEncoder128 = commandEncoder151.beginComputePass({});
let renderBundleEncoder119 = device0.createRenderBundleEncoder({label: '\u105b\u0726\u{1ffaf}\u{1f850}\ubb9c\u2755', colorFormats: ['rgba8unorm'], sampleCount: 4});
let sampler104 = device0.createSampler({
  label: '\u{1f95f}\ue1f9\u{1f9ea}\ub3af\u{1f7cb}',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 16.88,
  lodMaxClamp: 37.23,
});
try {
computePassEncoder26.dispatchWorkgroupsIndirect(buffer10, 11944);
} catch {}
try {
renderBundleEncoder40.setVertexBuffer(6, buffer4, 100_188, 14_897);
} catch {}
try {
commandEncoder140.copyBufferToBuffer(buffer4, 123772, buffer20, 3600, 39008);
} catch {}
try {
commandEncoder138.clearBuffer(buffer3, 4168, 46520);
} catch {}
try {
commandEncoder240.resolveQuerySet(querySet40, 98, 419, buffer34, 47360);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 1192}
*/
{
  source: offscreenCanvas29,
  origin: { x: 11, y: 101 },
  flipY: false,
}, {
  texture: texture58,
  mipLevel: 0,
  origin: {x: 9, y: 8, z: 30},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 41, height: 6, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout68 = device2.createBindGroupLayout({
  label: '\u04e2\ucbc3\u878d\ud52c\u1b95\u0158\u{1f60d}',
  entries: [
    {
      binding: 376,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let bindGroup79 = device2.createBindGroup({
  label: '\u096f\u0882\ud929\u{1f726}\uf0a8',
  layout: bindGroupLayout50,
  entries: [{binding: 308, resource: sampler75}],
});
let commandEncoder242 = device2.createCommandEncoder();
let textureView279 = texture87.createView({label: '\ub672\u468b\u05dd\u{1ffea}\ua107', baseMipLevel: 2, mipLevelCount: 2});
try {
computePassEncoder73.dispatchWorkgroups(1, 3, 1);
} catch {}
try {
renderBundleEncoder114.setIndexBuffer(buffer43, 'uint16', 2_132, 308);
} catch {}
let promise70 = buffer27.mapAsync(GPUMapMode.WRITE, 0, 90060);
try {
commandEncoder216.copyTextureToTexture({
  texture: texture113,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 9},
  aspect: 'all',
},
{
  texture: texture130,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
},
{width: 28, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder117.pushDebugGroup('\u0d77');
} catch {}
let pipeline184 = await device2.createComputePipelineAsync({
  label: '\u6eda\u43c0\u0b28\u5218',
  layout: pipelineLayout9,
  compute: {module: shaderModule27, entryPoint: 'compute0', constants: {}},
});
let buffer50 = device5.createBuffer({
  label: '\u1a39\u{1ffa3}\u6767\u{1f8ba}\u0810\u36f3\uf23d',
  size: 64102,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let querySet114 = device5.createQuerySet({label: '\u067e\ua4b3', type: 'occlusion', count: 3951});
let texture156 = device1.createTexture({
  size: [302, 96, 1],
  mipLevelCount: 8,
  dimension: '2d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32sint'],
});
let renderBundleEncoder120 = device1.createRenderBundleEncoder({
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  stencilReadOnly: true,
});
let sampler105 = device1.createSampler({
  label: '\ud04f\u{1fce2}\u086b\u834f\u9cc2',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  lodMinClamp: 5.497,
  lodMaxClamp: 9.790,
});
let externalTexture119 = device1.importExternalTexture({label: '\u52a3\u2e00\u666d\u86dc', source: videoFrame26});
try {
renderBundleEncoder102.setBindGroup(3, bindGroup61);
} catch {}
try {
renderBundleEncoder99.setBindGroup(3, bindGroup61, new Uint32Array(4638), 2870, 0);
} catch {}
try {
renderBundleEncoder34.draw(3);
} catch {}
try {
commandEncoder189.clearBuffer(buffer36, 7952, 35848);
} catch {}
let pipeline185 = await device1.createComputePipelineAsync({
  label: '\ue6b8\u{1fd69}\ud47e\ue7ef\uc65b\ud7ab\u8b10\u{1f848}\u1b8b\u3311',
  layout: pipelineLayout5,
  compute: {module: shaderModule14, entryPoint: 'compute0', constants: {}},
});
let commandEncoder243 = device4.createCommandEncoder();
let querySet115 = device4.createQuerySet({label: '\u{1fc8a}\u89a0\u{1ff4d}\ue85f\u{1fa9a}', type: 'occlusion', count: 3732});
let textureView280 = texture153.createView({label: '\uedb3\u6f43\u10b6\u21ab\u671d\u8d37\u0d96\ucb95\u022c\u056e\u022b', baseMipLevel: 8});
let pipeline186 = device4.createComputePipeline({
  label: '\u{1ffee}\ua2ec\u0aa0\u{1fa18}\ue432\u4151\u07aa\u0c5c\ue9a2\u2456\u25bc',
  layout: pipelineLayout17,
  compute: {module: shaderModule36, entryPoint: 'compute0', constants: {}},
});
gc();
let commandEncoder244 = device0.createCommandEncoder({label: '\u{1ff1c}\ud1d3\u69a1\u{1f925}\u016a\ufe69\u{1fe19}\u0746'});
let querySet116 = device0.createQuerySet({label: '\u817c\u6c23\u2bb5\u010b\u10cc\u0f16\u7bc6', type: 'occlusion', count: 1843});
let texture157 = device0.createTexture({
  size: {width: 660, height: 480, depthOrArrayLayers: 130},
  mipLevelCount: 7,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg16uint'],
});
let renderBundle142 = renderBundleEncoder75.finish({label: '\u34be\u{1fd70}\u4db5'});
let externalTexture120 = device0.importExternalTexture({
  label: '\u{1f861}\u{1fc31}\u08e6\u0a3b\u9b81\ud5bd\u781f\u4ef0\u{1f68d}',
  source: videoFrame9,
  colorSpace: 'display-p3',
});
try {
renderPassEncoder13.beginOcclusionQuery(440);
} catch {}
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
renderPassEncoder15.setBlendConstant({ r: 243.0, g: 244.9, b: -478.9, a: -471.1, });
} catch {}
try {
renderBundleEncoder29.draw(18, 119, 27, 161_509_044);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer11, 229_716);
} catch {}
try {
commandEncoder185.copyBufferToTexture({
  /* bytesInLastRow: 136 widthInBlocks: 34 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 4356 */
  offset: 4356,
  buffer: buffer8,
}, {
  texture: texture139,
  mipLevel: 0,
  origin: {x: 729, y: 0, z: 0},
  aspect: 'all',
}, {width: 34, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder103.clearBuffer(buffer14, 3536, 29392);
} catch {}
try {
commandEncoder138.resolveQuerySet(querySet51, 19, 78, buffer11, 6656);
} catch {}
let pipeline187 = await device0.createComputePipelineAsync({
  label: '\ueae2\u2826\u6f9f\u2217',
  layout: pipelineLayout0,
  compute: {module: shaderModule18, entryPoint: 'compute0', constants: {}},
});
let img26 = await imageWithData(224, 205, '#cd02a6bb', '#93cd23b1');
let bindGroupLayout69 = device1.createBindGroupLayout({
  label: '\u{1f970}\u3a35\u9f8d\u0266\u08c3',
  entries: [
    {
      binding: 377,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 1,
      visibility: 0,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let bindGroup80 = device1.createBindGroup({label: '\u0c32\uef54\u32f7\u02e2', layout: bindGroupLayout46, entries: []});
let commandEncoder245 = device1.createCommandEncoder();
let texture158 = device1.createTexture({
  label: '\u{1fb4d}\ub548\u{1feed}\u957b\u0708\u0af9\u0cb0\u3364',
  size: [75, 24, 190],
  mipLevelCount: 5,
  format: 'rgba32sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle143 = renderBundleEncoder33.finish({label: '\u0a4f\u2661\u41fc\u0a4b\ued47\u{1f6ab}\u06d1\u00eb\u0840\u132d'});
try {
computePassEncoder68.end();
} catch {}
try {
renderBundleEncoder34.drawIndexed(7_541, 247, 2_085, 14_047_669, 555_718_208);
} catch {}
try {
renderBundleEncoder103.setIndexBuffer(buffer15, 'uint32', 4_760, 9_965);
} catch {}
try {
commandEncoder194.copyBufferToBuffer(buffer13, 70220, buffer28, 24012, 18284);
} catch {}
try {
commandEncoder117.copyTextureToTexture({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture50,
  mipLevel: 2,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{width: 7, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer36, 2764, new Float32Array(33687), 8349, 2296);
} catch {}
let pipeline188 = await device1.createComputePipelineAsync({
  label: '\u00ff\u6e63\ucf36\u4fdd\u{1fac9}\u5dc9\u2842',
  layout: pipelineLayout19,
  compute: {module: shaderModule31, entryPoint: 'compute0', constants: {}},
});
let imageData37 = new ImageData(48, 100);
let texture159 = device2.createTexture({
  label: '\u370f\u{1fe48}\u3db4\u{1f92a}',
  size: {width: 180, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm-srgb'],
});
let textureView281 = texture79.createView({dimension: '2d', baseArrayLayer: 26});
try {
computePassEncoder73.dispatchWorkgroupsIndirect(buffer23, 131856);
} catch {}
try {
computePassEncoder98.setPipeline(pipeline113);
} catch {}
try {
renderBundleEncoder91.setIndexBuffer(buffer43, 'uint32', 452, 742);
} catch {}
let arrayBuffer15 = buffer22.getMappedRange(200072, 1648);
try {
commandEncoder183.copyBufferToBuffer(buffer22, 331388, buffer43, 2092, 4440);
} catch {}
try {
commandEncoder147.copyBufferToTexture({
  /* bytesInLastRow: 156 widthInBlocks: 39 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 218480 */
  offset: 9584,
  bytesPerRow: 256,
  rowsPerImage: 102,
  buffer: buffer23,
}, {
  texture: texture117,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 2},
  aspect: 'all',
}, {width: 39, height: 0, depthOrArrayLayers: 9});
} catch {}
try {
commandEncoder159.resolveQuerySet(querySet74, 1033, 325, buffer23, 40192);
} catch {}
let commandEncoder246 = device3.createCommandEncoder({label: '\u{1fa9c}\u{1f98c}\u8245\u7cd9\u{1fa75}\u2440\u07b0'});
let renderBundle144 = renderBundleEncoder113.finish({label: '\u0a7c\u632b'});
let sampler106 = device3.createSampler({
  label: '\u{1fbbd}\u1d51\ub3e3\u55cc\u6db8\u{1f825}\u0b63\u{1f92d}',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 56.64,
  lodMaxClamp: 85.50,
  compare: 'never',
  maxAnisotropy: 3,
});
try {
renderBundleEncoder98.setVertexBuffer(2, buffer47, 57_484, 38_352);
} catch {}
try {
commandEncoder225.copyBufferToBuffer(buffer47, 54524, buffer38, 67428, 892);
} catch {}
let commandEncoder247 = device4.createCommandEncoder({label: '\u027d\u8a20\u0f95\ud313'});
let textureView282 = texture136.createView({
  label: '\u0594\u{1fb59}\u6178\u{1fe3e}\u02dc\uc400\u8fe8\uf14b\u0f0f',
  baseMipLevel: 1,
  mipLevelCount: 1,
});
try {
commandEncoder227.copyBufferToBuffer(buffer48, 37212, buffer30, 3232, 16384);
} catch {}
let offscreenCanvas31 = new OffscreenCanvas(888, 476);
let video38 = await videoWithData();
let bindGroupLayout70 = device5.createBindGroupLayout({
  label: '\u727f\u55ff\u8c6f\u{1fa76}\u9c65',
  entries: [
    {
      binding: 932,
      visibility: 0,
      texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let pipelineLayout21 = device5.createPipelineLayout({bindGroupLayouts: [bindGroupLayout70, bindGroupLayout70, bindGroupLayout70, bindGroupLayout70]});
let querySet117 = device5.createQuerySet({label: '\u619f\u0c89\u8db2\uce2c\u1123\u01c3\u0cb9\u{1fe97}', type: 'occlusion', count: 2266});
let texture160 = device5.createTexture({
  label: '\uece6\u8a27\u00ef\ubd71',
  size: [160],
  dimension: '1d',
  format: 'rgba8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8uint', 'rgba8uint'],
});
let textureView283 = texture160.createView({});
try {
gpuCanvasContext10.configure({
  device: device5,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let buffer51 = device4.createBuffer({
  label: '\u1598\u8b9f\ubef4',
  size: 126580,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT,
  mappedAtCreation: true,
});
let textureView284 = texture125.createView({dimension: '2d-array', format: 'rgba8unorm-srgb'});
let computePassEncoder129 = commandEncoder227.beginComputePass({label: '\u5a41\ubd3c\u{1f779}\uc15a\u8677\uf1fd\u{1fa2a}\u532b\u3faf'});
let renderBundle145 = renderBundleEncoder92.finish({});
let commandEncoder248 = device2.createCommandEncoder({});
let textureView285 = texture94.createView({label: '\uce79\u02da\ue463', dimension: '2d-array', aspect: 'all'});
try {
commandEncoder216.copyBufferToBuffer(buffer23, 345876, buffer43, 4024, 2188);
} catch {}
try {
commandEncoder208.clearBuffer(buffer43);
} catch {}
try {
renderBundleEncoder91.insertDebugMarker('\u28e9');
} catch {}
try {
device2.queue.writeBuffer(buffer33, 3676, new DataView(new ArrayBuffer(14035)), 3938, 780);
} catch {}
let bindGroupLayout71 = device1.createBindGroupLayout({
  label: '\u{1f745}\u{1f9c0}\u5fbf\u3d2d\u07a4\u0be1\u00ab\u{1fb2b}\u6513',
  entries: [
    {
      binding: 873,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let bindGroup81 = device1.createBindGroup({label: '\uea74\uabb4\u{1f776}\u6fd2\u33b1\u0c1d', layout: bindGroupLayout20, entries: []});
let querySet118 = device1.createQuerySet({label: '\u2924\uc6c6', type: 'occlusion', count: 3602});
let commandBuffer58 = commandEncoder215.finish({label: '\u050a\u1829\u021d\uac6c\u5f52\u190d\u4973'});
let textureView286 = texture37.createView({label: '\u{1f9e7}\u6798\u{1f63c}\u22ba\uaaa0\u7cce\uc74c\u57e8\u08df\u0f65'});
try {
computePassEncoder81.setBindGroup(0, bindGroup26, new Uint32Array(361), 243, 0);
} catch {}
try {
renderBundleEncoder34.draw(2);
} catch {}
try {
renderBundleEncoder110.setVertexBuffer(2, buffer13, 0, 75_077);
} catch {}
try {
buffer31.destroy();
} catch {}
try {
commandEncoder116.copyTextureToBuffer({
  texture: texture48,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 30 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 31220 */
  offset: 31220,
  buffer: buffer28,
}, {width: 15, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.submit([commandBuffer43, commandBuffer47]);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture137,
  mipLevel: 3,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 2_264 */
{offset: 343, bytesPerRow: 160}, {width: 1, height: 13, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas27,
  origin: { x: 95, y: 221 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let video39 = await videoWithData();
try {
device5.queue.label = '\uae07\u{1fbc2}';
} catch {}
let pipelineLayout22 = device5.createPipelineLayout({label: '\u3953\u01b1\u{1fdb6}', bindGroupLayouts: [bindGroupLayout70, bindGroupLayout70]});
let textureView287 = texture160.createView({label: '\udf8a\ua066\u{1f92a}\ucfe7\u{1fc42}'});
let renderBundleEncoder121 = device5.createRenderBundleEncoder({colorFormats: ['rg16uint', 'rgba32float', 'r32sint', 'r8unorm', 'rg8uint'], depthReadOnly: true});
let renderBundle146 = renderBundleEncoder121.finish({label: '\u01ee\u0f99\u{1fee3}\ucd4f\u{1fabf}\ua16b\ucb08\u{1f7d5}\uddc8'});
let externalTexture121 = device5.importExternalTexture({source: videoFrame18});
let video40 = await videoWithData();
let shaderModule42 = device2.createShaderModule({
  label: '\u{1f67f}\u1149\u{1fd04}\ub7c0\u0d58\u272c\u{1fb09}\u{1fa39}',
  code: `@group(1) @binding(385)
var<storage, read_write> field10: array<u32>;
@group(1) @binding(473)
var<storage, read_write> global12: array<u32>;
@group(1) @binding(552)
var<storage, read_write> parameter16: array<u32>;
@group(0) @binding(786)
var<storage, read_write> function16: array<u32>;

@compute @workgroup_size(3, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(3) f0: vec4<f32>,
  @location(6) f1: vec4<i32>,
  @location(2) f2: vec4<f32>,
  @location(5) f3: vec4<f32>,
  @location(4) f4: vec4<i32>,
  @location(0) f5: vec4<f32>,
  @builtin(sample_mask) f6: u32,
  @location(1) f7: vec4<f32>
}

@fragment
fn fragment0(@builtin(sample_mask) a0: u32, @builtin(front_facing) a1: bool, @builtin(sample_index) a2: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S34 {
  @location(11) f0: vec4<f16>,
  @location(4) f1: vec3<i32>,
  @location(3) f2: vec4<i32>,
  @location(7) f3: vec3<u32>,
  @location(1) f4: vec4<f16>,
  @location(9) f5: vec4<f32>,
  @builtin(vertex_index) f6: u32,
  @location(6) f7: f32,
  @location(15) f8: vec3<f32>,
  @location(10) f9: vec3<f16>,
  @builtin(instance_index) f10: u32,
  @location(0) f11: f32,
  @location(5) f12: vec3<f16>,
  @location(2) f13: vec4<f32>,
  @location(14) f14: vec3<f16>,
  @location(8) f15: vec3<u32>,
  @location(12) f16: vec3<i32>,
  @location(13) f17: f32
}

@vertex
fn vertex0(a0: S34) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let buffer52 = device2.createBuffer({size: 91534, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandBuffer59 = commandEncoder236.finish({});
let sampler107 = device2.createSampler({
  label: '\u60ad\u6e4d',
  addressModeU: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 2.253,
  lodMaxClamp: 85.79,
  maxAnisotropy: 1,
});
try {
computePassEncoder73.setPipeline(pipeline172);
} catch {}
try {
renderBundleEncoder114.setIndexBuffer(buffer43, 'uint16', 1_952, 1_196);
} catch {}
try {
device2.queue.writeBuffer(buffer43, 964, new BigUint64Array(60282), 45883, 44);
} catch {}
let pipeline189 = await device2.createRenderPipelineAsync({
  label: '\u7abe\ub42e',
  layout: pipelineLayout13,
  vertex: {
    module: shaderModule40,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 60, attributes: []},
      {arrayStride: 184, stepMode: 'instance', attributes: []},
      {
        arrayStride: 960,
        stepMode: 'instance',
        attributes: [{format: 'float32x2', offset: 404, shaderLocation: 12}],
      },
      {arrayStride: 448, attributes: []},
      {arrayStride: 128, attributes: [{format: 'sint32x2', offset: 0, shaderLocation: 0}]},
      {arrayStride: 20, stepMode: 'instance', attributes: []},
      {
        arrayStride: 36,
        attributes: [{format: 'sint32', offset: 4, shaderLocation: 2}, {format: 'snorm8x2', offset: 10, shaderLocation: 9}],
      },
      {
        arrayStride: 928,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 68, shaderLocation: 15},
          {format: 'sint32x4', offset: 0, shaderLocation: 3},
          {format: 'float32x4', offset: 108, shaderLocation: 5},
          {format: 'unorm16x2', offset: 208, shaderLocation: 11},
          {format: 'uint32x2', offset: 128, shaderLocation: 10},
          {format: 'uint8x2', offset: 24, shaderLocation: 14},
          {format: 'sint8x2', offset: 642, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 100, shaderLocation: 13},
        ],
      },
    ],
  },
});
try {
  await promise69;
} catch {}
document.body.prepend(img18);
let imageData38 = new ImageData(32, 144);
let bindGroupLayout72 = device4.createBindGroupLayout({label: '\uef5b\u{1fb5d}\u{1ff13}\u0ec1\u{1fd25}\u{1fcfb}\u0a7d', entries: []});
let querySet119 = device4.createQuerySet({label: '\u5ea3\u00f9\u9868\ub389', type: 'occlusion', count: 3860});
let textureView288 = texture136.createView({
  label: '\u79d5\u9270\u{1f68e}\u0865\u5078\ue6c9\u08e8\u8894\u1c16\udf0c\u013b',
  aspect: 'all',
  mipLevelCount: 1,
});
let renderBundleEncoder122 = device4.createRenderBundleEncoder({
  label: '\u{1f8fe}\u3739\uf277',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  stencilReadOnly: true,
});
let sampler108 = device4.createSampler({
  label: '\u{1ffa1}\u084a\uf140\ud8f1\ufb20',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 49.77,
  lodMaxClamp: 67.49,
});
try {
commandEncoder238.resolveQuerySet(querySet95, 23, 62, buffer48, 59392);
} catch {}
let pipeline190 = device4.createRenderPipeline({
  label: '\u4401\ufedb\u{1f9ca}\ubce3\u23a3\u027c\u0db5\u1fd2\udd04\uc88b',
  layout: pipelineLayout17,
  fragment: {
  module: shaderModule34,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.GREEN}, {format: 'rgba8sint', writeMask: 0}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}, {format: 'rg8sint'}, {
  format: 'rg8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'stencil8',
    depthCompare: 'always',
    stencilFront: {compare: 'equal', failOp: 'replace', depthFailOp: 'increment-clamp', passOp: 'increment-wrap'},
    stencilBack: {compare: 'greater', failOp: 'decrement-wrap', depthFailOp: 'decrement-wrap', passOp: 'increment-wrap'},
    stencilReadMask: 1893480873,
    stencilWriteMask: 2129739951,
    depthBias: 705229091,
  },
  vertex: {
    module: shaderModule34,
    constants: {},
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'float32x3', offset: 216, shaderLocation: 9},
          {format: 'snorm16x2', offset: 64, shaderLocation: 14},
          {format: 'float32x4', offset: 588, shaderLocation: 6},
          {format: 'sint32', offset: 384, shaderLocation: 5},
          {format: 'snorm16x2', offset: 160, shaderLocation: 13},
          {format: 'unorm8x2', offset: 380, shaderLocation: 12},
        ],
      },
      {arrayStride: 196, attributes: []},
      {arrayStride: 224, attributes: [{format: 'snorm8x4', offset: 20, shaderLocation: 8}]},
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 224, shaderLocation: 15}],
      },
      {
        arrayStride: 840,
        attributes: [
          {format: 'float16x4', offset: 56, shaderLocation: 3},
          {format: 'float16x4', offset: 216, shaderLocation: 10},
        ],
      },
      {arrayStride: 76, attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 400, shaderLocation: 7},
          {format: 'sint32x4', offset: 348, shaderLocation: 2},
          {format: 'uint16x4', offset: 68, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let imageBitmap27 = await createImageBitmap(offscreenCanvas24);
let textureView289 = texture22.createView({
  label: '\u0875\ud97d',
  aspect: 'all',
  baseMipLevel: 8,
  mipLevelCount: 1,
  baseArrayLayer: 1,
  arrayLayerCount: 121,
});
let renderBundle147 = renderBundleEncoder46.finish({});
try {
computePassEncoder28.setBindGroup(3, bindGroup11);
} catch {}
try {
computePassEncoder22.setPipeline(pipeline39);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(1728);
} catch {}
try {
renderPassEncoder14.executeBundles([]);
} catch {}
try {
renderPassEncoder14.setBlendConstant({ r: 565.2, g: 284.5, b: 282.3, a: -94.01, });
} catch {}
try {
renderPassEncoder14.setStencilReference(3573);
} catch {}
try {
renderPassEncoder6.setViewport(101.8, 68.08, 25.84, 12.89, 0.6561, 0.7716);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer0, 'uint32', 78_340, 67_886);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer44, 1_044);
} catch {}
try {
renderBundleEncoder119.setIndexBuffer(buffer3, 'uint32', 5_712, 1_252);
} catch {}
try {
renderBundleEncoder50.setPipeline(pipeline135);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(2, buffer9, 0, 23_898);
} catch {}
try {
  await buffer40.mapAsync(GPUMapMode.READ, 244640, 209508);
} catch {}
try {
computePassEncoder96.insertDebugMarker('\u7719');
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 660, height: 480, depthOrArrayLayers: 124}
*/
{
  source: imageBitmap20,
  origin: { x: 57, y: 25 },
  flipY: true,
}, {
  texture: texture115,
  mipLevel: 1,
  origin: {x: 202, y: 11, z: 56},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 14, depthOrArrayLayers: 0});
} catch {}
let commandEncoder249 = device4.createCommandEncoder({label: '\u{1f9a6}\u64c8\u1709\u0c63'});
let textureView290 = texture124.createView({aspect: 'all'});
try {
renderBundleEncoder93.setIndexBuffer(buffer48, 'uint16', 40_490, 10_047);
} catch {}
try {
commandEncoder249.copyBufferToTexture({
  /* bytesInLastRow: 396 widthInBlocks: 99 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 7368 */
  offset: 6972,
  buffer: buffer48,
}, {
  texture: texture124,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 99, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder247.copyTextureToTexture({
  texture: texture153,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture136,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 60},
  aspect: 'all',
},
{width: 131, height: 3, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder243.clearBuffer(buffer51, 113740);
} catch {}
try {
commandEncoder247.resolveQuerySet(querySet95, 81, 12, buffer48, 62976);
} catch {}
try {
device4.queue.submit([commandBuffer56]);
} catch {}
try {
  await promise70;
} catch {}
let textureView291 = texture141.createView({label: '\u{1f86f}\uef19\u8c74'});
try {
renderBundleEncoder116.setBindGroup(0, bindGroup76);
} catch {}
try {
renderBundleEncoder98.setIndexBuffer(buffer47, 'uint16', 20_814, 14_070);
} catch {}
try {
commandEncoder221.copyBufferToBuffer(buffer47, 182916, buffer38, 66584, 11352);
} catch {}
try {
commandEncoder233.copyTextureToTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture131,
  mipLevel: 4,
  origin: {x: 10, y: 0, z: 2},
  aspect: 'all',
},
{width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder232.clearBuffer(buffer38, 64200, 7352);
} catch {}
try {
computePassEncoder107.insertDebugMarker('\uc4aa');
} catch {}
try {
device3.queue.writeBuffer(buffer47, 66564, new BigUint64Array(58796), 1367, 2840);
} catch {}
let imageData39 = new ImageData(4, 216);
try {
offscreenCanvas31.getContext('bitmaprenderer');
} catch {}
let querySet120 = device3.createQuerySet({label: '\ua8be\u6fec\u3aa7\u8276\u5081\u{1fc0a}', type: 'occlusion', count: 2034});
let computePassEncoder130 = commandEncoder233.beginComputePass({label: '\ue3e9\u{1ffeb}'});
let renderBundleEncoder123 = device3.createRenderBundleEncoder({
  label: '\u9e93\u74a8',
  colorFormats: ['rgba32sint', 'rg32uint', 'rg16sint', 'r32uint'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder116.setBindGroup(0, bindGroup62, new Uint32Array(9311), 3454, 0);
} catch {}
try {
commandEncoder214.copyBufferToBuffer(buffer47, 112468, buffer49, 16008, 10172);
} catch {}
let offscreenCanvas32 = new OffscreenCanvas(480, 910);
try {
offscreenCanvas32.getContext('2d');
} catch {}
let querySet121 = device4.createQuerySet({type: 'occlusion', count: 1606});
let sampler109 = device4.createSampler({
  label: '\u2eaf\u00b7\u{1f8c1}\u3cca\u2278',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 72.33,
  lodMaxClamp: 76.77,
  compare: 'greater',
});
try {
renderBundleEncoder101.setVertexBuffer(4, undefined, 177_741_163);
} catch {}
try {
commandEncoder238.clearBuffer(buffer51);
} catch {}
let pipeline191 = await device4.createComputePipelineAsync({
  label: '\u04a6\u06ad\u0d69\ub648\u06be\u5fc2\udc29',
  layout: 'auto',
  compute: {module: shaderModule41, entryPoint: 'compute0', constants: {}},
});
let commandEncoder250 = device1.createCommandEncoder({});
let querySet122 = device1.createQuerySet({label: '\u0a31\u8a5b\u0bd7', type: 'occlusion', count: 287});
let commandBuffer60 = commandEncoder189.finish({});
let textureView292 = texture116.createView({label: '\uec4d\u221c\u{1f9a3}\u0705\u{1fb78}', baseMipLevel: 2});
let renderBundleEncoder124 = device1.createRenderBundleEncoder({
  label: '\ue877\u0b4b\ufb70\u0906\u9902\u9352',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
});
let renderBundle148 = renderBundleEncoder102.finish();
try {
renderBundleEncoder34.drawIndexed(3_555, 44, 464, 410_559_875, 32_764_709);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer19, 1_412);
} catch {}
try {
renderBundleEncoder124.setPipeline(pipeline80);
} catch {}
try {
  await promise67;
} catch {}
let pipelineLayout23 = device0.createPipelineLayout({
  label: '\u0e8b\u061b',
  bindGroupLayouts: [bindGroupLayout5, bindGroupLayout8, bindGroupLayout10, bindGroupLayout32],
});
let buffer53 = device0.createBuffer({
  label: '\u01b3\u94a0\uaa7d\u{1fd52}\u0885\u9cf0\ubd96\ua36e',
  size: 12610,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let commandEncoder251 = device0.createCommandEncoder({label: '\u0447\u0874\u{1f954}\ueaae\uc4d9'});
let textureView293 = texture33.createView({label: '\u{1ffb2}\u292d\ud8bc\u0fee\u{1f820}\u011f\ua49a\uec8e', baseMipLevel: 1});
let renderBundleEncoder125 = device0.createRenderBundleEncoder({
  label: '\u0fce\u0adb\u{1fd05}\u543c',
  colorFormats: ['rg16float', 'rgba16float'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
let renderBundle149 = renderBundleEncoder44.finish();
try {
renderBundleEncoder50.draw(276, 172, 2_580_525_450, 488_396_769);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer11, 82_376);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer53, 1_920);
} catch {}
try {
commandEncoder134.copyBufferToBuffer(buffer1, 233072, buffer20, 33452, 30640);
} catch {}
try {
commandEncoder231.copyTextureToBuffer({
  texture: texture72,
  mipLevel: 0,
  origin: {x: 54, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 3224 widthInBlocks: 806 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 34436 */
  offset: 31212,
  bytesPerRow: 3328,
  buffer: buffer1,
}, {width: 806, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder251.copyTextureToTexture({
  texture: texture66,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture77,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 15},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture16,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(720), /* required buffer size: 720 */
{offset: 720}, {width: 86, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(canvas3);
let querySet123 = device3.createQuerySet({label: '\u0d22\u0094\udd68\u{1f994}\u6f95', type: 'occlusion', count: 252});
let textureView294 = texture122.createView({label: '\udbad\ubf54\u66a1\uf9e8\u{1f99d}', mipLevelCount: 1});
let renderBundleEncoder126 = device3.createRenderBundleEncoder({
  label: '\u6f90\u2668\u066d\ue554\u029a',
  colorFormats: ['rg8sint', 'rgba8unorm-srgb', 'rgba8uint', undefined, 'rgba8sint', 'rg32uint', 'rg8unorm'],
  stencilReadOnly: true,
});
let renderBundle150 = renderBundleEncoder79.finish({label: '\u09ef\uba71\u0070\u2440\u{1fcc0}\u0342'});
try {
computePassEncoder89.end();
} catch {}
let commandBuffer61 = commandEncoder234.finish({label: '\u1113\u{1f68b}\uf012\u0e26\u{1fcf8}\u{1ff97}\ufc5f\udfbc\u665d\uce60\u0954'});
let renderBundle151 = renderBundleEncoder108.finish({label: '\u1707\u0e70'});
try {
computePassEncoder88.setPipeline(pipeline157);
} catch {}
try {
commandEncoder226.resolveQuerySet(querySet83, 201, 89, buffer23, 134656);
} catch {}
try {
device2.queue.submit([commandBuffer59]);
} catch {}
let videoFrame28 = new VideoFrame(canvas26, {timestamp: 0});
let buffer54 = device4.createBuffer({size: 227700, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView295 = texture127.createView({
  label: '\ubfb1\u0b4f\u{1f885}\u3625\u713e\ud483\u065a',
  dimension: '2d-array',
  aspect: 'all',
  baseMipLevel: 1,
  mipLevelCount: 1,
});
let renderBundleEncoder127 = device4.createRenderBundleEncoder({
  label: '\u80b3\udf07\u{1f65d}\u{1fd80}\u20bb\u{1ffcf}\u7e9f\u{1fe72}\u{1fdc9}\u07c2\u9f72',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: false,
});
try {
computePassEncoder125.setPipeline(pipeline181);
} catch {}
try {
renderBundleEncoder117.setVertexBuffer(4_294_967_295, undefined);
} catch {}
try {
commandEncoder249.copyTextureToTexture({
  texture: texture154,
  mipLevel: 0,
  origin: {x: 24, y: 1, z: 16},
  aspect: 'all',
},
{
  texture: texture136,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 3},
  aspect: 'all',
},
{width: 37, height: 1, depthOrArrayLayers: 21});
} catch {}
try {
commandEncoder247.resolveQuerySet(querySet95, 9, 34, buffer48, 17920);
} catch {}
document.body.prepend(img3);
let pipelineLayout24 = device1.createPipelineLayout({
  label: '\u0f06\u0b2b\ue2af\u1bf7\u{1f8b1}\u68c5',
  bindGroupLayouts: [bindGroupLayout18, bindGroupLayout60, bindGroupLayout16],
});
let textureView296 = texture156.createView({dimension: '2d-array', format: 'r32sint', baseMipLevel: 6, mipLevelCount: 2});
try {
computePassEncoder104.setBindGroup(1, bindGroup55);
} catch {}
try {
renderBundleEncoder99.setBindGroup(3, bindGroup55);
} catch {}
try {
renderBundleEncoder34.draw(1, 2, 0, 2);
} catch {}
try {
renderBundleEncoder34.drawIndexedIndirect(buffer42, 2_188);
} catch {}
try {
renderBundleEncoder68.setVertexBuffer(7, buffer42);
} catch {}
try {
commandEncoder117.copyBufferToBuffer(buffer18, 292532, buffer13, 166224, 6580);
} catch {}
try {
commandEncoder222.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5184 */
  offset: 4140,
  bytesPerRow: 256,
  buffer: buffer12,
}, {width: 5, height: 5, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.submit([commandBuffer58]);
} catch {}
let bindGroup82 = device2.createBindGroup({label: '\u{1fe2e}\u32df', layout: bindGroupLayout50, entries: [{binding: 308, resource: sampler75}]});
let commandEncoder252 = device2.createCommandEncoder({});
try {
renderBundleEncoder114.setVertexBuffer(3, buffer43, 2_812, 11);
} catch {}
try {
buffer43.unmap();
} catch {}
try {
commandEncoder248.copyTextureToBuffer({
  texture: texture94,
  mipLevel: 1,
  origin: {x: 56, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 132 widthInBlocks: 66 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4028 */
  offset: 3896,
  bytesPerRow: 256,
  buffer: buffer33,
}, {width: 66, height: 1, depthOrArrayLayers: 1});
} catch {}
let promise71 = device2.queue.onSubmittedWorkDone();
try {
device2.queue.copyExternalImageToTexture(/*
{width: 360, height: 1, depthOrArrayLayers: 222}
*/
{
  source: imageBitmap17,
  origin: { x: 2, y: 8 },
  flipY: false,
}, {
  texture: texture150,
  mipLevel: 1,
  origin: {x: 81, y: 0, z: 1},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline192 = await promise49;
let offscreenCanvas33 = new OffscreenCanvas(643, 81);
let shaderModule43 = device0.createShaderModule({
  label: '\u{1f72c}\u0ac8\u325f\u{1f7f5}\u02ad\uf847\u0d60\u6c6c\u2f8d',
  code: `@group(1) @binding(733)
var<storage, read_write> function17: array<u32>;
@group(0) @binding(483)
var<storage, read_write> local12: array<u32>;
@group(1) @binding(360)
var<storage, read_write> n19: array<u32>;
@group(0) @binding(733)
var<storage, read_write> local13: array<u32>;
@group(0) @binding(360)
var<storage, read_write> parameter17: array<u32>;

@compute @workgroup_size(2, 3, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(3) f0: vec4<u32>,
  @location(1) f1: vec4<i32>,
  @location(5) f2: vec4<f32>,
  @location(0) f3: vec4<f32>,
  @location(2) f4: vec4<f32>,
  @location(4) f5: vec3<u32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S35 {
  @location(6) f0: vec4<i32>,
  @location(14) f1: u32,
  @location(12) f2: vec4<f32>,
  @location(13) f3: vec3<i32>,
  @location(1) f4: vec4<f16>,
  @location(2) f5: vec3<f16>,
  @location(0) f6: i32,
  @location(11) f7: vec4<f16>
}
struct VertexOutput0 {
  @builtin(position) f227: vec4<f32>
}

@vertex
fn vertex0(@location(3) a0: vec4<f32>, @location(8) a1: i32, @location(4) a2: i32, @location(10) a3: i32, @location(5) a4: vec4<f16>, @location(7) a5: vec3<f16>, a6: S35, @location(15) a7: vec4<u32>, @location(9) a8: vec2<f16>, @builtin(vertex_index) a9: u32, @builtin(instance_index) a10: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout73 = pipeline10.getBindGroupLayout(1);
let commandEncoder253 = device0.createCommandEncoder({label: '\u02bc\u09c4\u4dfe\u{1fa00}\u06a1\u0fb6\u0041\u{1fa3f}'});
let commandBuffer62 = commandEncoder38.finish({});
let texture161 = device0.createTexture({
  size: [330],
  dimension: '1d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8sint', 'rgba8sint', 'rgba8sint'],
});
let computePassEncoder131 = commandEncoder18.beginComputePass({label: '\uee6e\u{1f8d9}\udf91\u0100\u0938\u06ce'});
try {
renderPassEncoder14.executeBundles([]);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(6, undefined);
} catch {}
try {
renderBundleEncoder50.draw(10, 164, 547_365_316, 148_414_399);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 233_960);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer10, 4_388);
} catch {}
try {
renderBundleEncoder50.setIndexBuffer(buffer3, 'uint16', 2_044, 10_775);
} catch {}
try {
commandEncoder210.copyBufferToTexture({
  /* bytesInLastRow: 1332 widthInBlocks: 333 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 8288 */
  offset: 8288,
  bytesPerRow: 1536,
  buffer: buffer3,
}, {
  texture: texture147,
  mipLevel: 0,
  origin: {x: 41, y: 10, z: 7},
  aspect: 'all',
}, {width: 333, height: 232, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture91,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(new ArrayBuffer(64)), /* required buffer size: 298 */
{offset: 298}, {width: 62, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline193 = device0.createComputePipeline({
  label: '\ub77e\u0a64\u{1f9dd}',
  layout: pipelineLayout4,
  compute: {module: shaderModule12, entryPoint: 'compute0', constants: {}},
});
try {
gpuCanvasContext22.unconfigure();
} catch {}
let bindGroup83 = device1.createBindGroup({
  label: '\u4f9c\ua4b3\u{1f814}\uaf7e\u30b7',
  layout: bindGroupLayout40,
  entries: [{binding: 868, resource: {buffer: buffer36, offset: 35840, size: 9560}}],
});
let querySet124 = device1.createQuerySet({label: '\u34f7\u1c65', type: 'occlusion', count: 1522});
let computePassEncoder132 = commandEncoder196.beginComputePass({});
let sampler110 = device1.createSampler({
  label: '\u{1fa5b}\u624b\u020f\u163e\u0150\u7dd4\u3508\u55b3\u09e7\u7dee',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMaxClamp: 91.90,
});
try {
renderBundleEncoder103.setBindGroup(3, bindGroup67, []);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer19, 784);
} catch {}
try {
renderBundleEncoder85.setVertexBuffer(6, buffer13, 36_816, 7_987);
} catch {}
try {
commandEncoder201.copyTextureToBuffer({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 516 widthInBlocks: 129 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 8508 */
  offset: 8508,
  bytesPerRow: 768,
  buffer: buffer13,
}, {width: 129, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder80.copyTextureToTexture({
  texture: texture56,
  mipLevel: 2,
  origin: {x: 28, y: 0, z: 16},
  aspect: 'all',
},
{
  texture: texture96,
  mipLevel: 1,
  origin: {x: 38, y: 0, z: 4},
  aspect: 'all',
},
{width: 12, height: 1, depthOrArrayLayers: 11});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture155,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer9, /* required buffer size: 1_984 */
{offset: 340}, {width: 411, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap13,
  origin: { x: 64, y: 15 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder254 = device5.createCommandEncoder();
let textureView297 = texture160.createView({label: '\u3001\u0345\ue09f\uc841\ud47f\u0cb5\u0c95\ua327\u{1fdf6}\u{1ffc4}', mipLevelCount: 1});
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let pipelineLayout25 = device3.createPipelineLayout({label: '\u3a34\u1d6c\uca5d\u7f42', bindGroupLayouts: [bindGroupLayout64]});
try {
renderBundleEncoder98.setBindGroup(2, bindGroup71);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Int32Array(arrayBuffer14), /* required buffer size: 487 */
{offset: 487}, {width: 87, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup84 = device0.createBindGroup({label: '\u9d84\u09a1', layout: bindGroupLayout2, entries: []});
let textureView298 = texture70.createView({label: '\u0792\uf0d9\u1f9f'});
let sampler111 = device0.createSampler({
  label: '\u04c2\u0618\u1398\u0c6d',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 40.73,
  lodMaxClamp: 74.47,
  maxAnisotropy: 3,
});
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setVertexBuffer(3, buffer35, 0, 1_903);
} catch {}
try {
renderBundleEncoder29.drawIndexed(1_254, 59, 341, 262_694_008, 1_118_475_838);
} catch {}
try {
renderBundleEncoder88.setIndexBuffer(buffer3, 'uint16', 2_134, 9_689);
} catch {}
try {
buffer0.destroy();
} catch {}
try {
commandEncoder178.copyTextureToBuffer({
  texture: texture30,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 1188 widthInBlocks: 297 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 23340 */
  offset: 22152,
  buffer: buffer1,
}, {width: 297, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
computePassEncoder99.popDebugGroup();
} catch {}
try {
gpuCanvasContext13.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm'],
  colorSpace: 'srgb',
});
} catch {}
let commandBuffer63 = commandEncoder183.finish({label: '\ua6e2\u2a2d\u7571\u{1fe73}\u{1fc4c}\u657c'});
let textureView299 = texture93.createView({label: '\ubbb6\u{1f753}\u{1fa0b}', dimension: '2d-array', baseMipLevel: 5, arrayLayerCount: 1});
let computePassEncoder133 = commandEncoder164.beginComputePass({});
try {
commandEncoder147.clearBuffer(buffer33, 80232, 17248);
} catch {}
try {
commandEncoder229.resolveQuerySet(querySet67, 208, 68, buffer23, 51456);
} catch {}
let pipeline194 = device2.createComputePipeline({
  label: '\u4e98\u2052\u909a',
  layout: 'auto',
  compute: {module: shaderModule27, entryPoint: 'compute0'},
});
let pipeline195 = await device2.createRenderPipelineAsync({
  label: '\ubbfd\ue2c2\u0880\u{1fc6e}\u03aa\u{1fa21}\u3e3c\ub2bf',
  layout: 'auto',
  multisample: {},
  fragment: {
  module: shaderModule27,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm'}, {format: 'rgba8unorm'}, {format: 'rgba8unorm-srgb'}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}, {format: 'r8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst-alpha', dstFactor: 'dst-alpha'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'less-equal', failOp: 'increment-clamp', depthFailOp: 'increment-wrap', passOp: 'invert'},
    stencilBack: {compare: 'greater', failOp: 'decrement-clamp', depthFailOp: 'invert', passOp: 'replace'},
    stencilReadMask: 3069128993,
    stencilWriteMask: 1451575737,
    depthBias: -839269233,
    depthBiasSlopeScale: -56.86593698947339,
  },
  vertex: {
    module: shaderModule27,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 376, attributes: [{format: 'uint32x4', offset: 0, shaderLocation: 15}]},
      {arrayStride: 84, attributes: []},
      {arrayStride: 536, stepMode: 'instance', attributes: []},
      {
        arrayStride: 60,
        stepMode: 'instance',
        attributes: [{format: 'float32x3', offset: 20, shaderLocation: 13}],
      },
      {
        arrayStride: 912,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 204, shaderLocation: 14},
          {format: 'uint16x2', offset: 468, shaderLocation: 2},
          {format: 'sint8x2', offset: 44, shaderLocation: 10},
        ],
      },
      {arrayStride: 0, attributes: [{format: 'uint8x4', offset: 12, shaderLocation: 7}]},
      {
        arrayStride: 456,
        stepMode: 'vertex',
        attributes: [
          {format: 'float16x4', offset: 160, shaderLocation: 9},
          {format: 'uint32x3', offset: 96, shaderLocation: 11},
          {format: 'snorm8x2', offset: 98, shaderLocation: 1},
          {format: 'uint32x2', offset: 4, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: false},
});
try {
  await promise71;
} catch {}
let sampler112 = device4.createSampler({
  label: '\u{1f85c}\uafd5\u2057\u2731\u02a4',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 84.64,
  maxAnisotropy: 12,
});
let externalTexture122 = device4.importExternalTexture({source: video3, colorSpace: 'display-p3'});
try {
commandEncoder243.copyTextureToTexture({
  texture: texture153,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture136,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 34},
  aspect: 'all',
},
{width: 55, height: 1, depthOrArrayLayers: 1});
} catch {}
let commandEncoder255 = device2.createCommandEncoder({label: '\u{1f68a}\u0804\ue553\ufd5e\u8737\u{1fe7e}\u09ac\u57ba\u6334\u1043\ucb3a'});
let querySet125 = device2.createQuerySet({type: 'occlusion', count: 1551});
let textureView300 = texture97.createView({label: '\u1d1f\u64a3\ua939\ueee3\u0d60\u{1fbc4}\ud6ed\u0ea2\u0d3b\u31b3\ua05a'});
let renderBundle152 = renderBundleEncoder90.finish();
let sampler113 = device2.createSampler({
  label: '\u{1f9a5}\u45a8\ud288\u{1f730}\ua9b0',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 77.62,
  lodMaxClamp: 80.75,
  compare: 'always',
});
try {
computePassEncoder92.setBindGroup(1, bindGroup51, new Uint32Array(9047), 6454, 0);
} catch {}
try {
renderBundleEncoder74.setPipeline(pipeline133);
} catch {}
try {
renderBundleEncoder91.setVertexBuffer(7, buffer43);
} catch {}
try {
commandEncoder159.copyBufferToBuffer(buffer33, 42588, buffer23, 173724, 114884);
} catch {}
try {
device2.queue.writeBuffer(buffer43, 692, new Int16Array(40302), 16797, 956);
} catch {}
let textureView301 = texture117.createView({label: '\u070d\u{1f97b}\u{1fdc9}\u{1f728}\ue8fb\u0de9\u{1fa5c}\u09a2\ucedd', mipLevelCount: 5});
try {
computePassEncoder98.setPipeline(pipeline179);
} catch {}
try {
renderBundleEncoder91.drawIndirect(buffer33, 74_644);
} catch {}
try {
renderBundleEncoder91.setVertexBuffer(5, buffer43, 0, 1_962);
} catch {}
try {
commandEncoder216.copyBufferToBuffer(buffer33, 141524, buffer43, 2516, 244);
} catch {}
try {
commandEncoder242.copyTextureToBuffer({
  texture: texture132,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 22420 */
  offset: 22420,
  buffer: buffer23,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext31.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device2.queue.writeBuffer(buffer33, 129672, new Float32Array(31534), 24301, 1188);
} catch {}
let pipeline196 = await device2.createComputePipelineAsync({
  label: '\uab83\u9a35\u1968\u0ed7\u{1fac0}\u0e9e\u0972\u{1fe12}\ubda3',
  layout: pipelineLayout16,
  compute: {module: shaderModule40, entryPoint: 'compute0', constants: {}},
});
let device6 = await adapter6.requestDevice({
  label: '\u9666\u{1f676}\u3b4c\u2aa9\u04fc\u3671\u2dd9\u{1f83f}\ub1fa',
  requiredFeatures: [
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxColorAttachmentBytesPerSample: 32,
    maxUniformBufferBindingSize: 128070665,
    maxStorageBufferBindingSize: 267326842,
    maxSamplersPerShaderStage: 16,
  },
});
let commandEncoder256 = device4.createCommandEncoder({label: '\u9c64\u57b0\u320e'});
let externalTexture123 = device4.importExternalTexture({
  label: '\uad98\u8dda\ud43e\u0b03\u0056\u{1f7ee}\u0032\u{1fca1}',
  source: video13,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder122.setPipeline(pipeline170);
} catch {}
try {
renderBundleEncoder122.setVertexBuffer(4_294_967_295, undefined, 288_133_904, 150_190_282);
} catch {}
try {
commandEncoder249.copyTextureToTexture({
  texture: texture153,
  mipLevel: 3,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture127,
  mipLevel: 1,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
},
{width: 18, height: 0, depthOrArrayLayers: 1});
} catch {}
gc();
try {
externalTexture33.label = '\u5697\u{1fc8f}\u0b5a\u0c6d\ufcc2\u070c\ufbad\ube48\ua28c\u0ac7\ud10a';
} catch {}
let shaderModule44 = device0.createShaderModule({
  label: '\u690c\uac75\u899e\u{1f9fa}\ubc22\ub46e\u0c3e\u4413\uefb4',
  code: `@group(1) @binding(834)
var<storage, read_write> n20: array<u32>;
@group(1) @binding(91)
var<storage, read_write> n21: array<u32>;

@compute @workgroup_size(4, 2, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<f32>,
  @location(1) f1: vec4<i32>,
  @builtin(sample_mask) f2: u32,
  @location(2) f3: vec4<f32>,
  @location(5) f4: vec4<f32>,
  @location(4) f5: vec2<u32>,
  @location(3) f6: vec4<u32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(12) a0: vec3<i32>, @location(0) a1: i32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder257 = device0.createCommandEncoder({});
let textureView302 = texture77.createView({label: '\u3f33\u{1fa04}\u036b\u546d\u{1f762}\u154a', aspect: 'all', baseMipLevel: 4, mipLevelCount: 3});
let computePassEncoder134 = commandEncoder90.beginComputePass({label: '\u{1fea0}\u{1fdcb}\u2e97\u0467\u0568\uebfd'});
let renderBundleEncoder128 = device0.createRenderBundleEncoder({colorFormats: ['r32float']});
let renderBundle153 = renderBundleEncoder9.finish();
let externalTexture124 = device0.importExternalTexture({source: videoFrame23, colorSpace: 'display-p3'});
try {
renderPassEncoder16.setIndexBuffer(buffer34, 'uint32', 79_812, 66_139);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(6, buffer6, 0);
} catch {}
try {
renderBundleEncoder40.setBindGroup(1, bindGroup8);
} catch {}
try {
renderBundleEncoder89.setBindGroup(0, bindGroup42, new Uint32Array(3737), 2216, 0);
} catch {}
try {
renderBundleEncoder50.drawIndexed(599, 123, 70, -2_074_648_385, 20_864_312);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer11, 177_292);
} catch {}
try {
renderBundleEncoder88.setPipeline(pipeline53);
} catch {}
try {
commandEncoder110.copyTextureToBuffer({
  texture: texture43,
  mipLevel: 4,
  origin: {x: 1, y: 3, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 136 widthInBlocks: 34 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 313692 */
  offset: 212,
  bytesPerRow: 256,
  rowsPerImage: 135,
  buffer: buffer34,
}, {width: 34, height: 10, depthOrArrayLayers: 10});
} catch {}
try {
commandEncoder210.copyTextureToTexture({
  texture: texture5,
  mipLevel: 1,
  origin: {x: 2, y: 26, z: 6},
  aspect: 'all',
},
{
  texture: texture21,
  mipLevel: 1,
  origin: {x: 14, y: 53, z: 0},
  aspect: 'all',
},
{width: 298, height: 97, depthOrArrayLayers: 1});
} catch {}
let pipeline197 = await device0.createRenderPipelineAsync({
  label: '\u6e67\u{1f885}\u6314\u776a\u{1fc88}',
  layout: pipelineLayout3,
  multisample: {count: 4, mask: 0x5ffacd2},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rg16float', writeMask: 0}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'increment-clamp', passOp: 'zero'},
    stencilBack: {compare: 'greater', failOp: 'decrement-clamp', depthFailOp: 'decrement-wrap', passOp: 'zero'},
    stencilReadMask: 2346847566,
    stencilWriteMask: 2832399361,
    depthBiasSlopeScale: 313.42720195926114,
  },
  vertex: {
    module: shaderModule0,
    buffers: [
      {arrayStride: 312, attributes: []},
      {arrayStride: 176, attributes: []},
      {arrayStride: 52, stepMode: 'instance', attributes: []},
      {arrayStride: 0, attributes: []},
      {arrayStride: 508, stepMode: 'instance', attributes: []},
      {arrayStride: 28, attributes: []},
      {arrayStride: 32, attributes: []},
      {
        arrayStride: 748,
        attributes: [
          {format: 'float32', offset: 48, shaderLocation: 14},
          {format: 'sint32x4', offset: 184, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', cullMode: 'front'},
});
let commandEncoder258 = device5.createCommandEncoder({label: '\u{1feb2}\u0fa8\uffa8\u{1f80e}\u000f'});
let querySet126 = device5.createQuerySet({type: 'occlusion', count: 579});
let texture162 = device5.createTexture({
  label: '\uedc8\u{1ff26}\u60bc\u{1f646}\u5ce9\ub7dd\u0d4e\u{1fc7e}\u{1ffd9}',
  size: {width: 40, height: 120, depthOrArrayLayers: 13},
  mipLevelCount: 5,
  sampleCount: 1,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView303 = texture160.createView({label: '\u{1fb62}\uf499', aspect: 'all', baseMipLevel: 0, arrayLayerCount: 1});
let computePassEncoder135 = commandEncoder254.beginComputePass({label: '\u2330\u{1fbb0}'});
let externalTexture125 = device5.importExternalTexture({label: '\u6f64\u6fb0\u487d', source: video25, colorSpace: 'srgb'});
let adapter7 = await navigator.gpu.requestAdapter({powerPreference: 'high-performance'});
let videoFrame29 = new VideoFrame(canvas18, {timestamp: 0});
try {
adapter3.label = '\ue2f0\ubb81\u9a78\u0e2c\u04a1\ua246\u8df7\u0326\u0ec5';
} catch {}
try {
offscreenCanvas33.getContext('webgl');
} catch {}
let bindGroup85 = device4.createBindGroup({layout: bindGroupLayout72, entries: []});
let texture163 = device4.createTexture({
  label: '\u{1f92d}\u9dcd\u{1f940}',
  size: [164, 3, 1],
  mipLevelCount: 7,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8sint', 'rg8sint', 'rg8sint'],
});
try {
commandEncoder247.copyBufferToBuffer(buffer48, 175964, buffer51, 22480, 524);
} catch {}
try {
commandEncoder256.copyTextureToBuffer({
  texture: texture163,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 6268 */
  offset: 6268,
  buffer: buffer54,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout26 = device4.createPipelineLayout({
  label: '\u374c\ua8f7\u{1f841}\udfcc\ub5e6\u1738\u018b\u4f5b\uff67\ud4d8',
  bindGroupLayouts: [bindGroupLayout61, bindGroupLayout67],
});
let textureView304 = texture129.createView({dimension: '3d', aspect: 'all', baseMipLevel: 1, mipLevelCount: 4, arrayLayerCount: 1});
let sampler114 = device4.createSampler({
  label: '\u{1ff65}\u0ab6',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 83.94,
  lodMaxClamp: 96.89,
  compare: 'always',
});
try {
computePassEncoder125.setBindGroup(1, bindGroup85);
} catch {}
try {
commandEncoder243.copyTextureToBuffer({
  texture: texture154,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 32092 */
  offset: 32092,
  bytesPerRow: 0,
  rowsPerImage: 143,
  buffer: buffer54,
}, {width: 0, height: 1, depthOrArrayLayers: 3});
} catch {}
try {
commandEncoder243.resolveQuerySet(querySet91, 259, 241, buffer48, 105984);
} catch {}
try {
commandEncoder247.pushDebugGroup('\u0a5a');
} catch {}
try {
device4.queue.writeBuffer(buffer54, 58004, new Float32Array(19331), 5530);
} catch {}
try {
device4.queue.writeTexture({
  texture: texture127,
  mipLevel: 1,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(24), /* required buffer size: 394 */
{offset: 394}, {width: 55, height: 1, depthOrArrayLayers: 0});
} catch {}
let video41 = await videoWithData();
let commandEncoder259 = device3.createCommandEncoder({});
let querySet127 = device3.createQuerySet({label: '\u{1f86a}\u02e2\u0e54\u839d\u2d33\ue897\u5628\u0e55\u{1fa56}', type: 'occlusion', count: 2730});
let texture164 = device3.createTexture({
  label: '\u0c87\ub2bd\u0e0c\u{1fcbc}\u{1f773}\u68f1\ufe3f\ud1d8',
  size: {width: 351, height: 1, depthOrArrayLayers: 329},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg8unorm'],
});
let textureView305 = texture152.createView({label: '\u{1f973}\u02d7', baseMipLevel: 5, mipLevelCount: 2});
let externalTexture126 = device3.importExternalTexture({
  label: '\u01fa\u40f8\ud089\u667a\u0fb9\u{1f825}\u05bd\u{1f690}',
  source: videoFrame13,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder104.setBindGroup(3, bindGroup76);
} catch {}
try {
gpuCanvasContext23.configure({
  device: device3,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let shaderModule45 = device3.createShaderModule({
  label: '\u0068\u00ae\u91cf\u3477',
  code: `@group(0) @binding(852)
var<storage, read_write> function18: array<u32>;

@compute @workgroup_size(8, 2, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<i32>,
  @location(2) f1: vec3<i32>,
  @location(1) f2: vec3<u32>,
  @location(3) f3: vec2<u32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S36 {
  @location(10) f0: vec4<u32>,
  @location(7) f1: vec2<f16>,
  @location(1) f2: vec3<f16>,
  @location(8) f3: f32,
  @location(15) f4: i32,
  @builtin(vertex_index) f5: u32,
  @location(3) f6: vec2<f32>,
  @location(13) f7: vec3<i32>,
  @location(2) f8: vec2<f16>,
  @location(0) f9: vec3<i32>,
  @location(14) f10: vec4<f16>,
  @location(5) f11: vec3<u32>,
  @location(4) f12: vec2<u32>,
  @builtin(instance_index) f13: u32,
  @location(11) f14: vec2<f32>,
  @location(6) f15: f16
}

@vertex
fn vertex0(a0: S36, @location(9) a1: vec3<f16>, @location(12) a2: vec3<f16>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder260 = device3.createCommandEncoder({});
let textureView306 = texture151.createView({});
let computePassEncoder136 = commandEncoder241.beginComputePass({label: '\u6fc5\u0940\u{1f94c}\u91c1\u02c0'});
let sampler115 = device3.createSampler({
  label: '\u0adf\uac1e\u0fce\uc27d\ud362\u044b\u33d9\ue410\ue6c5\u240c',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 63.41,
  lodMaxClamp: 91.10,
  compare: 'less',
  maxAnisotropy: 14,
});
try {
gpuCanvasContext29.unconfigure();
} catch {}
let texture165 = device6.createTexture({
  label: '\u158d\u0da6\u93d4\u6fbe\ubfdc\u07bb\u{1f881}\u0369\u0388',
  size: [80, 20, 1],
  mipLevelCount: 1,
  format: 'eac-r11snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['eac-r11snorm', 'eac-r11snorm', 'eac-r11snorm'],
});
let sampler116 = device6.createSampler({
  label: '\u07ac\u8b06\u1b33\ubaf2\u{1fcf4}\u6a69\ua6c6\ua880\u4c26\u028a',
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 25.80,
  lodMaxClamp: 31.86,
  compare: 'always',
});
let promise72 = device6.queue.onSubmittedWorkDone();
try {
gpuCanvasContext26.unconfigure();
} catch {}
let buffer55 = device2.createBuffer({
  label: '\u7840\u035b\u8099\u0372',
  size: 73759,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
try {
renderBundleEncoder91.setPipeline(pipeline168);
} catch {}
try {
commandEncoder255.copyBufferToBuffer(buffer52, 53992, buffer23, 396852, 18840);
} catch {}
try {
commandEncoder213.clearBuffer(buffer55, 11668, 51160);
} catch {}
try {
device2.queue.submit([commandBuffer53]);
} catch {}
gc();
let buffer56 = device4.createBuffer({
  size: 451188,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let texture166 = device4.createTexture({
  label: '\u{1f630}\u7f29\u4c3f\ub505\u0138',
  size: {width: 164},
  dimension: '1d',
  format: 'rg11b10ufloat',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder129 = device4.createRenderBundleEncoder({
  label: '\u{1f755}\ue7e4\u{1ff9f}\ubb6e\u{1f897}\u0650\u80a7\u09b2\u7417',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: true,
});
try {
computePassEncoder125.setPipeline(pipeline182);
} catch {}
try {
renderBundleEncoder129.setPipeline(pipeline166);
} catch {}
let arrayBuffer16 = buffer56.getMappedRange();
try {
commandEncoder249.copyBufferToTexture({
  /* bytesInLastRow: 54 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 22138 */
  offset: 22138,
  bytesPerRow: 256,
  buffer: buffer48,
}, {
  texture: texture127,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {width: 27, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder247.popDebugGroup();
} catch {}
try {
device4.queue.writeTexture({
  texture: texture166,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer7, /* required buffer size: 580 */
{offset: 580}, {width: 155, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise72;
} catch {}
let bindGroup86 = device2.createBindGroup({
  label: '\u{1f86e}\uf139\u51be\ub48f\u{1fabf}\u{1fe8d}\u00e4',
  layout: bindGroupLayout47,
  entries: [{binding: 953, resource: sampler75}, {binding: 84, resource: sampler102}],
});
let buffer57 = device2.createBuffer({size: 252268, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder261 = device2.createCommandEncoder({label: '\u{1f864}\ucffe\u08e6\u4d3f\u0f5c\u838c'});
let commandBuffer64 = commandEncoder252.finish({label: '\u0cce\u02ab\uf5f6\u{1f605}\u7850\u35a1\u{1f864}\ue9e8\u{1f696}'});
let computePassEncoder137 = commandEncoder208.beginComputePass({});
let externalTexture127 = device2.importExternalTexture({label: '\uca04\u0c1f\uced3\u071e\u{1f9c9}', source: video41, colorSpace: 'display-p3'});
try {
commandEncoder213.copyBufferToBuffer(buffer23, 482936, buffer57, 37476, 54088);
} catch {}
try {
commandEncoder242.copyTextureToTexture({
  texture: texture82,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 19},
  aspect: 'all',
},
{
  texture: texture82,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 7, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
computePassEncoder117.popDebugGroup();
} catch {}
try {
gpuCanvasContext29.configure({
  device: device2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let video42 = await videoWithData();
let commandEncoder262 = device2.createCommandEncoder({label: '\u8ab2\u{1f7ed}\u{1fc68}'});
let texture167 = gpuCanvasContext5.getCurrentTexture();
let textureView307 = texture148.createView({label: '\u35c3\u97df\u6fb0\u{1f878}\u3ac7\u219b\u029a\ud6bb\u2c82', baseMipLevel: 4, mipLevelCount: 4});
let renderBundleEncoder130 = device2.createRenderBundleEncoder({
  label: '\ud654\u0202\u05a8',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
commandEncoder147.copyTextureToTexture({
  texture: texture140,
  mipLevel: 2,
  origin: {x: 10, y: 0, z: 9},
  aspect: 'all',
},
{
  texture: texture140,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 33, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder91.pushDebugGroup('\u{1ffd6}');
} catch {}
try {
device2.queue.writeBuffer(buffer33, 368, new Float32Array(36145), 30176, 100);
} catch {}
let pipeline198 = device2.createComputePipeline({
  label: '\u{1f95d}\u6f42\u0b77\u0c1c',
  layout: 'auto',
  compute: {module: shaderModule25, entryPoint: 'compute0', constants: {}},
});
let commandEncoder263 = device6.createCommandEncoder({label: '\u0f12\u7c47\u57ad\u02ff\u{1f87f}\ueb72\ucaea\uefaf\u{1f912}\ucba5\u{1fb3a}'});
let commandBuffer65 = commandEncoder263.finish({label: '\u4460\u0275\u{1fcb2}'});
let textureView308 = texture165.createView({label: '\u67ec\u06a4\u0cb5\u0ccb\ua2bb'});
let shaderModule46 = device2.createShaderModule({
  label: '\u1e1c\u062a\uddd7\u{1fed6}\u0438',
  code: `@group(0) @binding(786)
var<storage, read_write> field11: array<u32>;
@group(1) @binding(552)
var<storage, read_write> field12: array<u32>;
@group(1) @binding(473)
var<storage, read_write> n22: array<u32>;
@group(1) @binding(385)
var<storage, read_write> local14: array<u32>;

@compute @workgroup_size(2, 3, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S38 {
  @location(4) f0: f32,
  @builtin(position) f1: vec4<f32>,
  @location(1) f2: u32,
  @location(15) f3: vec3<f32>,
  @location(11) f4: vec4<f32>,
  @location(7) f5: vec4<f32>
}
struct FragmentOutput0 {
  @location(2) f0: vec4<f32>,
  @location(6) f1: vec4<i32>,
  @location(1) f2: vec4<f32>,
  @location(5) f3: vec3<f32>,
  @location(4) f4: i32,
  @location(3) f5: f32,
  @location(0) f6: vec4<f32>
}

@fragment
fn fragment0(@builtin(sample_mask) a0: u32, @location(14) a1: u32, @builtin(front_facing) a2: bool, @location(12) a3: vec3<u32>, @location(9) a4: vec4<f32>, @location(13) a5: vec3<i32>, @location(5) a6: vec3<u32>, @location(6) a7: i32, @builtin(sample_index) a8: u32, @location(0) a9: vec2<i32>, a10: S38) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S37 {
  @builtin(vertex_index) f0: u32,
  @location(12) f1: vec2<f32>,
  @location(10) f2: vec3<f32>,
  @location(7) f3: vec3<f16>,
  @location(5) f4: u32,
  @location(4) f5: i32,
  @location(13) f6: vec2<i32>,
  @location(15) f7: vec4<f32>,
  @location(9) f8: vec2<i32>,
  @location(2) f9: vec4<f32>,
  @location(11) f10: vec3<f16>,
  @location(6) f11: vec3<f16>,
  @location(8) f12: f32
}
struct VertexOutput0 {
  @location(1) f228: u32,
  @location(6) f229: i32,
  @location(14) f230: u32,
  @location(4) f231: f32,
  @location(15) f232: vec3<f32>,
  @builtin(position) f233: vec4<f32>,
  @location(13) f234: vec3<i32>,
  @location(5) f235: vec3<u32>,
  @location(12) f236: vec3<u32>,
  @location(7) f237: vec4<f32>,
  @location(11) f238: vec4<f32>,
  @location(9) f239: vec4<f32>,
  @location(0) f240: vec2<i32>
}

@vertex
fn vertex0(a0: S37, @location(14) a1: vec2<i32>, @location(0) a2: i32, @location(3) a3: vec3<i32>, @location(1) a4: vec3<u32>, @builtin(instance_index) a5: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
});
let commandEncoder264 = device2.createCommandEncoder({label: '\u{1fa54}\ud5dd\u0a7a\u0314\u8cce\u0393\uaeaf\u5363\u{1fd9b}\u2475\u520a'});
let renderBundle154 = renderBundleEncoder77.finish({});
try {
commandEncoder255.copyBufferToBuffer(buffer52, 3752, buffer23, 227256, 32624);
} catch {}
try {
device2.queue.submit([commandBuffer64]);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 45, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas2,
  origin: { x: 14, y: 12 },
  flipY: true,
}, {
  texture: texture93,
  mipLevel: 2,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap28 = await createImageBitmap(imageData31);
let imageData40 = new ImageData(48, 144);
let bindGroup87 = device4.createBindGroup({
  layout: bindGroupLayout54,
  entries: [
    {binding: 863, resource: sampler114},
    {binding: 571, resource: {buffer: buffer56, offset: 419840}},
    {binding: 142, resource: externalTexture103},
  ],
});
let buffer58 = device4.createBuffer({size: 156188, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: true});
let textureView309 = texture166.createView({dimension: '1d', aspect: 'all'});
let renderBundle155 = renderBundleEncoder117.finish({label: '\u0222\u{1fe45}'});
try {
renderBundleEncoder122.setBindGroup(0, bindGroup85);
} catch {}
try {
renderBundleEncoder129.setVertexBuffer(5, buffer56);
} catch {}
let pipeline199 = device4.createComputePipeline({
  label: '\u061b\u66e3\u58e7\u090e\ua078\u7895\u8ebd\u{1fc17}\ue27a',
  layout: pipelineLayout26,
  compute: {module: shaderModule35, entryPoint: 'compute0', constants: {}},
});
let offscreenCanvas34 = new OffscreenCanvas(774, 278);
let bindGroup88 = device0.createBindGroup({label: '\u691a\u083a\u0d0d\u029d\ubab7\u094f', layout: bindGroupLayout26, entries: []});
let pipelineLayout27 = device0.createPipelineLayout({bindGroupLayouts: []});
let commandBuffer66 = commandEncoder131.finish();
let textureView310 = texture17.createView({
  label: '\u{1fd18}\u0383\u22d6\u4cac\ucc35\u717d\ud769\u04b1\u040e\u714c',
  baseMipLevel: 2,
  arrayLayerCount: 1,
});
let externalTexture128 = device0.importExternalTexture({label: '\u12a3\u9cd6\u0be0\u00a4', source: videoFrame21, colorSpace: 'display-p3'});
try {
renderBundleEncoder29.drawIndirect(buffer35, 1_924);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer0, 'uint16', 41_586, 24_020);
} catch {}
try {
renderBundleEncoder56.setPipeline(pipeline135);
} catch {}
try {
commandEncoder150.copyTextureToTexture({
  texture: texture67,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture81,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 82, height: 60, depthOrArrayLayers: 124}
*/
{
  source: imageData9,
  origin: { x: 23, y: 32 },
  flipY: false,
}, {
  texture: texture28,
  mipLevel: 1,
  origin: {x: 7, y: 8, z: 11},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 13, height: 1, depthOrArrayLayers: 0});
} catch {}
offscreenCanvas1.width = 1796;
let commandEncoder265 = device2.createCommandEncoder({label: '\ub386\u{1fb1b}\u8264\u7052'});
let renderBundle156 = renderBundleEncoder70.finish({label: '\u0d16\uc908\u6c14\ub0f6\u0a25\u7feb\ub546\u{1ffd4}\u73cf'});
let sampler117 = device2.createSampler({
  label: '\u13d7\u086b\u{1fa2a}\uf237\u0c05\u{1f64c}\u876b\u0c7a\u0d07',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 27.37,
});
let externalTexture129 = device2.importExternalTexture({label: '\u0b28\ud384\u{1f6df}\u4eb8\u0cc0\uc136', source: video2, colorSpace: 'display-p3'});
try {
computePassEncoder73.setBindGroup(2, bindGroup86);
} catch {}
try {
renderBundleEncoder130.setPipeline(pipeline133);
} catch {}
try {
commandEncoder228.copyBufferToTexture({
  /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 16988 */
  offset: 16988,
  buffer: buffer41,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 18, height: 0, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas35 = new OffscreenCanvas(733, 957);
try {
offscreenCanvas35.getContext('bitmaprenderer');
} catch {}
let bindGroup89 = device1.createBindGroup({
  layout: bindGroupLayout27,
  entries: [
    {binding: 180, resource: sampler74},
    {binding: 354, resource: {buffer: buffer18, offset: 78592, size: 22212}},
    {binding: 406, resource: sampler82},
  ],
});
let buffer59 = device1.createBuffer({size: 332615, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let textureView311 = texture121.createView({label: '\u{1f894}\u0261\u275b\u5ae9\u8ff6', dimension: '2d-array', baseMipLevel: 2});
try {
renderBundleEncoder107.setIndexBuffer(buffer28, 'uint16', 2_246, 4_931);
} catch {}
try {
renderBundleEncoder39.setVertexBuffer(0, buffer36);
} catch {}
let pipeline200 = device1.createComputePipeline({
  label: '\u0dbe\u53d1\u{1fa79}\u0137\u90da',
  layout: pipelineLayout7,
  compute: {module: shaderModule15, entryPoint: 'compute0'},
});
let shaderModule47 = device4.createShaderModule({
  label: '\ue659\u0c2a\u{1fe0d}\u0d72\ue071\u2b3b',
  code: `@group(1) @binding(910)
var<storage, read_write> local15: array<u32>;
@group(1) @binding(386)
var<storage, read_write> global13: array<u32>;
@group(0) @binding(910)
var<storage, read_write> parameter18: array<u32>;

@compute @workgroup_size(7, 3, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(3) f0: vec4<f32>,
  @location(2) f1: vec4<f32>,
  @location(1) f2: vec4<i32>,
  @location(0) f3: vec4<u32>,
  @location(5) f4: vec4<f32>,
  @location(4) f5: vec2<i32>,
  @builtin(sample_mask) f6: u32
}

@fragment
fn fragment0(@location(7) a0: vec3<u32>, @location(0) a1: vec2<i32>, @builtin(sample_mask) a2: u32, @builtin(position) a3: vec4<f32>, @builtin(sample_index) a4: u32, @builtin(front_facing) a5: bool) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S39 {
  @location(8) f0: vec3<i32>,
  @location(3) f1: vec2<i32>,
  @location(5) f2: vec3<i32>,
  @location(2) f3: f16,
  @location(6) f4: f32
}
struct VertexOutput0 {
  @builtin(position) f241: vec4<f32>,
  @location(0) f242: vec2<i32>,
  @location(7) f243: vec3<u32>
}

@vertex
fn vertex0(@location(14) a0: vec4<u32>, @location(12) a1: vec3<u32>, @builtin(instance_index) a2: u32, @builtin(vertex_index) a3: u32, a4: S39, @location(11) a5: vec4<u32>, @location(7) a6: vec2<f32>, @location(9) a7: f32, @location(15) a8: f32, @location(0) a9: vec3<f32>, @location(1) a10: vec2<u32>, @location(13) a11: vec4<f32>, @location(4) a12: vec2<u32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let renderBundleEncoder131 = device4.createRenderBundleEncoder({
  label: '\u019f\u30c9\u3d4b\u3bbc\u{1fe35}',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: true,
});
let renderBundle157 = renderBundleEncoder95.finish({});
try {
computePassEncoder125.setBindGroup(1, bindGroup85);
} catch {}
try {
device4.queue.submit([commandBuffer57, commandBuffer51]);
} catch {}
try {
device4.queue.writeTexture({
  texture: texture136,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, arrayBuffer14, /* required buffer size: 52_315 */
{offset: 235, bytesPerRow: 60, rowsPerImage: 217}, {width: 2, height: 0, depthOrArrayLayers: 5});
} catch {}
let imageData41 = new ImageData(56, 200);
let commandEncoder266 = device6.createCommandEncoder({label: '\u{1fcdf}\u49b9\u4c6f\u{1f9b6}\uac98\u{1f945}\u0418\u{1fa36}'});
let renderBundleEncoder132 = device6.createRenderBundleEncoder({
  colorFormats: ['r16sint', 'rgba16sint', 'rgb10a2uint', 'rgb10a2uint'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: false,
});
let sampler118 = device6.createSampler({
  label: '\u01be\ub04e\u3776\u0534\u0351\ue358\u0231\u7051\uc59f',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  lodMinClamp: 93.39,
  lodMaxClamp: 95.59,
  compare: 'less',
});
let externalTexture130 = device6.importExternalTexture({
  label: '\u{1ff93}\u030c\u0fe6\u4627\u3a8b\u061d\u{1fcf0}\u26f3\u{1fa3e}\ue388\u{1fe3a}',
  source: videoFrame0,
  colorSpace: 'srgb',
});
try {
gpuCanvasContext4.configure({
  device: device6,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55) };
} catch {}
let bindGroupLayout74 = device0.createBindGroupLayout({
  label: '\u55d5\u01b7\u{1fdff}\ubbc3\ubde3\u027f\u{1fdc7}',
  entries: [
    {
      binding: 378,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '1d' },
    },
  ],
});
let querySet128 = device0.createQuerySet({label: '\u00ac\ue370\u{1f84c}\u0b25\u{1fc5e}\u9b5c\u050a', type: 'occlusion', count: 3798});
let renderBundleEncoder133 = device0.createRenderBundleEncoder({
  label: '\ubc0c\u{1f6ad}\uab5b\u{1fcb5}\ud8bd',
  colorFormats: ['rgba8unorm'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder90.dispatchWorkgroups(5, 1, 3);
} catch {}
try {
renderPassEncoder6.setBindGroup(3, bindGroup77, new Uint32Array(2693), 1761, 0);
} catch {}
try {
renderBundleEncoder125.setBindGroup(1, bindGroup43);
} catch {}
try {
renderBundleEncoder29.drawIndexed(6_092, 239, 5, 194_786_577, 48_896_806);
} catch {}
try {
buffer20.destroy();
} catch {}
try {
commandEncoder95.copyTextureToBuffer({
  texture: texture43,
  mipLevel: 3,
  origin: {x: 6, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 88 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 400372 */
  offset: 23196,
  bytesPerRow: 256,
  rowsPerImage: 79,
  buffer: buffer34,
}, {width: 22, height: 52, depthOrArrayLayers: 19});
} catch {}
try {
commandEncoder100.clearBuffer(buffer16, 748, 9480);
} catch {}
try {
device0.queue.writeBuffer(buffer6, 6360, new BigUint64Array(30580), 22202, 696);
} catch {}
let pipeline201 = await device0.createComputePipelineAsync({
  label: '\u{1fc45}\uc49c\u5e4f\u5209\u36ef\uc9e8\u0aff',
  layout: pipelineLayout18,
  compute: {module: shaderModule8, entryPoint: 'compute0', constants: {}},
});
try {
offscreenCanvas34.getContext('2d');
} catch {}
let commandEncoder267 = device4.createCommandEncoder({label: '\u{1fb31}\u4833\ubbd2'});
let textureView312 = texture163.createView({
  label: '\u7792\u0e7b\u{1febd}\u0d72\u{1f666}\u0204\u0032\u0b42\u28ec\u3ce9\u{1f872}',
  dimension: '2d-array',
  baseMipLevel: 3,
  mipLevelCount: 3,
});
try {
commandEncoder256.clearBuffer(buffer51);
} catch {}
try {
commandEncoder238.resolveQuerySet(querySet109, 21, 3, buffer56, 103168);
} catch {}
try {
gpuCanvasContext10.unconfigure();
} catch {}
let texture168 = device5.createTexture({
  label: '\u47cb\u3d55\u3118\u074b\u002d\u{1fb68}',
  size: {width: 40, height: 120, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let sampler119 = device5.createSampler({
  label: '\u4237\u{1fb23}\uc69c',
  addressModeU: 'repeat',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 70.66,
  lodMaxClamp: 73.80,
  maxAnisotropy: 1,
});
try {
computePassEncoder135.pushDebugGroup('\u7c59');
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55) };
} catch {}
let querySet129 = device5.createQuerySet({label: '\u0a4d\u940f\u967e\u0d9a\u61fe\u6f24\u5fca\u877b', type: 'occlusion', count: 419});
let texture169 = device5.createTexture({
  size: [2496],
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32sint'],
});
try {
commandEncoder258.copyBufferToTexture({
  /* bytesInLastRow: 7452 widthInBlocks: 1863 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 9244 */
  offset: 1792,
  buffer: buffer50,
}, {
  texture: texture169,
  mipLevel: 0,
  origin: {x: 154, y: 0, z: 0},
  aspect: 'all',
}, {width: 1863, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let bindGroup90 = device0.createBindGroup({
  label: '\u{1f8b0}\ud5d3\u67e2\u939e\u{1ff46}\u5cb5\u1dbf\u495d',
  layout: bindGroupLayout0,
  entries: [{binding: 954, resource: {buffer: buffer24, offset: 169216, size: 66232}}],
});
let commandEncoder268 = device0.createCommandEncoder();
let texture170 = device0.createTexture({
  label: '\u{1fb57}\u1cc7\u{1ffb2}\uf98f\u0ef5\u7906',
  size: [330, 240, 945],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rg16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg16uint'],
});
let textureView313 = texture73.createView({
  label: '\u{1ff41}\u0cf8\uc4c6\u0b8c\ue2b3',
  dimension: '2d',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 43,
});
let renderBundle158 = renderBundleEncoder38.finish();
try {
renderPassEncoder12.beginOcclusionQuery(2156);
} catch {}
try {
renderPassEncoder6.setScissorRect(1, 109, 47, 9);
} catch {}
try {
renderPassEncoder12.setViewport(323.3, 130.9, 128.1, 263.2, 0.3678, 0.4881);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(buffer6, 'uint32', 3_156, 469);
} catch {}
try {
renderBundleEncoder88.setBindGroup(0, bindGroup10);
} catch {}
try {
renderBundleEncoder50.drawIndexed(93, 145, 950, -882_549_627, 196_475_333);
} catch {}
try {
commandEncoder96.copyBufferToTexture({
  /* bytesInLastRow: 3816 widthInBlocks: 954 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 31540 */
  offset: 31540,
  bytesPerRow: 3840,
  buffer: buffer8,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
}, {width: 954, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder230.clearBuffer(buffer3, 2584, 87788);
} catch {}
try {
commandEncoder231.resolveQuerySet(querySet21, 1699, 147, buffer1, 8704);
} catch {}
let shaderModule48 = device1.createShaderModule({
  code: `@group(0) @binding(966)
var<storage, read_write> field13: array<u32>;

@compute @workgroup_size(5, 4, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(1) f0: vec2<u32>,
  @location(0) f1: vec3<u32>,
  @location(3) f2: vec2<i32>,
  @location(2) f3: i32
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32, @builtin(position) a1: vec4<f32>, @builtin(sample_mask) a2: u32, @builtin(front_facing) a3: bool) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @builtin(position) f244: vec4<f32>
}

@vertex
fn vertex0(@location(6) a0: vec3<f16>, @location(15) a1: f16) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
});
let commandEncoder269 = device1.createCommandEncoder();
let textureView314 = texture99.createView({});
try {
computePassEncoder86.setPipeline(pipeline185);
} catch {}
try {
renderBundleEncoder34.drawIndexed(1_319, 223, 1_136, 340_635_342, 1_565_960_509);
} catch {}
try {
renderBundleEncoder68.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder107.setVertexBuffer(4_294_967_295, undefined, 594_116_528, 428_633_208);
} catch {}
try {
commandEncoder88.copyBufferToBuffer(buffer13, 66236, buffer59, 291052, 24092);
} catch {}
try {
commandEncoder194.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 9176 */
  offset: 4272,
  bytesPerRow: 256,
  buffer: buffer31,
}, {
  texture: texture142,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 10, height: 20, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder117.clearBuffer(buffer36, 9084, 18400);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, new BigInt64Array(arrayBuffer7), /* required buffer size: 271 */
{offset: 271}, {width: 97, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline202 = device1.createRenderPipeline({
  label: '\u0d2f\ua2f5\u04d0\u9b30\u04e9\u{1fac7}\u1fc0\ua098\u7d0c',
  layout: pipelineLayout19,
  fragment: {
  module: shaderModule32,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE}, {
  format: 'rgb10a2unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA,
}],
},
  vertex: {
    module: shaderModule32,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 208, attributes: []},
      {arrayStride: 1336, attributes: [{format: 'float32x4', offset: 372, shaderLocation: 15}]},
      {arrayStride: 332, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 280, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 272,
        attributes: [
          {format: 'float16x2', offset: 104, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 268, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 776,
        attributes: [
          {format: 'uint16x2', offset: 132, shaderLocation: 4},
          {format: 'unorm16x2', offset: 248, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 624,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm8x2', offset: 38, shaderLocation: 13},
          {format: 'snorm8x4', offset: 20, shaderLocation: 11},
          {format: 'uint32x2', offset: 120, shaderLocation: 5},
          {format: 'sint16x2', offset: 4, shaderLocation: 8},
          {format: 'uint16x2', offset: 40, shaderLocation: 10},
          {format: 'sint8x4', offset: 112, shaderLocation: 2},
        ],
      },
    ],
  },
});
let querySet130 = device3.createQuerySet({type: 'occlusion', count: 2});
let textureView315 = texture103.createView({
  label: '\udc7f\u00f3\u{1ff42}\u0f55\u2af8\u08da',
  dimension: '2d',
  format: 'astc-10x5-unorm-srgb',
  baseMipLevel: 4,
  baseArrayLayer: 60,
});
try {
renderBundleEncoder104.setVertexBuffer(5, buffer47, 0);
} catch {}
try {
  await buffer38.mapAsync(GPUMapMode.READ, 0, 81164);
} catch {}
try {
commandEncoder237.copyBufferToTexture({
  /* bytesInLastRow: 108 widthInBlocks: 54 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 32278 */
  offset: 32278,
  buffer: buffer47,
}, {
  texture: texture143,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 54, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder246.resolveQuerySet(querySet96, 200, 39, buffer47, 57344);
} catch {}
let pipeline203 = device3.createRenderPipeline({
  label: '\u{1fd13}\u3b35',
  layout: pipelineLayout25,
  fragment: {
  module: shaderModule45,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg32uint', writeMask: 0}, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r32uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilFront: {compare: 'equal', failOp: 'replace', depthFailOp: 'decrement-wrap', passOp: 'replace'},
    stencilBack: {compare: 'less', failOp: 'keep', depthFailOp: 'increment-clamp', passOp: 'zero'},
    stencilReadMask: 1372027277,
    stencilWriteMask: 3030262339,
    depthBiasSlopeScale: 365.4408701978306,
  },
  vertex: {
    module: shaderModule45,
    buffers: [
      {arrayStride: 188, attributes: [{format: 'float32x4', offset: 8, shaderLocation: 3}]},
      {
        arrayStride: 172,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 36, shaderLocation: 13}],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 588, shaderLocation: 7},
          {format: 'snorm16x2', offset: 468, shaderLocation: 6},
          {format: 'sint32', offset: 796, shaderLocation: 0},
          {format: 'sint16x2', offset: 156, shaderLocation: 15},
          {format: 'float16x2', offset: 324, shaderLocation: 14},
          {format: 'unorm8x4', offset: 72, shaderLocation: 11},
          {format: 'uint32x4', offset: 116, shaderLocation: 10},
        ],
      },
      {arrayStride: 40, attributes: [{format: 'unorm8x2', offset: 0, shaderLocation: 2}]},
      {arrayStride: 392, attributes: []},
      {arrayStride: 252, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [{format: 'uint8x2', offset: 0, shaderLocation: 5}],
      },
      {
        arrayStride: 320,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 4, shaderLocation: 8},
          {format: 'unorm10-10-10-2', offset: 96, shaderLocation: 9},
          {format: 'float16x2', offset: 32, shaderLocation: 12},
          {format: 'unorm8x4', offset: 72, shaderLocation: 1},
          {format: 'uint32x4', offset: 152, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'ccw', cullMode: 'front', unclippedDepth: true},
});
let texture171 = device1.createTexture({
  size: [80, 80, 1],
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder138 = commandEncoder194.beginComputePass({});
let renderBundle159 = renderBundleEncoder110.finish({label: '\uf9f8\u0bdc\u3659\u3cac\u0d4f\u2a5c\u0bdc\u19c5\ub584\u229a\u{1f76a}'});
try {
renderBundleEncoder63.setBindGroup(1, bindGroup30, new Uint32Array(8353), 1056, 0);
} catch {}
try {
renderBundleEncoder34.drawIndexed(816, 5, 719, 28_244_082, 438_513_916);
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
try {
commandEncoder117.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 29794 */
  offset: 29794,
  buffer: buffer18,
}, {
  texture: texture54,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder156.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 10104 */
  offset: 10104,
  buffer: buffer28,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let promise73 = device1.queue.onSubmittedWorkDone();
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData22,
  origin: { x: 0, y: 26 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline204 = await promise24;
let commandEncoder270 = device0.createCommandEncoder({});
let texture172 = device0.createTexture({
  label: '\u173f\u1ca7\u0e5a\u2c23\u0cab\u{1fc4f}',
  size: [165],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16float', 'r16float'],
});
let textureView316 = texture128.createView({label: '\u{1fe51}\u0e9e\u{1f651}\u057b\uedb0\u901c', format: 'rg8uint'});
try {
computePassEncoder56.setBindGroup(3, bindGroup34);
} catch {}
try {
computePassEncoder90.dispatchWorkgroups(4);
} catch {}
try {
computePassEncoder54.dispatchWorkgroupsIndirect(buffer0, 182424);
} catch {}
try {
renderBundleEncoder50.drawIndexed(792, 103, 1_699, 123_368_461, 54_232_628);
} catch {}
try {
renderBundleEncoder119.setVertexBuffer(1, buffer53, 5_112, 642);
} catch {}
try {
commandEncoder84.copyTextureToBuffer({
  texture: texture4,
  mipLevel: 3,
  origin: {x: 4, y: 0, z: 2},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1796 */
  offset: 1796,
  bytesPerRow: 0,
  rowsPerImage: 184,
  buffer: buffer10,
}, {width: 0, height: 10, depthOrArrayLayers: 112});
} catch {}
try {
commandEncoder8.clearBuffer(buffer9);
} catch {}
let buffer60 = device6.createBuffer({
  label: '\u{1f797}\u4f97\u{1fd8b}\u0fcf',
  size: 194427,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
});
let textureView317 = texture165.createView({dimension: '2d-array'});
let renderBundleEncoder134 = device6.createRenderBundleEncoder({colorFormats: ['r16sint', 'rgba16sint', 'rgb10a2uint', 'rgb10a2uint'], stencilReadOnly: true});
let renderBundle160 = renderBundleEncoder132.finish();
let sampler120 = device6.createSampler({
  label: '\u086d\u0f0a\u5859\u6f4b\ud202\u{1fdd2}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMaxClamp: 36.11,
});
let externalTexture131 = device6.importExternalTexture({label: '\u262e\u94e6\u0c2e\u193a\ud840\u{1fb07}', source: videoFrame14, colorSpace: 'display-p3'});
try {
commandEncoder266.copyTextureToBuffer({
  texture: texture165,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 112 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 21488 */
  offset: 21488,
  bytesPerRow: 256,
  buffer: buffer60,
}, {width: 56, height: 16, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder266.clearBuffer(buffer60, 86884, 42056);
} catch {}
let shaderModule49 = device3.createShaderModule({
  label: '\u{1f935}\u{1f99a}\u{1feac}\ud471\uf8f3',
  code: `

@compute @workgroup_size(7, 3, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<i32>,
  @location(3) f1: vec2<u32>,
  @location(2) f2: vec2<i32>,
  @location(1) f3: vec4<u32>
}

@fragment
fn fragment0(@builtin(sample_mask) a0: u32, @builtin(position) a1: vec4<f32>, @builtin(sample_index) a2: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S40 {
  @location(1) f0: vec3<f32>
}

@vertex
fn vertex0(@location(0) a0: vec2<u32>, @location(13) a1: i32, @location(7) a2: vec2<f16>, @location(4) a3: vec3<f32>, @builtin(instance_index) a4: u32, @location(2) a5: vec2<i32>, @builtin(vertex_index) a6: u32, @location(3) a7: vec2<f16>, @location(11) a8: vec2<f16>, @location(6) a9: f32, @location(9) a10: vec2<u32>, @location(10) a11: vec2<f32>, a12: S40, @location(5) a13: f16) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  hints: {},
});
let commandEncoder271 = device3.createCommandEncoder({label: '\u{1fbf1}\u170e\u{1f8ff}\u1e89\u1fb7\u8cb4\u{1ffb8}\u0630\u0609\u0521\u{1f88a}'});
let texture173 = device3.createTexture({
  label: '\u17f9\uf448',
  size: [189],
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm'],
});
let textureView318 = texture151.createView({});
let renderBundleEncoder135 = device3.createRenderBundleEncoder({
  colorFormats: ['rg32uint', 'r16sint', 'bgra8unorm-srgb', 'rgba8unorm-srgb', undefined, 'r8unorm'],
  stencilReadOnly: true,
});
try {
computePassEncoder119.end();
} catch {}
try {
renderBundleEncoder123.setVertexBuffer(1, buffer47);
} catch {}
try {
device3.pushErrorScope('validation');
} catch {}
try {
commandEncoder168.copyBufferToBuffer(buffer47, 53660, buffer38, 121368, 4404);
} catch {}
try {
commandEncoder271.clearBuffer(buffer47);
} catch {}
try {
commandEncoder220.resolveQuerySet(querySet93, 868, 980, buffer47, 13312);
} catch {}
try {
  await device3.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder272 = device5.createCommandEncoder({});
let texture174 = device5.createTexture({
  label: '\u87ee\ud613\uc3a5\u7990\u{1fe28}\u0806\u76d0\u0508\u0a54',
  size: [468],
  dimension: '1d',
  format: 'r32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32sint'],
});
let textureView319 = texture162.createView({label: '\u0e21\u{1feee}\u8ab8', baseMipLevel: 4, arrayLayerCount: 1});
gc();
let bindGroupLayout75 = device2.createBindGroupLayout({label: '\u{1fb47}\u0fd2\u9833\u6784\u01bb\u0dd0', entries: []});
let commandEncoder273 = device2.createCommandEncoder({label: '\u{1fac1}\ua628\u3795\u30c0\u{1f69a}\u0e61\u0222'});
let sampler121 = device2.createSampler({
  label: '\uce13\u0017\u{1fdd2}\u31bf\udbd0\uc961',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 99.44,
});
try {
computePassEncoder123.setBindGroup(0, bindGroup86);
} catch {}
try {
renderBundleEncoder109.setPipeline(pipeline192);
} catch {}
try {
commandEncoder228.copyTextureToBuffer({
  texture: texture94,
  mipLevel: 2,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 42 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 12304 */
  offset: 12304,
  bytesPerRow: 512,
  buffer: buffer33,
}, {width: 21, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder228.clearBuffer(buffer33, 36092, 42896);
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
try {
window.someLabel = externalTexture131.label;
} catch {}
let commandEncoder274 = device6.createCommandEncoder({label: '\uf6f5\u6708\ufb7d'});
let querySet131 = device6.createQuerySet({type: 'occlusion', count: 56});
try {
commandEncoder274.copyTextureToBuffer({
  texture: texture165,
  mipLevel: 0,
  origin: {x: 4, y: 4, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 624 */
  offset: 624,
  bytesPerRow: 0,
  buffer: buffer60,
}, {width: 0, height: 4, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder266.resolveQuerySet(querySet131, 6, 6, buffer60, 8192);
} catch {}
try {
device6.queue.writeBuffer(buffer60, 127708, new Float32Array(57406), 21016, 412);
} catch {}
let renderBundle161 = renderBundleEncoder7.finish({label: '\u{1f8ee}\u882a\u{1fdc9}\uace7\uc247\u30df\u056f\ua7fb'});
let externalTexture132 = device0.importExternalTexture({source: video25, colorSpace: 'display-p3'});
try {
renderPassEncoder14.setScissorRect(64, 446, 437, 14);
} catch {}
try {
renderPassEncoder13.setStencilReference(3960);
} catch {}
try {
renderPassEncoder12.setVertexBuffer(0, buffer24, 1_952, 47_163);
} catch {}
try {
renderBundleEncoder19.setBindGroup(3, bindGroup27, new Uint32Array(3700), 387, 0);
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(6, buffer7, 0);
} catch {}
try {
texture135.destroy();
} catch {}
try {
commandEncoder150.resolveQuerySet(querySet44, 291, 94, buffer34, 52224);
} catch {}
try {
computePassEncoder36.insertDebugMarker('\u191c');
} catch {}
try {
device0.queue.writeBuffer(buffer16, 44, new Int16Array(53632), 32172, 1384);
} catch {}
let pipeline205 = device0.createComputePipeline({
  label: '\uf54c\u912a\u04a2\u{1ff2e}\u1b24\u2e81\u{1fe76}\uf50f\u4136\ub3cf',
  layout: pipelineLayout23,
  compute: {module: shaderModule37, entryPoint: 'compute0', constants: {}},
});
try {
gpuCanvasContext22.unconfigure();
} catch {}
let commandEncoder275 = device1.createCommandEncoder({label: '\u{1f688}\u1289\u{1faf3}\u11a2\u109c\u4acd\u{1ff14}'});
let querySet132 = device1.createQuerySet({label: '\u39a9\ub6d7\ue2a3', type: 'occlusion', count: 1025});
let textureView320 = texture137.createView({label: '\u0ff2\uc0ad\u{1fbad}\u{1f669}\u{1fe69}\ub4b7\ue5c8\u2816', format: 'r8uint', baseMipLevel: 3});
let renderBundleEncoder136 = device1.createRenderBundleEncoder({
  label: '\u{1ffb5}\u{1f91f}\ufadd\ue722\u{1fbfa}',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle162 = renderBundleEncoder136.finish({label: '\ua1cd\u06a7\u749f\u403d\u1a89\u0c5a\u02e7\uc262\u937b\ud030\u0614'});
try {
renderBundleEncoder34.drawIndirect(buffer15, 3_468);
} catch {}
let arrayBuffer17 = buffer32.getMappedRange(0, 1636);
try {
commandEncoder165.copyBufferToTexture({
  /* bytesInLastRow: 560 widthInBlocks: 35 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 168016 */
  offset: 12880,
  bytesPerRow: 768,
  rowsPerImage: 101,
  buffer: buffer18,
}, {
  texture: texture96,
  mipLevel: 4,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 35, height: 0, depthOrArrayLayers: 3});
} catch {}
try {
renderBundleEncoder34.pushDebugGroup('\u03cd');
} catch {}
try {
gpuCanvasContext33.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let promise74 = device1.queue.onSubmittedWorkDone();
let bindGroup91 = device3.createBindGroup({
  label: '\u210e\u691a\u{1fda6}\u{1f98d}',
  layout: bindGroupLayout64,
  entries: [{binding: 852, resource: externalTexture110}],
});
let texture175 = device3.createTexture({
  size: [175, 1, 1500],
  mipLevelCount: 11,
  dimension: '3d',
  format: 'rg8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8sint', 'rg8sint'],
});
let computePassEncoder139 = commandEncoder246.beginComputePass({label: '\u0cdb\u{1fbc7}'});
let externalTexture133 = device3.importExternalTexture({label: '\u{1fdcb}\u4384\u6427\u8541\u5aac\u0b56\u037b', source: video32});
try {
renderBundleEncoder135.setVertexBuffer(5, buffer47, 25_484);
} catch {}
let arrayBuffer18 = buffer38.getMappedRange(0, 5708);
try {
commandEncoder237.resolveQuerySet(querySet96, 462, 371, buffer47, 129280);
} catch {}
let promise75 = device3.createRenderPipelineAsync({
  label: '\u75bd\u0a5e\ue78a\u{1fc55}',
  layout: pipelineLayout25,
  fragment: {
  module: shaderModule49,
  entryPoint: 'fragment0',
  targets: [{format: 'rgba32sint'}, {format: 'rg32uint', writeMask: 0}, {format: 'rg16sint', writeMask: 0}, {format: 'r32uint', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule49,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 76,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 0, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 12, shaderLocation: 1},
          {format: 'sint32x2', offset: 4, shaderLocation: 13},
        ],
      },
      {arrayStride: 16, stepMode: 'instance', attributes: []},
      {arrayStride: 288, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'float32x4', offset: 444, shaderLocation: 7},
          {format: 'unorm16x2', offset: 196, shaderLocation: 4},
          {format: 'snorm16x4', offset: 8, shaderLocation: 10},
          {format: 'float32x2', offset: 136, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 388,
        stepMode: 'instance',
        attributes: [{format: 'uint32', offset: 16, shaderLocation: 9}],
      },
      {arrayStride: 100, stepMode: 'instance', attributes: []},
      {arrayStride: 416, attributes: []},
      {
        arrayStride: 728,
        attributes: [
          {format: 'unorm8x4', offset: 76, shaderLocation: 6},
          {format: 'uint16x2', offset: 88, shaderLocation: 0},
          {format: 'float16x4', offset: 44, shaderLocation: 11},
          {format: 'unorm16x2', offset: 128, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', unclippedDepth: true},
});
let offscreenCanvas36 = new OffscreenCanvas(270, 656);
let textureView321 = texture49.createView({
  label: '\u04fb\u{1f6d6}\ud3c8\u04e1\u{1fe2f}\ua6ac\u0b88\u0204\u8397\u048f\u{1fc49}',
  mipLevelCount: 1,
});
let renderBundleEncoder137 = device1.createRenderBundleEncoder({
  label: '\u0bd9\u{1fb53}\u67fb\u086b\udc58\u{1f7e3}',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: false,
});
try {
renderBundleEncoder34.drawIndexedIndirect(buffer13, 62_264);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline80);
} catch {}
try {
commandEncoder156.copyTextureToBuffer({
  texture: texture111,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 12},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4632 */
  offset: 4632,
  bytesPerRow: 0,
  rowsPerImage: 51,
  buffer: buffer12,
}, {width: 0, height: 0, depthOrArrayLayers: 56});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture171,
  mipLevel: 0,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, new ArrayBuffer(40), /* required buffer size: 9_018 */
{offset: 856, bytesPerRow: 303}, {width: 71, height: 27, depthOrArrayLayers: 1});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let querySet133 = device2.createQuerySet({label: '\u3281\ua733\u9c2c\u8414\u98e9', type: 'occlusion', count: 3633});
let textureView322 = texture126.createView({
  label: '\u0119\u0bd8\u{1fb54}\u86e7\u05f4\u09ca\u75f6',
  dimension: '2d-array',
  baseMipLevel: 5,
  mipLevelCount: 1,
});
let renderBundleEncoder138 = device2.createRenderBundleEncoder({
  label: '\ue19d\ube40\ueaac\u544e\u3818',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder87.setPipeline(pipeline177);
} catch {}
try {
renderBundleEncoder106.setBindGroup(2, bindGroup47);
} catch {}
let promise76 = buffer52.mapAsync(GPUMapMode.WRITE, 0, 29260);
try {
commandEncoder213.clearBuffer(buffer33, 140064, 5196);
} catch {}
let pipeline206 = device2.createComputePipeline({
  label: '\u062f\u2ffc\u04bc\u7d4d\uea98',
  layout: pipelineLayout9,
  compute: {module: shaderModule40, entryPoint: 'compute0', constants: {}},
});
document.body.prepend(canvas0);
let commandEncoder276 = device2.createCommandEncoder({});
try {
commandEncoder242.copyBufferToBuffer(buffer41, 18232, buffer23, 498568, 236);
} catch {}
try {
commandEncoder213.copyTextureToTexture({
  texture: texture132,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture97,
  mipLevel: 0,
  origin: {x: 151, y: 4, z: 0},
  aspect: 'all',
},
{width: 21, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.writeBuffer(buffer57, 8748, new BigUint64Array(44225), 26981);
} catch {}
let textureView323 = texture142.createView({label: '\u08a5\u0328\u9b72\ua446\u{1fb0e}\u9fb6\ue3c0\ua2dd', baseMipLevel: 3});
let computePassEncoder140 = commandEncoder124.beginComputePass({label: '\u37d5\u7396\ud216\u0a4f\uf6c3\ucab2\udcab\u1887\u06fb'});
let renderBundleEncoder139 = device1.createRenderBundleEncoder({
  label: '\ua606\u02e5',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  depthReadOnly: true,
});
let renderBundle163 = renderBundleEncoder137.finish();
try {
renderBundleEncoder52.setBindGroup(3, bindGroup83, new Uint32Array(1579), 1505, 0);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture50,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new DataView(arrayBuffer11), /* required buffer size: 830 */
{offset: 782}, {width: 12, height: 1, depthOrArrayLayers: 1});
} catch {}
let commandEncoder277 = device3.createCommandEncoder({label: '\u0c87\ud612\u9086\u562a\u{1f731}\ub664\u020c\u99eb\u9a3e\u6f71\u0868'});
let texture176 = device3.createTexture({
  label: '\ufc13\u0fd7\ubfe0\u098f\u07e6\ud1ee',
  size: [672, 30, 127],
  mipLevelCount: 7,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint'],
});
let renderBundleEncoder140 = device3.createRenderBundleEncoder({
  label: '\u258f\u1a96\u{1ff1f}\u5313\u71ec\u92ad\u{1fb4a}\u4971\u0b03\u{1f866}\u01d3',
  colorFormats: ['rg8sint', 'rgba8unorm-srgb', 'rgba8uint', undefined, 'rgba8sint', 'rg32uint', 'rg8unorm'],
  depthReadOnly: true,
});
try {
renderBundleEncoder104.setVertexBuffer(6, buffer47, 64_432);
} catch {}
let pipeline207 = device3.createRenderPipeline({
  label: '\u22ec\uf63f\u{1f94a}\ube4e\u14d2\uc51b\u1786',
  layout: pipelineLayout15,
  multisample: {mask: 0xc3bc1dbb},
  fragment: {
  module: shaderModule49,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rg16sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'r32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'less', failOp: 'invert', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'not-equal', failOp: 'increment-clamp', depthFailOp: 'replace', passOp: 'decrement-wrap'},
    stencilReadMask: 2192764305,
    stencilWriteMask: 1675544589,
    depthBiasClamp: 556.3776214006664,
  },
  vertex: {
    module: shaderModule49,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 792,
        attributes: [
          {format: 'uint16x4', offset: 80, shaderLocation: 9},
          {format: 'snorm16x4', offset: 40, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 1020,
        attributes: [
          {format: 'sint32x3', offset: 16, shaderLocation: 13},
          {format: 'sint32x4', offset: 104, shaderLocation: 2},
          {format: 'uint32x3', offset: 16, shaderLocation: 0},
          {format: 'float16x4', offset: 320, shaderLocation: 10},
          {format: 'float32x4', offset: 108, shaderLocation: 5},
          {format: 'unorm16x2', offset: 12, shaderLocation: 11},
          {format: 'snorm8x4', offset: 176, shaderLocation: 7},
        ],
      },
      {arrayStride: 836, stepMode: 'instance', attributes: []},
      {arrayStride: 484, stepMode: 'instance', attributes: []},
      {arrayStride: 272, stepMode: 'instance', attributes: []},
      {arrayStride: 92, stepMode: 'instance', attributes: []},
      {arrayStride: 84, attributes: [{format: 'unorm8x2', offset: 2, shaderLocation: 3}]},
      {
        arrayStride: 300,
        attributes: [
          {format: 'snorm8x2', offset: 30, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'back'},
});
let video43 = await videoWithData();
let bindGroupLayout76 = device5.createBindGroupLayout({
  label: '\u958f\u0f9a',
  entries: [
    {binding: 463, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }},
    {binding: 236, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let texture177 = device5.createTexture({
  label: '\u{1fd66}\u{1f72a}\u0241\u050b\ua88e\udf63\u0b88',
  size: {width: 2496},
  mipLevelCount: 1,
  sampleCount: 1,
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
document.body.prepend(video6);
let canvas39 = document.createElement('canvas');
let bindGroup92 = device0.createBindGroup({
  label: '\u1b89\u{1f98a}\u86a8\u8e57\u09df\u{1ff4b}\u9d1e\u{1f924}\u90e1\u0d82\u1407',
  layout: bindGroupLayout62,
  entries: [{binding: 864, resource: {buffer: buffer0, offset: 309504, size: 37788}}],
});
let commandEncoder278 = device0.createCommandEncoder();
let texture178 = device0.createTexture({
  label: '\uf866\uef65\ucc7e\u738c\u051b\u962f\u5b17\u9309\u{1f7d2}\u0faf\u0672',
  size: [165, 120, 124],
  mipLevelCount: 3,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView324 = texture12.createView({baseMipLevel: 3, mipLevelCount: 4, baseArrayLayer: 113, arrayLayerCount: 3});
let renderPassEncoder17 = commandEncoder8.beginRenderPass({
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: -449.1, g: -307.5, b: 369.9, a: -358.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet87,
  maxDrawCount: 561434383,
});
let externalTexture134 = device0.importExternalTexture({label: '\u{1f61c}\u20aa\u8637\u0623\u094c\u{1fc98}\u8e3a', source: videoFrame24, colorSpace: 'srgb'});
try {
computePassEncoder112.setBindGroup(2, bindGroup9);
} catch {}
try {
computePassEncoder41.setPipeline(pipeline193);
} catch {}
try {
renderPassEncoder13.setBindGroup(3, bindGroup15);
} catch {}
try {
renderPassEncoder17.setBlendConstant({ r: -241.1, g: -168.3, b: 786.8, a: -188.0, });
} catch {}
try {
renderPassEncoder16.setViewport(149.0, 96.05, 2.826, 2.976, 0.2399, 0.6312);
} catch {}
try {
renderPassEncoder8.setIndexBuffer(buffer7, 'uint16', 23_310, 1_439);
} catch {}
try {
renderBundleEncoder29.drawIndexed(993, 67, 670, -1_730_120_716, 13_632_451);
} catch {}
try {
commandEncoder100.copyBufferToTexture({
  /* bytesInLastRow: 1412 widthInBlocks: 353 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 380688 */
  offset: 22924,
  bytesPerRow: 1536,
  rowsPerImage: 60,
  buffer: buffer5,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 80, y: 0, z: 1},
  aspect: 'all',
}, {width: 353, height: 53, depthOrArrayLayers: 4});
} catch {}
try {
gpuCanvasContext4.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb'],
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 41, height: 30, depthOrArrayLayers: 147}
*/
{
  source: imageData1,
  origin: { x: 2, y: 22 },
  flipY: true,
}, {
  texture: texture101,
  mipLevel: 3,
  origin: {x: 1, y: 14, z: 3},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(video36);
let querySet134 = device1.createQuerySet({label: '\u1791\u8239', type: 'occlusion', count: 2653});
let textureView325 = texture52.createView({
  label: '\u8748\u1a1c\ua975\u027a\u078d\u1287',
  baseMipLevel: 8,
  mipLevelCount: 1,
  baseArrayLayer: 126,
  arrayLayerCount: 61,
});
try {
computePassEncoder50.end();
} catch {}
try {
renderBundleEncoder39.setBindGroup(1, bindGroup36);
} catch {}
try {
renderBundleEncoder34.drawIndexed(5_183, 168, 1_421, 850_321_701, 1_187_937_812);
} catch {}
try {
commandEncoder222.copyTextureToTexture({
  texture: texture137,
  mipLevel: 3,
  origin: {x: 1, y: 9, z: 0},
  aspect: 'all',
},
{
  texture: texture137,
  mipLevel: 2,
  origin: {x: 26, y: 4, z: 0},
  aspect: 'all',
},
{width: 26, height: 9, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder115.clearBuffer(buffer13, 78728);
} catch {}
try {
gpuCanvasContext29.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, new BigUint64Array(new ArrayBuffer(8)), /* required buffer size: 1_758 */
{offset: 902}, {width: 214, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas18,
  origin: { x: 4, y: 628 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let computePassEncoder141 = commandEncoder220.beginComputePass({label: '\ufd12\u02ea\u{1f95d}'});
let renderBundle164 = renderBundleEncoder116.finish({label: '\u{1f973}\u6cf6\u3242\u0bcc\uf483\u3333\u08d4\u{1fe1d}\u70a9\u905b'});
try {
commandEncoder217.copyBufferToBuffer(buffer47, 127860, buffer38, 120388, 720);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture103,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer12, /* required buffer size: 488_577 */
{offset: 537, bytesPerRow: 420, rowsPerImage: 83}, {width: 110, height: 0, depthOrArrayLayers: 15});
} catch {}
canvas30.height = 651;
try {
offscreenCanvas36.getContext('2d');
} catch {}
let commandEncoder279 = device1.createCommandEncoder({label: '\u7716\u{1fa4e}\uf98e\u575b\u7a42\u035f\u{1feb0}'});
let textureView326 = texture78.createView({dimension: '2d-array', baseMipLevel: 1});
let sampler122 = device1.createSampler({
  label: '\ue4f6\u{1ff1f}\ud2be',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 88.54,
  lodMaxClamp: 90.46,
});
let externalTexture135 = device1.importExternalTexture({label: '\u{1fd12}\u0816\ud8cf', source: video14, colorSpace: 'srgb'});
try {
renderBundleEncoder34.drawIndirect(buffer42, 616);
} catch {}
try {
device1.pushErrorScope('internal');
} catch {}
try {
commandEncoder201.copyTextureToBuffer({
  texture: texture68,
  mipLevel: 1,
  origin: {x: 7, y: 4, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 548 widthInBlocks: 137 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 34216 */
  offset: 21380,
  bytesPerRow: 1024,
  buffer: buffer59,
}, {width: 137, height: 13, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder165.resolveQuerySet(querySet39, 181, 332, buffer18, 3584);
} catch {}
try {
renderBundleEncoder34.popDebugGroup();
} catch {}
try {
device1.queue.writeTexture({
  texture: texture156,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer14, /* required buffer size: 1_250 */
{offset: 199, bytesPerRow: 183}, {width: 34, height: 6, depthOrArrayLayers: 1});
} catch {}
offscreenCanvas31.height = 656;
let textureView327 = texture169.createView({label: '\u3e21\ubee0\u0046\u78b2\u1530\u{1f994}\u0ccb'});
let computePassEncoder142 = commandEncoder272.beginComputePass({});
try {
commandEncoder258.copyTextureToTexture({
  texture: texture174,
  mipLevel: 0,
  origin: {x: 152, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture169,
  mipLevel: 0,
  origin: {x: 1868, y: 0, z: 0},
  aspect: 'all',
},
{width: 59, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext19.configure({
  device: device5,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
canvas16.width = 140;
let bindGroup93 = device1.createBindGroup({label: '\ufaaf\ue3ea', layout: bindGroupLayout20, entries: []});
let commandEncoder280 = device1.createCommandEncoder();
try {
renderBundleEncoder34.drawIndirect(buffer42, 844);
} catch {}
try {
renderBundleEncoder68.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(7, buffer42, 1_332);
} catch {}
try {
commandEncoder275.copyBufferToTexture({
  /* bytesInLastRow: 448 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 301648 */
  offset: 144,
  bytesPerRow: 512,
  rowsPerImage: 294,
  buffer: buffer18,
}, {
  texture: texture96,
  mipLevel: 3,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
}, {width: 28, height: 1, depthOrArrayLayers: 3});
} catch {}
try {
commandEncoder165.resolveQuerySet(querySet101, 66, 150, buffer31, 9728);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture50,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer15, /* required buffer size: 505 */
{offset: 505}, {width: 29, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas36,
  origin: { x: 11, y: 21 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder281 = device3.createCommandEncoder();
let textureView328 = texture151.createView({label: '\uef45\ud63e\u4c66', format: 'bgra8unorm'});
let renderBundle165 = renderBundleEncoder116.finish({label: '\u3d28\u1f2d\uc45b'});
try {
renderBundleEncoder118.setBindGroup(3, bindGroup69);
} catch {}
try {
commandEncoder271.clearBuffer(buffer49);
} catch {}
let gpuCanvasContext34 = canvas39.getContext('webgpu');
let videoFrame30 = new VideoFrame(video30, {timestamp: 0});
let commandEncoder282 = device6.createCommandEncoder({label: '\u0681\u08ef\uace6\u099e\ue11c\u8020\u098b\u0735\u0d4e\u{1fbf5}'});
let texture179 = device6.createTexture({
  label: '\u64cd\u0fdd\u0f89\u9732\u{1fc6a}\udd0d',
  size: [186],
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['rgb10a2uint', 'rgb10a2uint', 'rgb10a2uint'],
});
let textureView329 = texture179.createView({label: '\u{1fbf6}\u{1fc56}\u{1f66b}\udf33\u1a80'});
try {
  await promise74;
} catch {}
let querySet135 = device0.createQuerySet({label: '\u8a30\ufbe6\u7851\u{1ffcb}\u285e\u1301\u3bfd', type: 'occlusion', count: 3169});
let computePassEncoder143 = commandEncoder231.beginComputePass({});
try {
renderPassEncoder8.setBindGroup(2, bindGroup34);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setViewport(92.15, 15.52, 20.68, 30.91, 0.1501, 0.7660);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer24, 157_408);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm', 'rgba8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer3, 28396, new Int16Array(19227), 18192, 52);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline208 = device0.createRenderPipeline({
  label: '\u3c9a\ufc44\u0cba\u93a1\uc1e8\u0725\u4cae\u{1f71d}\u4cd8',
  layout: pipelineLayout10,
  multisample: {mask: 0x20ab152c},
  fragment: {module: shaderModule21, entryPoint: 'fragment0', constants: {}, targets: [{format: 'r32float'}]},
  vertex: {module: shaderModule21, buffers: []},
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'ccw', cullMode: 'front'},
});
let sampler123 = device1.createSampler({
  label: '\u4ef4\u{1ff32}\u0afc\u0558\uf541\u2793',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 2.598,
  lodMaxClamp: 63.60,
  compare: 'equal',
  maxAnisotropy: 20,
});
let externalTexture136 = device1.importExternalTexture({source: videoFrame20, colorSpace: 'display-p3'});
try {
commandEncoder269.resolveQuerySet(querySet49, 482, 371, buffer36, 1536);
} catch {}
try {
computePassEncoder59.insertDebugMarker('\ucd98');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device1.queue.submit([commandBuffer60]);
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55) };
} catch {}
let texture180 = device2.createTexture({
  label: '\u84dc\u06c7\u6d2d\u4b9f\u06c6\u{1faaf}',
  size: {width: 180, height: 768, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm', 'rgba8unorm'],
});
let textureView330 = texture117.createView({label: '\u467a\u{1fa46}\u0014\uc61d\u{1fb9b}', mipLevelCount: 5});
let computePassEncoder144 = commandEncoder213.beginComputePass({label: '\u084d\u587d\ud7f7\u907b\u25c0\u255a\u{1f7fe}\u8484\uba95\u7187\u20f1'});
let renderBundle166 = renderBundleEncoder58.finish({label: '\u8f3a\u31e6\u40da\u083b\u{1fd4d}\u0c05\ud594\u1cde'});
let externalTexture137 = device2.importExternalTexture({label: '\u09de\u67d9\u711d', source: videoFrame29, colorSpace: 'srgb'});
try {
computePassEncoder114.end();
} catch {}
try {
renderBundleEncoder109.setBindGroup(3, bindGroup51);
} catch {}
try {
renderBundleEncoder69.setPipeline(pipeline133);
} catch {}
try {
commandEncoder273.copyTextureToBuffer({
  texture: texture140,
  mipLevel: 0,
  origin: {x: 303, y: 0, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 452 widthInBlocks: 113 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 118116 */
  offset: 9572,
  bytesPerRow: 512,
  rowsPerImage: 4,
  buffer: buffer33,
}, {width: 113, height: 0, depthOrArrayLayers: 54});
} catch {}
let pipeline209 = device2.createRenderPipeline({
  layout: pipelineLayout14,
  multisample: {count: 4, mask: 0x9817cc96},
  fragment: {
  module: shaderModule42,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALL}, {format: 'rgba8unorm'}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'src-alpha', dstFactor: 'constant'},
  },
}, {format: 'r8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'r8sint'}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'constant'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {failOp: 'decrement-wrap', depthFailOp: 'decrement-wrap', passOp: 'replace'},
    stencilBack: {compare: 'greater-equal', failOp: 'decrement-clamp', depthFailOp: 'decrement-clamp'},
    stencilReadMask: 4240960093,
    stencilWriteMask: 2342193915,
    depthBias: 0,
    depthBiasSlopeScale: 620.9341310570961,
  },
  vertex: {
    module: shaderModule42,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x2', offset: 0, shaderLocation: 14}],
      },
      {
        arrayStride: 488,
        stepMode: 'instance',
        attributes: [{format: 'sint32', offset: 128, shaderLocation: 12}],
      },
      {arrayStride: 356, attributes: [{format: 'snorm8x2', offset: 64, shaderLocation: 10}]},
      {
        arrayStride: 1004,
        attributes: [
          {format: 'float16x4', offset: 212, shaderLocation: 1},
          {format: 'float32', offset: 204, shaderLocation: 13},
          {format: 'uint32x3', offset: 56, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 364,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 96, shaderLocation: 3}],
      },
      {arrayStride: 412, stepMode: 'instance', attributes: []},
      {arrayStride: 476, attributes: []},
      {
        arrayStride: 140,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32', offset: 20, shaderLocation: 6},
          {format: 'snorm16x4', offset: 0, shaderLocation: 5},
          {format: 'uint32', offset: 12, shaderLocation: 7},
          {format: 'float16x4', offset: 8, shaderLocation: 2},
          {format: 'snorm8x4', offset: 48, shaderLocation: 15},
          {format: 'sint8x2', offset: 4, shaderLocation: 4},
          {format: 'float32x2', offset: 16, shaderLocation: 0},
          {format: 'float32', offset: 12, shaderLocation: 9},
          {format: 'unorm16x4', offset: 4, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'back'},
});
let commandEncoder283 = device2.createCommandEncoder();
let texture181 = device2.createTexture({
  size: [48, 32, 208],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
});
try {
computePassEncoder76.setPipeline(pipeline105);
} catch {}
try {
renderBundleEncoder76.setBindGroup(1, bindGroup47);
} catch {}
try {
renderBundleEncoder69.setVertexBuffer(5, buffer43, 36);
} catch {}
try {
device2.addEventListener('uncapturederror', e => { log('device2.uncapturederror'); log(e); e.label = device2.label; });
} catch {}
let bindGroupLayout77 = pipeline77.getBindGroupLayout(3);
let commandEncoder284 = device1.createCommandEncoder({});
let textureView331 = texture46.createView({
  label: '\ubfc9\u4e26\u00fd\ucb61\u913a\u25cf\u794d',
  dimension: '2d',
  baseMipLevel: 3,
  mipLevelCount: 1,
  baseArrayLayer: 1,
});
try {
renderBundleEncoder82.setBindGroup(0, bindGroup74, new Uint32Array(7510), 2923, 0);
} catch {}
try {
renderBundleEncoder34.drawIndexed(3_014, 3, 7_957, 69_195_010, 109_170_279);
} catch {}
try {
renderBundleEncoder105.setVertexBuffer(4_294_967_295, undefined, 0, 448_434_621);
} catch {}
let arrayBuffer19 = buffer26.getMappedRange(262464, 3648);
try {
commandEncoder279.resolveQuerySet(querySet122, 3, 9, buffer15, 3072);
} catch {}
let pipeline210 = device1.createRenderPipeline({
  label: '\u{1f664}\u{1ffd3}\u0dc4\u086f\u094b\u398c\u3099',
  layout: pipelineLayout24,
  multisample: {count: 4, mask: 0xfc5ba69},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 1336,
        stepMode: 'instance',
        attributes: [{format: 'uint8x2', offset: 48, shaderLocation: 11}],
      },
      {
        arrayStride: 16,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 0, shaderLocation: 12},
          {format: 'uint32x2', offset: 0, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'float32', offset: 208, shaderLocation: 2},
          {format: 'uint32x3', offset: 132, shaderLocation: 4},
        ],
      },
      {arrayStride: 0, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 28, attributes: []},
      {arrayStride: 1524, attributes: []},
      {
        arrayStride: 1824,
        attributes: [
          {format: 'float32', offset: 632, shaderLocation: 0},
          {format: 'snorm8x4', offset: 256, shaderLocation: 13},
          {format: 'float32x3', offset: 36, shaderLocation: 3},
          {format: 'sint32x2', offset: 220, shaderLocation: 10},
          {format: 'snorm16x2', offset: 396, shaderLocation: 5},
          {format: 'uint16x4', offset: 68, shaderLocation: 9},
          {format: 'uint32', offset: 136, shaderLocation: 1},
          {format: 'uint32x2', offset: 152, shaderLocation: 6},
          {format: 'uint32x2', offset: 116, shaderLocation: 15},
          {format: 'unorm10-10-10-2', offset: 20, shaderLocation: 14},
          {format: 'uint32x3', offset: 136, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'ccw', cullMode: 'back'},
});
try {
  await adapter3.requestAdapterInfo();
} catch {}
let buffer61 = device2.createBuffer({
  label: '\u0f12\u1466',
  size: 48588,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: true,
});
let texture182 = device2.createTexture({
  label: '\u0e8a\u0ad9\u041c\u014b\u7536\u{1f700}\u0945\u{1fbbb}\u7627\u4db9',
  size: [1440, 1, 1],
  mipLevelCount: 7,
  sampleCount: 1,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView332 = texture95.createView({baseArrayLayer: 28, arrayLayerCount: 22});
try {
renderBundleEncoder91.setIndexBuffer(buffer43, 'uint16', 5_294, 149);
} catch {}
try {
renderBundleEncoder91.setVertexBuffer(2, buffer43, 412);
} catch {}
let arrayBuffer20 = buffer22.getMappedRange(201720, 628);
try {
device2.queue.copyExternalImageToTexture(/*
{width: 12, height: 8, depthOrArrayLayers: 52}
*/
{
  source: videoFrame9,
  origin: { x: 1, y: 3 },
  flipY: false,
}, {
  texture: texture108,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline211 = device2.createComputePipeline({
  label: '\u{1f73d}\u0455\u6bda\u0214\udf62\u042e',
  layout: 'auto',
  compute: {module: shaderModule46, entryPoint: 'compute0', constants: {}},
});
let video44 = await videoWithData();
let pipelineLayout28 = device5.createPipelineLayout({
  label: '\u{1fd81}\u783d\u8dae',
  bindGroupLayouts: [bindGroupLayout70, bindGroupLayout70, bindGroupLayout70],
});
let querySet136 = device5.createQuerySet({
  label: '\ub632\u9116\u{1f624}\u{1fed0}\u{1fe39}\u5fcd\uaeac\u5653\u086c',
  type: 'occlusion',
  count: 2721,
});
let textureView333 = texture169.createView({label: '\u{1f76c}\u0a5b\ua866\ub7c1'});
let computePassEncoder145 = commandEncoder258.beginComputePass({label: '\u14ec\u245d\u0ada\ua1c4\u2e56\u4fb5\u{1fe69}\u98aa\u5f5e\u07b1'});
document.body.prepend(canvas21);
let buffer62 = device2.createBuffer({size: 318207, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let commandEncoder285 = device2.createCommandEncoder({});
let textureView334 = texture109.createView({label: '\u0c28\u219d\u{1febb}\ub68f', dimension: '2d-array', baseMipLevel: 1});
let computePassEncoder146 = commandEncoder228.beginComputePass({});
let renderBundle167 = renderBundleEncoder130.finish();
try {
commandEncoder276.copyTextureToBuffer({
  texture: texture109,
  mipLevel: 2,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 224 widthInBlocks: 56 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 52520 */
  offset: 52520,
  buffer: buffer62,
}, {width: 56, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder186.copyTextureToTexture({
  texture: texture132,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture97,
  mipLevel: 0,
  origin: {x: 95, y: 1, z: 0},
  aspect: 'all',
},
{width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder276.clearBuffer(buffer62, 264980, 33748);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture138,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Float32Array(arrayBuffer15), /* required buffer size: 253 */
{offset: 253}, {width: 3, height: 0, depthOrArrayLayers: 1});
} catch {}
let videoFrame31 = new VideoFrame(canvas34, {timestamp: 0});
let shaderModule50 = device4.createShaderModule({
  label: '\u{1fdf7}\u8183\u8eba\u{1fe4a}\u{1f829}\ua68d\uc96a\u0546\u{1f7e7}',
  code: `@group(0) @binding(910)
var<storage, read_write> type12: array<u32>;
@group(1) @binding(910)
var<storage, read_write> global14: array<u32>;
@group(1) @binding(386)
var<storage, read_write> field14: array<u32>;
@group(0) @binding(386)
var<storage, read_write> type13: array<u32>;

@compute @workgroup_size(4, 4, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(5) f0: vec3<f32>,
  @location(2) f1: vec2<f32>,
  @location(0) f2: vec4<u32>,
  @location(3) f3: vec3<f32>,
  @location(4) f4: vec3<i32>,
  @location(1) f5: vec4<i32>
}

@fragment
fn fragment0(@builtin(front_facing) a0: bool, @builtin(position) a1: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S41 {
  @location(5) f0: f16,
  @location(1) f1: vec4<f32>,
  @location(6) f2: f16
}

@vertex
fn vertex0(@location(13) a0: vec4<i32>, @location(0) a1: vec4<f16>, @location(11) a2: vec3<f16>, @location(2) a3: vec3<f32>, @location(14) a4: vec2<f32>, @location(10) a5: vec2<u32>, @location(7) a6: f32, a7: S41, @location(4) a8: vec3<f32>, @location(12) a9: f16, @location(3) a10: i32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout78 = device4.createBindGroupLayout({
  label: '\uc70d\u3481\u0fc8\uf1e0\u7f09\ua8db\u{1f85d}',
  entries: [
    {binding: 274, visibility: 0, externalTexture: {}},
    {
      binding: 659,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '3d' },
    },
    {
      binding: 201,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let querySet137 = device4.createQuerySet({label: '\u275e\u{1f702}\u0350\u595a\u1690\u304f\u308e\u8207', type: 'occlusion', count: 2427});
let externalTexture138 = device4.importExternalTexture({label: '\u01dc\ubf40\u0567\u9916', source: video38, colorSpace: 'srgb'});
try {
computePassEncoder129.setPipeline(pipeline165);
} catch {}
try {
renderBundleEncoder129.setPipeline(pipeline180);
} catch {}
try {
commandEncoder243.resolveQuerySet(querySet95, 9, 5, buffer48, 14592);
} catch {}
try {
device4.queue.writeBuffer(buffer54, 25520, new BigUint64Array(31234), 15721);
} catch {}
let pipeline212 = await device4.createComputePipelineAsync({layout: pipelineLayout17, compute: {module: shaderModule47, entryPoint: 'compute0'}});
let video45 = await videoWithData();
let buffer63 = device1.createBuffer({
  label: '\u{1fe90}\u734c\u07fd\u{1fce8}\ubf6a\u4dd8\u09b3\u4f25\u{1feef}\u2112',
  size: 38380,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: true,
});
let commandEncoder286 = device1.createCommandEncoder();
let renderBundleEncoder141 = device1.createRenderBundleEncoder({
  label: '\ufd4e\u{1f616}\u{1fe27}\u{1fa3d}',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle168 = renderBundleEncoder32.finish({label: '\u{1fce4}\u88ca'});
try {
renderBundleEncoder34.drawIndexedIndirect(buffer19, 1_012);
} catch {}
try {
renderBundleEncoder107.setVertexBuffer(2, buffer12, 316, 2_354);
} catch {}
try {
commandEncoder280.resolveQuerySet(querySet50, 583, 695, buffer31, 4864);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture142,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
}, new Int8Array(new ArrayBuffer(32)), /* required buffer size: 6_440 */
{offset: 948, bytesPerRow: 194, rowsPerImage: 226}, {width: 15, height: 29, depthOrArrayLayers: 1});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas18,
  origin: { x: 3, y: 115 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas37 = new OffscreenCanvas(999, 272);
let imageData42 = new ImageData(108, 112);
let texture183 = device3.createTexture({
  label: '\u84f2\u8389\u{1f676}\u0b3b\ub931',
  size: {width: 756, height: 8, depthOrArrayLayers: 1},
  mipLevelCount: 10,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
let textureView335 = texture122.createView({label: '\u7050\u24de\ud52e\u{1fef7}\u03ca\u6d38\u{1f820}\u71d5', dimension: '2d-array'});
try {
renderBundleEncoder98.setVertexBuffer(0, buffer47);
} catch {}
try {
commandEncoder221.copyBufferToBuffer(buffer47, 117064, buffer49, 1432, 14520);
} catch {}
try {
commandEncoder237.copyBufferToTexture({
  /* bytesInLastRow: 92 widthInBlocks: 46 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 14328 */
  offset: 14328,
  bytesPerRow: 256,
  buffer: buffer47,
}, {
  texture: texture143,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {width: 46, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device3.queue.writeTexture({
  texture: texture131,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 228_955 */
{offset: 859, bytesPerRow: 144, rowsPerImage: 176}, {width: 58, height: 0, depthOrArrayLayers: 10});
} catch {}
document.body.prepend(video4);
let buffer64 = device3.createBuffer({
  size: 297760,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder287 = device3.createCommandEncoder({label: '\ubef3\u6483\u759d\u{1fed4}'});
let textureView336 = texture105.createView({
  label: '\u{1f6e9}\u8adf\u{1fc0f}\u0427\u787b\u{1f781}\u{1f92d}',
  aspect: 'all',
  format: 'astc-12x10-unorm',
  baseMipLevel: 3,
  mipLevelCount: 1,
  baseArrayLayer: 19,
  arrayLayerCount: 28,
});
let renderBundle169 = renderBundleEncoder123.finish({});
let externalTexture139 = device3.importExternalTexture({label: '\ufa75\u79cb\u3ed0\u04c0\u6b6e\u4bc4', source: video9, colorSpace: 'display-p3'});
try {
renderBundleEncoder98.setVertexBuffer(1, buffer64, 16_100, 22_559);
} catch {}
try {
commandEncoder281.copyBufferToBuffer(buffer47, 148984, buffer38, 111900, 3132);
} catch {}
try {
commandEncoder281.clearBuffer(buffer38, 50096, 72980);
} catch {}
try {
gpuCanvasContext24.configure({
  device: device3,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm', 'rgba8unorm'],
  alphaMode: 'premultiplied',
});
} catch {}
let gpuCanvasContext35 = offscreenCanvas37.getContext('webgpu');
try {
  await promise73;
} catch {}
gc();
let imageData43 = new ImageData(84, 204);
let textureView337 = texture173.createView({label: '\u4ce2\u{1ffb3}\u8881\uf47e\u5175\u071a\u0af5\ue81a', format: 'rgba8unorm'});
let computePassEncoder147 = commandEncoder221.beginComputePass();
let sampler124 = device3.createSampler({
  label: '\ua666\u5244\u24d2\u007e\u033e',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 66.68,
  lodMaxClamp: 82.15,
  maxAnisotropy: 6,
});
let bindGroup94 = device2.createBindGroup({
  label: '\u63f6\u6c95\u{1fdf9}\u5f43',
  layout: bindGroupLayout50,
  entries: [{binding: 308, resource: sampler75}],
});
let pipelineLayout29 = device2.createPipelineLayout({
  label: '\u{1f8a5}\uaf22\u{1fb2c}\u014f\u0b47\u0288\u61d1\u{1f615}\u{1f8cf}\u6fb3\u{1f857}',
  bindGroupLayouts: [bindGroupLayout63, bindGroupLayout57, bindGroupLayout75],
});
let querySet138 = device2.createQuerySet({
  label: '\ud79f\ue0ef\ue820\u4c27\ub9a6\u{1fd2f}\u330a\u015f\u0225\u2e53',
  type: 'occlusion',
  count: 1940,
});
let computePassEncoder148 = commandEncoder229.beginComputePass({});
let externalTexture140 = device2.importExternalTexture({
  label: '\u{1f832}\u1b43\u0779\u{1fae7}\u{1f7e9}\u8040\u10c7\u8517\u0efb\u{1f847}',
  source: videoFrame15,
});
try {
computePassEncoder76.setBindGroup(2, bindGroup82);
} catch {}
try {
commandEncoder264.copyBufferToBuffer(buffer41, 7416, buffer57, 32256, 11180);
} catch {}
try {
commandEncoder265.copyTextureToBuffer({
  texture: texture181,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 8},
  aspect: 'all',
}, {
  /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 313760 */
  offset: 12148,
  bytesPerRow: 256,
  rowsPerImage: 69,
  buffer: buffer62,
}, {width: 11, height: 6, depthOrArrayLayers: 18});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture113,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 1},
  aspect: 'all',
}, new Int32Array(arrayBuffer9), /* required buffer size: 515_995 */
{offset: 351, bytesPerRow: 296, rowsPerImage: 157}, {width: 3, height: 16, depthOrArrayLayers: 12});
} catch {}
let commandEncoder288 = device6.createCommandEncoder({label: '\uec24\u24af\ue9c5'});
let renderBundleEncoder142 = device6.createRenderBundleEncoder({
  label: '\u{1facb}\ub572\uc136',
  colorFormats: ['r16sint', 'rgba16sint', 'rgb10a2uint', 'rgb10a2uint'],
  depthReadOnly: true,
});
let sampler125 = device6.createSampler({
  label: '\u34db\ua131\uc0b9\u8a4a\u2204',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 13.59,
  lodMaxClamp: 36.44,
  compare: 'greater-equal',
});
let externalTexture141 = device6.importExternalTexture({label: '\u0f2d\u1c49\u185c\u035c', source: videoFrame3});
try {
renderBundleEncoder142.setVertexBuffer(0, buffer60, 0);
} catch {}
try {
device6.queue.writeTexture({
  texture: texture179,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(368), /* required buffer size: 368 */
{offset: 368}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
gc();
try {
computePassEncoder33.dispatchWorkgroupsIndirect(buffer10, 44780);
} catch {}
try {
renderPassEncoder15.setViewport(121.0, 25.41, 179.0, 7.991, 0.3617, 0.4055);
} catch {}
try {
renderBundleEncoder50.drawIndexed(916, 139, 939, 1_095_941_249, 1_120_778_898);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer0, 31_928);
} catch {}
try {
commandEncoder244.copyTextureToTexture({
  texture: texture3,
  mipLevel: 0,
  origin: {x: 432, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture45,
  mipLevel: 0,
  origin: {x: 43, y: 0, z: 0},
  aspect: 'all',
},
{width: 458, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.submit([commandBuffer39, commandBuffer66, commandBuffer46, commandBuffer50, commandBuffer44]);
} catch {}
try {
gpuCanvasContext29.unconfigure();
} catch {}
let commandEncoder289 = device6.createCommandEncoder();
try {
commandEncoder282.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2648 */
  offset: 2648,
  buffer: buffer60,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder289.copyTextureToBuffer({
  texture: texture165,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 19288 */
  offset: 18976,
  bytesPerRow: 256,
  rowsPerImage: 146,
  buffer: buffer60,
}, {width: 28, height: 8, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder274.resolveQuerySet(querySet131, 1, 11, buffer60, 3584);
} catch {}
let bindGroup95 = device5.createBindGroup({
  label: '\u0563\ua0ca\u082b\u0ceb',
  layout: bindGroupLayout76,
  entries: [{binding: 236, resource: externalTexture121}, {binding: 463, resource: sampler119}],
});
let querySet139 = device5.createQuerySet({label: '\u04af\u048e\u6c2f\u128e\u2b4f\u8b1b', type: 'occlusion', count: 1241});
let texture184 = device5.createTexture({
  size: {width: 468, height: 1, depthOrArrayLayers: 103},
  mipLevelCount: 6,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint', 'rg8uint'],
});
let textureView338 = texture168.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 2});
let externalTexture142 = device5.importExternalTexture({label: '\u{1f869}\u25ec', source: videoFrame0, colorSpace: 'srgb'});
document.body.prepend(video0);
let bindGroupLayout79 = device1.createBindGroupLayout({
  label: '\u7cd3\u{1f863}\ub67d\u695d\u7452\u{1f94c}\u0512\u{1f9e8}',
  entries: [
    {
      binding: 361,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'float', multisampled: false },
    },
  ],
});
let commandBuffer67 = commandEncoder201.finish();
let renderBundle170 = renderBundleEncoder99.finish();
let sampler126 = device1.createSampler({
  label: '\u{1fa91}\u2d7d\u2eae\u{1f97e}\u3936\u{1fc3c}\ua65e\ua6e9',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 12.66,
  lodMaxClamp: 44.21,
});
let externalTexture143 = device1.importExternalTexture({label: '\u{1fbc5}\u{1f9e9}\u0015\u030b\u076f\ub892', source: videoFrame29, colorSpace: 'srgb'});
try {
computePassEncoder59.setBindGroup(0, bindGroup74, new Uint32Array(4756), 2962, 0);
} catch {}
try {
commandEncoder284.copyBufferToBuffer(buffer32, 98360, buffer36, 864, 21476);
} catch {}
try {
commandEncoder250.resolveQuerySet(querySet71, 546, 472, buffer63, 4864);
} catch {}
let promise77 = device1.queue.onSubmittedWorkDone();
let pipeline213 = await device1.createComputePipelineAsync({
  label: '\u7cbb\u0403\ue7b0\u79be\u{1ff42}\u7e0f\u0b95\u00c5\u01c9',
  layout: pipelineLayout24,
  compute: {module: shaderModule15, entryPoint: 'compute0', constants: {}},
});
let canvas40 = document.createElement('canvas');
let pipelineLayout30 = device0.createPipelineLayout({
  label: '\ud101\u49c3\ud9ee\u245f\ubfb5\u{1f6d8}\u{1fe2b}\u0a30\u0024\ueb88',
  bindGroupLayouts: [bindGroupLayout49, bindGroupLayout32],
});
let commandEncoder290 = device0.createCommandEncoder({label: '\u1ec4\u0545'});
let querySet140 = device0.createQuerySet({label: '\u65d4\u36a7\uc119\u8932\u{1f72f}\u0b9b\u0910\u6b06', type: 'occlusion', count: 2696});
let sampler127 = device0.createSampler({
  label: '\u0686\u{1fba9}\ub792\u{1faeb}\u0382\ufb08',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 96.19,
  lodMaxClamp: 99.08,
});
try {
renderPassEncoder12.setVertexBuffer(2, buffer53, 1_960);
} catch {}
try {
renderBundleEncoder50.draw(86, 63, 2_990_543_812, 1_293_129_146);
} catch {}
try {
buffer20.unmap();
} catch {}
let pipeline214 = device0.createComputePipeline({
  label: '\u78c6\u003c\ue194',
  layout: pipelineLayout0,
  compute: {module: shaderModule23, entryPoint: 'compute0', constants: {}},
});
gc();
let buffer65 = device2.createBuffer({
  label: '\u66b6\u{1fbf4}',
  size: 39396,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
});
let commandEncoder291 = device2.createCommandEncoder({label: '\u022e\u315b'});
let querySet141 = device2.createQuerySet({label: '\u{1fab4}\u8a13\u1341\u1055\u9d74', type: 'occlusion', count: 2703});
let textureView339 = texture159.createView({label: '\u979e\uc4aa\u0685\u0049\ub832\u092d\u6e0f', dimension: '2d', format: 'bgra8unorm-srgb'});
try {
renderBundleEncoder100.setBindGroup(3, bindGroup50, new Uint32Array(7241), 4763, 0);
} catch {}
try {
renderBundleEncoder138.setPipeline(pipeline168);
} catch {}
try {
device2.pushErrorScope('out-of-memory');
} catch {}
let pipeline215 = device2.createRenderPipeline({
  label: '\u68d8\u{1ff6b}\u6195\u59c5\u{1f96f}\u1a5b\udca6\u8986\uc894\u3c96',
  layout: pipelineLayout12,
  fragment: {
  module: shaderModule42,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'r8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'r8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one-minus-constant'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rgba8sint', writeMask: 0}],
},
  depthStencil: {
    format: 'stencil8',
    depthCompare: 'always',
    stencilFront: {compare: 'greater-equal', failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'invert'},
    stencilBack: {compare: 'never', failOp: 'decrement-clamp', depthFailOp: 'increment-clamp', passOp: 'replace'},
    stencilReadMask: 1127346927,
    stencilWriteMask: 3262746073,
  },
  vertex: {
    module: shaderModule42,
    buffers: [
      {
        arrayStride: 1360,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x2', offset: 492, shaderLocation: 3},
          {format: 'float32x4', offset: 68, shaderLocation: 10},
          {format: 'snorm16x2', offset: 0, shaderLocation: 14},
          {format: 'float32x3', offset: 248, shaderLocation: 2},
          {format: 'uint8x4', offset: 308, shaderLocation: 8},
          {format: 'float16x4', offset: 268, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 96,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x2', offset: 16, shaderLocation: 5}],
      },
      {arrayStride: 132, stepMode: 'instance', attributes: []},
      {
        arrayStride: 140,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 16, shaderLocation: 0},
          {format: 'float16x4', offset: 12, shaderLocation: 1},
          {format: 'snorm16x2', offset: 4, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 904,
        stepMode: 'instance',
        attributes: [{format: 'sint16x2', offset: 40, shaderLocation: 4}],
      },
      {arrayStride: 492, attributes: [{format: 'unorm8x4', offset: 128, shaderLocation: 15}]},
      {arrayStride: 464, stepMode: 'instance', attributes: []},
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 20, shaderLocation: 11},
          {format: 'uint32', offset: 12, shaderLocation: 7},
          {format: 'sint32x4', offset: 0, shaderLocation: 12},
          {format: 'float32', offset: 4, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'cw', unclippedDepth: false},
});
document.body.prepend(img18);
let texture185 = device5.createTexture({
  label: '\ue4be\ub735\u81c3\u{1f76b}\u0573\u7cb5\u90d2',
  size: {width: 320, height: 960, depthOrArrayLayers: 1},
  mipLevelCount: 10,
  format: 'r8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r8unorm', 'r8unorm'],
});
let textureView340 = texture162.createView({
  label: '\ucf47\u{1f7e3}\u{1f6e7}\u{1f8fa}\u4cfb\u3b0a\u68b9\ubc02\u67f9\u3582',
  baseMipLevel: 2,
  mipLevelCount: 2,
});
let renderBundleEncoder143 = device5.createRenderBundleEncoder({
  label: '\u9e59\u00b1\u0e6e\u069f\u9634',
  colorFormats: ['rg16uint', 'rgba32float', 'r32sint', 'r8unorm', 'rg8uint'],
  depthReadOnly: true,
});
let sampler128 = device5.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 36.31,
  lodMaxClamp: 41.79,
});
try {
device5.queue.writeTexture({
  texture: texture184,
  mipLevel: 5,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(44_622), /* required buffer size: 44_622 */
{offset: 501, bytesPerRow: 191, rowsPerImage: 231}, {width: 1, height: 0, depthOrArrayLayers: 2});
} catch {}
let imageData44 = new ImageData(248, 232);
let bindGroupLayout80 = device2.createBindGroupLayout({
  label: '\uf2e9\u0dc1\ud36f\ub803\u0ec9\u48d0\u6d03\u{1f720}\u03c6\u0f35\u642b',
  entries: [
    {
      binding: 718,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false },
    },
    {
      binding: 319,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let commandEncoder292 = device2.createCommandEncoder();
let externalTexture144 = device2.importExternalTexture({
  label: '\ua6f9\u{1fba4}\ud396\u03e9\u3bfd\u2250\uc181\u09dd\u{1f830}\u93b5',
  source: video19,
  colorSpace: 'srgb',
});
try {
computePassEncoder80.setBindGroup(0, bindGroup79);
} catch {}
try {
renderBundleEncoder69.setBindGroup(0, bindGroup82);
} catch {}
try {
renderBundleEncoder76.setVertexBuffer(6, buffer43, 2_728, 52);
} catch {}
let arrayBuffer21 = buffer22.getMappedRange(202352, 10180);
let bindGroup96 = device2.createBindGroup({
  label: '\uf0d7\ub1ab\u{1fa01}\uad33\u433f\u595e\ueb40',
  layout: bindGroupLayout47,
  entries: [{binding: 84, resource: sampler80}, {binding: 953, resource: sampler113}],
});
let commandEncoder293 = device2.createCommandEncoder({label: '\u01f6\u04df'});
let textureView341 = texture86.createView({label: '\u7a7a\u516c\u6a1f\u02ff\u01e6\u49d0\u3295', mipLevelCount: 1});
let externalTexture145 = device2.importExternalTexture({label: '\u77f9\u0b83\uf1b1', source: video10});
try {
renderBundleEncoder74.setPipeline(pipeline133);
} catch {}
try {
commandEncoder242.copyTextureToTexture({
  texture: texture93,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture180,
  mipLevel: 2,
  origin: {x: 13, y: 17, z: 0},
  aspect: 'all',
},
{width: 4, height: 1, depthOrArrayLayers: 1});
} catch {}
canvas11.width = 2795;
let querySet142 = device4.createQuerySet({label: '\u{1f7f1}\u40f2\u0d60\u875a\ub3bc\u5502\u66fb\u{1fd02}', type: 'occlusion', count: 1940});
try {
renderBundleEncoder127.setBindGroup(2, bindGroup85);
} catch {}
try {
renderBundleEncoder129.setVertexBuffer(7, buffer56, 0, 112_085);
} catch {}
try {
commandEncoder249.resolveQuerySet(querySet115, 1282, 160, buffer56, 7936);
} catch {}
let pipeline216 = await device4.createComputePipelineAsync({layout: pipelineLayout26, compute: {module: shaderModule50, entryPoint: 'compute0', constants: {}}});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let bindGroup97 = device1.createBindGroup({label: '\u2d70\ua308\u0645\u0886\u2b43\u0179', layout: bindGroupLayout60, entries: []});
let commandEncoder294 = device1.createCommandEncoder({label: '\u0d61\u{1fa20}\u0392\ub518'});
let renderBundleEncoder144 = device1.createRenderBundleEncoder({
  label: '\ueb7d\u02b0\u01d8',
  colorFormats: ['rg16uint', 'r32uint', 'r8unorm', undefined, 'rg8sint'],
  stencilReadOnly: true,
});
try {
renderBundleEncoder34.draw(6, 0, 0, 9);
} catch {}
try {
commandEncoder115.copyBufferToTexture({
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 260 */
  offset: 260,
  bytesPerRow: 256,
  buffer: buffer36,
}, {
  texture: texture142,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 15, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder107.insertDebugMarker('\u80bb');
} catch {}
try {
device1.queue.writeBuffer(buffer59, 22552, new Float32Array(42333), 35918, 1328);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture156,
  mipLevel: 2,
  origin: {x: 10, y: 1, z: 0},
  aspect: 'all',
}, new ArrayBuffer(677), /* required buffer size: 677 */
{offset: 677, bytesPerRow: 376}, {width: 55, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData14,
  origin: { x: 27, y: 4 },
  flipY: true,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline217 = device1.createComputePipeline({layout: pipelineLayout19, compute: {module: shaderModule26, entryPoint: 'compute0', constants: {}}});
let renderBundleEncoder145 = device6.createRenderBundleEncoder({
  label: '\u0e8e\uf13d\uea29\uc2d5\u{1f9f6}\u922e\u{1fe59}\u086a\u8c5f',
  colorFormats: ['r16sint', 'rgba16sint', 'rgb10a2uint', 'rgb10a2uint'],
  depthReadOnly: true,
});
let renderBundle171 = renderBundleEncoder134.finish({});
try {
commandEncoder282.clearBuffer(buffer60, 182880, 7080);
} catch {}
try {
commandEncoder289.resolveQuerySet(querySet131, 1, 4, buffer60, 8448);
} catch {}
try {
commandEncoder282.pushDebugGroup('\ua57c');
} catch {}
try {
gpuCanvasContext35.configure({
  device: device6,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
gc();
let texture186 = device3.createTexture({
  label: '\u{1fba9}\u011b\u51ec\u0621\ub01d',
  size: {width: 378, height: 4, depthOrArrayLayers: 1},
  mipLevelCount: 8,
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder146 = device3.createRenderBundleEncoder({
  label: '\u{1ffa0}\u1ac9',
  colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'],
  depthReadOnly: true,
});
try {
commandEncoder237.copyBufferToBuffer(buffer47, 148536, buffer46, 502224, 34080);
} catch {}
try {
device3.queue.submit([]);
} catch {}
video40.height = 143;
let pipelineLayout31 = device0.createPipelineLayout({label: '\u5700\ub4b2\uf7fd\u7627', bindGroupLayouts: []});
let commandEncoder295 = device0.createCommandEncoder({label: '\u6c8e\u1446\u014c\u2ff4\ua6de\u0b4b\ub5c2\u6afa\u0fde\u104a'});
let commandBuffer68 = commandEncoder173.finish();
let texture187 = device0.createTexture({
  label: '\u3aa9\u0a8e\u1ebb\u036c\u{1ff95}\u77b2',
  size: {width: 330, height: 240, depthOrArrayLayers: 124},
  mipLevelCount: 7,
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['r16float', 'r16float'],
});
try {
computePassEncoder90.dispatchWorkgroupsIndirect(buffer35, 21552);
} catch {}
try {
computePassEncoder131.setPipeline(pipeline29);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(2, buffer6);
} catch {}
try {
commandEncoder87.copyTextureToTexture({
  texture: texture71,
  mipLevel: 0,
  origin: {x: 391, y: 9, z: 25},
  aspect: 'all',
},
{
  texture: texture101,
  mipLevel: 1,
  origin: {x: 5, y: 0, z: 56},
  aspect: 'all',
},
{width: 148, height: 114, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder268.clearBuffer(buffer44, 9408, 5788);
} catch {}
try {
commandEncoder230.resolveQuerySet(querySet13, 42, 441, buffer0, 48896);
} catch {}
let pipeline218 = await device0.createComputePipelineAsync({
  label: '\u2006\ucef9\u0ac2\u{1fdd0}\u{1fbff}\uc5b7\u0681\u{1ffc7}\ub48a\u{1fd9f}\u0e47',
  layout: pipelineLayout4,
  compute: {module: shaderModule43, entryPoint: 'compute0', constants: {}},
});
let pipeline219 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'rg16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'constant'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, undefined, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'src'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one-minus-constant'},
  },
  writeMask: 0,
}, {format: 'rg16float'}, {format: 'rgba16uint'}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 228, stepMode: 'instance', attributes: []},
      {arrayStride: 24, attributes: []},
      {arrayStride: 48, stepMode: 'instance', attributes: []},
      {arrayStride: 40, stepMode: 'instance', attributes: []},
      {arrayStride: 100, stepMode: 'vertex', attributes: []},
      {arrayStride: 44, attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 520,
        attributes: [
          {format: 'sint32x2', offset: 512, shaderLocation: 7},
          {format: 'float32x2', offset: 144, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'back'},
});
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let querySet143 = device4.createQuerySet({
  label: '\u0e02\uc157\uf4b1\u{1f8d1}\u{1fdc2}\u{1fbc3}\u27de\ude31\ue38f\ude51\u04c6',
  type: 'occlusion',
  count: 3453,
});
let texture188 = device4.createTexture({
  label: '\u97c6\uc411\u0150\uaff9\u937c\u41f5\uc26d\u6c31\ue2c3',
  size: [328, 6, 1],
  mipLevelCount: 7,
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg8sint', 'rg8sint', 'rg8sint'],
});
let renderBundleEncoder147 = device4.createRenderBundleEncoder({
  label: '\u9fe0\u46ba\u06a7\u082e\u8348\u3f95\u9fce',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder125.setPipeline(pipeline154);
} catch {}
try {
commandEncoder249.copyBufferToBuffer(buffer48, 44964, buffer56, 404728, 27184);
} catch {}
try {
commandEncoder247.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 16220 */
  offset: 16220,
  buffer: buffer48,
}, {
  texture: texture129,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device4.queue.writeBuffer(buffer54, 13584, new Float32Array(56641), 46757, 1552);
} catch {}
try {
device4.queue.writeTexture({
  texture: texture124,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(48), /* required buffer size: 241 */
{offset: 241}, {width: 125, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await promise77;
} catch {}
let canvas41 = document.createElement('canvas');
try {
canvas41.getContext('webgl');
} catch {}
let texture189 = gpuCanvasContext23.getCurrentTexture();
let computePassEncoder149 = commandEncoder274.beginComputePass({label: '\u25d3\uadb9\u2c77\u035a\u77be\udcd1\ufb58\u{1fa75}\u168f\u{1f6f0}\u{1f8a2}'});
let sampler129 = device6.createSampler({
  label: '\u0617\ua644\u9bd4\u019a\uf020\ua205\u{1f7fa}\u0860',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  lodMinClamp: 92.80,
  lodMaxClamp: 99.61,
  compare: 'less',
});
try {
commandEncoder282.popDebugGroup();
} catch {}
let texture190 = device2.createTexture({
  label: '\u1218\u05b4',
  size: {width: 30, height: 3, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm'],
});
let renderBundle172 = renderBundleEncoder90.finish();
let externalTexture146 = device2.importExternalTexture({
  label: '\u{1fc5d}\u3d03\ub73a\u0d7d\ue760\u06bb\u{1fb49}\u07eb\u0757',
  source: videoFrame3,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder109.setBindGroup(0, bindGroup96);
} catch {}
try {
commandEncoder293.copyBufferToBuffer(buffer61, 28776, buffer57, 80188, 2504);
} catch {}
try {
commandEncoder261.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 13648 */
  offset: 13648,
  bytesPerRow: 0,
  rowsPerImage: 231,
  buffer: buffer33,
}, {
  texture: texture79,
  mipLevel: 0,
  origin: {x: 48, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 12, depthOrArrayLayers: 27});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(arrayBuffer6), /* required buffer size: 191 */
{offset: 191}, {width: 32, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 22, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame30,
  origin: { x: 1, y: 0 },
  flipY: true,
}, {
  texture: texture93,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView342 = texture140.createView({label: '\uf3b9\ub20a', baseMipLevel: 1, mipLevelCount: 3, baseArrayLayer: 94, arrayLayerCount: 5});
try {
computePassEncoder133.setBindGroup(3, bindGroup49, new Uint32Array(8736), 1147, 0);
} catch {}
try {
buffer23.destroy();
} catch {}
try {
  await buffer62.mapAsync(GPUMapMode.READ, 0, 289772);
} catch {}
try {
commandEncoder255.resolveQuerySet(querySet66, 4, 533, buffer65, 1536);
} catch {}
try {
renderBundleEncoder74.insertDebugMarker('\u3d1e');
} catch {}
let promise78 = device2.queue.onSubmittedWorkDone();
let pipeline220 = await device2.createRenderPipelineAsync({
  label: '\u{1f6c1}\u5f26\u5e07\u8354\u4e3b\u{1fe05}\ubcff\u03a4\u{1f7ee}\ue117\u{1fd89}',
  layout: pipelineLayout14,
  fragment: {
  module: shaderModule40,
  entryPoint: 'fragment0',
  targets: [{
  format: 'bgra8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8unorm'}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'add', srcFactor: 'one', dstFactor: 'dst-alpha'},
    alpha: {operation: 'add', srcFactor: 'src', dstFactor: 'src-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'one-minus-src'},
    alpha: {operation: 'add', srcFactor: 'one-minus-src', dstFactor: 'src-alpha-saturated'},
  },
}, {format: 'r8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALL,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'greater', failOp: 'decrement-wrap', depthFailOp: 'decrement-wrap', passOp: 'invert'},
    stencilBack: {compare: 'greater', failOp: 'decrement-clamp', depthFailOp: 'zero', passOp: 'replace'},
    stencilReadMask: 3878927097,
    stencilWriteMask: 1895366387,
    depthBias: 609995441,
    depthBiasSlopeScale: -32.897808734289185,
  },
  vertex: {
    module: shaderModule40,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 880,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 0, shaderLocation: 12}],
      },
      {arrayStride: 756, stepMode: 'instance', attributes: []},
      {arrayStride: 560, attributes: []},
      {arrayStride: 676, attributes: []},
      {arrayStride: 0, attributes: [{format: 'sint16x2', offset: 152, shaderLocation: 2}]},
      {
        arrayStride: 44,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 0, shaderLocation: 13},
          {format: 'sint32', offset: 4, shaderLocation: 6},
          {format: 'uint32x2', offset: 0, shaderLocation: 10},
          {format: 'sint32', offset: 0, shaderLocation: 3},
        ],
      },
      {
        arrayStride: 68,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x2', offset: 4, shaderLocation: 5}],
      },
      {
        arrayStride: 528,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 180, shaderLocation: 11},
          {format: 'float16x2', offset: 164, shaderLocation: 9},
          {format: 'sint8x2', offset: 146, shaderLocation: 0},
          {format: 'uint32', offset: 48, shaderLocation: 14},
          {format: 'sint16x2', offset: 24, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw'},
});
let gpuCanvasContext36 = canvas40.getContext('webgpu');
offscreenCanvas27.height = 1628;
let textureView343 = texture149.createView({label: '\u5ee7\ud211', dimension: '1d', aspect: 'all'});
let sampler130 = device0.createSampler({
  label: '\u{1fab5}\u1e41\u{1fc84}\u1515\u892f\ub8a0\uc82a\u{1fa8f}',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 30.65,
  lodMaxClamp: 36.97,
});
try {
computePassEncoder65.setBindGroup(1, bindGroup7);
} catch {}
try {
computePassEncoder96.setPipeline(pipeline104);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle117, renderBundle147, renderBundle117, renderBundle73, renderBundle107, renderBundle73, renderBundle149, renderBundle107, renderBundle117, renderBundle117]);
} catch {}
try {
renderPassEncoder6.setStencilReference(3144);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(buffer3, 'uint16', 14_958, 13_391);
} catch {}
try {
renderBundleEncoder89.setPipeline(pipeline19);
} catch {}
try {
commandEncoder175.copyTextureToBuffer({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 71, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2070 widthInBlocks: 1035 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 35158 */
  offset: 35158,
  bytesPerRow: 2304,
  buffer: buffer2,
}, {width: 1035, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext17.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let commandBuffer69 = commandEncoder282.finish({label: '\u{1fb08}\u{1f8a8}\u0216\u3b87\u032d\u992c\u{1f98e}\u{1fb39}\u{1fde6}\u0cd1\u9adc'});
let texture191 = device6.createTexture({
  label: '\u{1f724}\u8e0a\u00c2\u7832\u2f1c\uc1b8\u6b61\u7914',
  size: [93, 1, 607],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rgba16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
commandEncoder288.clearBuffer(buffer60, 162484, 23220);
} catch {}
let pipelineLayout32 = device0.createPipelineLayout({label: '\u44ef\u{1fd0d}\ubc01\u{1fea7}', bindGroupLayouts: [bindGroupLayout36]});
let commandEncoder296 = device0.createCommandEncoder({});
let textureView344 = texture83.createView({
  label: '\u07fb\uebfa\ud778\u3e62\u0ed6\u01a6\u{1f81e}\uf8b5',
  mipLevelCount: 1,
  baseArrayLayer: 38,
  arrayLayerCount: 16,
});
let sampler131 = device0.createSampler({
  label: '\u0cfa\u0e85\ufd4a\u{1fb06}\u8275\u4843\u2904\ud035\u0a0c\u3c2a\ua75d',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 47.55,
  lodMaxClamp: 60.67,
  maxAnisotropy: 20,
});
try {
computePassEncoder134.setBindGroup(2, bindGroup24);
} catch {}
try {
renderPassEncoder14.setScissorRect(186, 207, 20, 23);
} catch {}
try {
renderPassEncoder14.setViewport(603.2, 210.1, 48.32, 4.067, 0.8769, 0.9303);
} catch {}
try {
renderBundleEncoder50.draw(30, 104, 438_335_632, 46_391_105);
} catch {}
try {
renderBundleEncoder56.drawIndirect(buffer11, 318_384);
} catch {}
try {
commandEncoder84.copyBufferToBuffer(buffer1, 61240, buffer14, 34868, 364);
} catch {}
try {
device0.queue.writeBuffer(buffer7, 10264, new Float32Array(12458));
} catch {}
let pipeline221 = device0.createComputePipeline({
  label: '\u8ea7\u0a3c\u0262\u05a9\u61ae\u014e',
  layout: pipelineLayout1,
  compute: {module: shaderModule22, entryPoint: 'compute0', constants: {}},
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let textureView345 = texture177.createView({});
let externalTexture147 = device5.importExternalTexture({label: '\ua905\uf101\u0487', source: videoFrame0, colorSpace: 'display-p3'});
try {
renderBundleEncoder143.setBindGroup(1, bindGroup95, new Uint32Array(7385), 1456, 0);
} catch {}
let canvas42 = document.createElement('canvas');
let commandEncoder297 = device3.createCommandEncoder({label: '\u{1fe48}\u6a3b\ud5b1\u8d69\u{1fe57}\u4f93\u97c9\u{1fcec}'});
let renderBundleEncoder148 = device3.createRenderBundleEncoder({
  label: '\u{1f683}\u07ef\ua7d2\u06db\u{1f8f3}\u054c\u{1fc3c}\u8ba6\u8f8d',
  colorFormats: ['rgba32sint', 'rg32uint', 'rg16sint', 'r32uint'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder118.setVertexBuffer(5, buffer47, 60_052, 37_922);
} catch {}
let gpuCanvasContext37 = canvas42.getContext('webgpu');
let video46 = await videoWithData();
let querySet144 = device1.createQuerySet({
  label: '\u{1f8f1}\u{1f657}\u91cf\u{1fc2f}\u0af2\ubee4\ucb22\u05f6\u4b2e\u078e\u{1fdbb}',
  type: 'occlusion',
  count: 2702,
});
let textureView346 = texture56.createView({mipLevelCount: 1, baseArrayLayer: 115, arrayLayerCount: 6});
let pipeline222 = device1.createComputePipeline({
  label: '\u49db\ueb96\ud6ce',
  layout: pipelineLayout24,
  compute: {module: shaderModule24, entryPoint: 'compute0', constants: {}},
});
document.body.prepend(video20);
let textureView347 = texture191.createView({label: '\u0f90\u5e73\u08c5\u054f', mipLevelCount: 1});
let computePassEncoder150 = commandEncoder266.beginComputePass({});
let renderBundleEncoder149 = device6.createRenderBundleEncoder({
  label: '\ua105\u0119\u{1fb62}\u229c\u0c99\u75db\ucc53\u0ddf\u5456',
  colorFormats: ['r16sint', 'rgba16sint', 'rgb10a2uint', 'rgb10a2uint'],
  depthReadOnly: true,
});
try {
renderBundleEncoder142.setVertexBuffer(7, buffer60, 1_896);
} catch {}
try {
commandEncoder289.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 16 */
  offset: 16,
  rowsPerImage: 173,
  buffer: buffer60,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder288.copyTextureToBuffer({
  texture: texture179,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 528 widthInBlocks: 132 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5412 */
  offset: 5412,
  buffer: buffer60,
}, {width: 132, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder288.copyTextureToTexture({
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder288.clearBuffer(buffer60, 97336, 29040);
} catch {}
try {
gpuCanvasContext25.unconfigure();
} catch {}
let querySet145 = device4.createQuerySet({label: '\u{1f664}\u6053\u4bad\ub7d9\u05e2\u{1fefa}\u0e41\u0812', type: 'occlusion', count: 681});
let texture192 = device4.createTexture({size: [164, 3, 1], mipLevelCount: 2, format: 'rgba8sint', usage: GPUTextureUsage.COPY_SRC});
let computePassEncoder151 = commandEncoder249.beginComputePass();
try {
device4.addEventListener('uncapturederror', e => { log('device4.uncapturederror'); log(e); e.label = device4.label; });
} catch {}
try {
commandEncoder256.copyBufferToTexture({
  /* bytesInLastRow: 296 widthInBlocks: 148 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2976 */
  offset: 2168,
  bytesPerRow: 512,
  buffer: buffer48,
}, {
  texture: texture127,
  mipLevel: 1,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
}, {width: 148, height: 2, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder247.resolveQuerySet(querySet102, 747, 16, buffer56, 310016);
} catch {}
try {
commandEncoder256.insertDebugMarker('\u{1fbf5}');
} catch {}
let pipeline223 = device4.createComputePipeline({
  label: '\u0ff8\u0ec3',
  layout: pipelineLayout26,
  compute: {module: shaderModule47, entryPoint: 'compute0', constants: {}},
});
offscreenCanvas1.height = 660;
let promise79 = adapter7.requestDevice({
  label: '\u482d\u43f3\u07ec',
  defaultQueue: {},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxTextureArrayLayers: 256,
    maxVertexBuffers: 8,
    maxUniformBufferBindingSize: 106981768,
    maxStorageBufferBindingSize: 165480574,
  },
});
let imageBitmap29 = await createImageBitmap(video26);
let texture193 = device6.createTexture({
  label: '\u6cd9\u{1ffce}\u{1fe7b}\u{1ff1e}\u{1fae5}\u0bca\u48fe\u0649\u4302',
  size: {width: 40, height: 10, depthOrArrayLayers: 1},
  mipLevelCount: 4,
  format: 'r16sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
try {
buffer60.unmap();
} catch {}
let videoFrame32 = new VideoFrame(canvas7, {timestamp: 0});
try {
window.someLabel = externalTexture142.label;
} catch {}
let texture194 = device5.createTexture({
  label: '\u10a8\ua640\u46cd\u1858\u00cf\u0528\u{1fda7}\u37ec',
  size: [160, 480, 54],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'],
});
let textureView348 = texture177.createView({label: '\u3796\u037e\u8252\u304b\uf17f\u0149\u05fd', format: 'rg16uint'});
let sampler132 = device5.createSampler({
  label: '\ucc77\u3e0c\u976c\u03ac',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 10.54,
  lodMaxClamp: 57.92,
});
let commandEncoder298 = device6.createCommandEncoder({label: '\u014b\u{1fba9}\u7325\u{1f883}\u{1f6a8}\uf1d9'});
let querySet146 = device6.createQuerySet({
  label: '\ud54d\u{1fae9}\u5bf7\u8910\u708a\u4a28\u0ec8\u009a\u9443\u262f',
  type: 'occlusion',
  count: 715,
});
let textureView349 = texture179.createView({label: '\u2925\u062f\u054e\u331e\u2159\u0522\u371e', format: 'rgb10a2uint', mipLevelCount: 1});
let externalTexture148 = device6.importExternalTexture({label: '\u04cf\u9e42\u2ed3\u{1fb9e}\u0b14\u8ead', source: video1, colorSpace: 'display-p3'});
try {
renderBundleEncoder142.setVertexBuffer(5, buffer60);
} catch {}
try {
device6.queue.writeTexture({
  texture: texture191,
  mipLevel: 1,
  origin: {x: 38, y: 0, z: 6},
  aspect: 'all',
}, new Uint16Array(arrayBuffer20), /* required buffer size: 9_041_352 */
{offset: 395, bytesPerRow: 273, rowsPerImage: 133}, {width: 2, height: 1, depthOrArrayLayers: 250});
} catch {}
let bindGroupLayout81 = device4.createBindGroupLayout({
  entries: [
    {binding: 198, visibility: 0, externalTexture: {}},
    {binding: 329, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {
      binding: 360,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let commandBuffer70 = commandEncoder247.finish();
let textureView350 = texture124.createView({aspect: 'all', baseArrayLayer: 0});
let renderBundle173 = renderBundleEncoder97.finish();
try {
computePassEncoder129.setPipeline(pipeline151);
} catch {}
try {
renderBundleEncoder93.setPipeline(pipeline170);
} catch {}
try {
commandEncoder267.copyTextureToTexture({
  texture: texture188,
  mipLevel: 6,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture188,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline224 = await device4.createComputePipelineAsync({
  label: '\u{1fc70}\u{1fc13}\ua455\u3904\ue59d\u056a\u03b0',
  layout: pipelineLayout26,
  compute: {module: shaderModule35, entryPoint: 'compute0'},
});
let pipeline225 = device4.createRenderPipeline({
  label: '\u8992\u0736\u0d98\u{1faa9}\ue424\u0e4d\u1c63',
  layout: pipelineLayout26,
  fragment: {
  module: shaderModule35,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint'}, {format: 'rgba8sint', writeMask: 0}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'src-alpha-saturated'},
  },
}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'src-alpha'},
  },
  writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rg8unorm'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {failOp: 'decrement-wrap', depthFailOp: 'decrement-wrap', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'less', failOp: 'increment-wrap', passOp: 'zero'},
    stencilReadMask: 1399132780,
    depthBias: -1796772499,
    depthBiasSlopeScale: 65.70017537339828,
    depthBiasClamp: 158.79318031784078,
  },
  vertex: {module: shaderModule35, entryPoint: 'vertex0', buffers: []},
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'ccw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
let imageData45 = new ImageData(252, 168);
let shaderModule51 = device5.createShaderModule({
  label: '\u096d\ue6bb\u{1f8b5}\u6072\u46e6',
  code: `@group(2) @binding(932)
var<storage, read_write> parameter19: array<u32>;
@group(1) @binding(932)
var<storage, read_write> local16: array<u32>;
@group(3) @binding(932)
var<storage, read_write> function19: array<u32>;

@compute @workgroup_size(2, 3, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(2) f0: i32,
  @location(4) f1: vec4<u32>,
  @location(0) f2: vec2<u32>,
  @location(3) f3: f32,
  @location(1) f4: vec4<f32>
}

@fragment
fn fragment0(@location(9) a0: f16, @location(6) a1: f16, @location(3) a2: vec4<f32>, @location(12) a3: f32, @builtin(position) a4: vec4<f32>, @location(14) a5: vec4<f16>, @location(2) a6: vec3<i32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S42 {
  @location(4) f0: vec2<u32>,
  @location(9) f1: vec2<f32>,
  @location(13) f2: vec3<f16>,
  @builtin(instance_index) f3: u32,
  @location(0) f4: i32,
  @location(7) f5: vec3<i32>,
  @location(14) f6: vec2<i32>,
  @location(12) f7: vec2<f16>,
  @location(15) f8: vec2<u32>,
  @location(6) f9: vec2<f32>
}
struct VertexOutput0 {
  @location(12) f245: f32,
  @location(0) f246: vec2<f16>,
  @location(5) f247: vec3<f16>,
  @location(9) f248: f16,
  @location(6) f249: f16,
  @location(11) f250: u32,
  @location(10) f251: vec4<f16>,
  @builtin(position) f252: vec4<f32>,
  @location(7) f253: vec3<u32>,
  @location(13) f254: vec2<f16>,
  @location(2) f255: vec3<i32>,
  @location(14) f256: vec4<f16>,
  @location(3) f257: vec4<f32>,
  @location(4) f258: vec2<u32>,
  @location(8) f259: vec3<u32>,
  @location(15) f260: vec3<f16>
}

@vertex
fn vertex0(@location(8) a0: vec3<f32>, @location(5) a1: vec4<f32>, @location(2) a2: vec4<f16>, a3: S42, @location(10) a4: vec4<f16>, @location(11) a5: vec2<f32>, @location(3) a6: f16, @location(1) a7: vec2<f32>, @builtin(vertex_index) a8: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  hints: {},
});
let bindGroupLayout82 = device5.createBindGroupLayout({
  label: '\u30b6\u8606\uc171\u50ff\u{1fa96}\u{1f713}\uc712\u{1fce2}\u0433',
  entries: [
    {
      binding: 38,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
    {binding: 752, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let commandEncoder299 = device5.createCommandEncoder();
let textureView351 = texture194.createView({baseMipLevel: 1, mipLevelCount: 1});
let computePassEncoder152 = commandEncoder299.beginComputePass({label: '\u{1feee}\u{1f7c8}\u0d8d'});
try {
computePassEncoder145.setBindGroup(3, bindGroup95, new Uint32Array(5508), 3123, 0);
} catch {}
try {
renderBundleEncoder143.setBindGroup(1, bindGroup95);
} catch {}
try {
renderBundleEncoder143.setBindGroup(2, bindGroup95, new Uint32Array(868), 425, 0);
} catch {}
try {
computePassEncoder135.pushDebugGroup('\uea6f');
} catch {}
try {
device5.queue.writeTexture({
  texture: texture169,
  mipLevel: 0,
  origin: {x: 35, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(2_660), /* required buffer size: 2_660 */
{offset: 172, rowsPerImage: 52}, {width: 622, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline226 = device5.createRenderPipeline({
  label: '\u32e5\uc121\u0208',
  layout: pipelineLayout22,
  fragment: {
  module: shaderModule51,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16uint'}, {format: 'rgba32float'}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'r8unorm', writeMask: GPUColorWrite.ALPHA}, {format: 'rg8uint', writeMask: 0}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'never',
    stencilFront: {compare: 'equal', failOp: 'increment-wrap', depthFailOp: 'replace'},
    stencilBack: {compare: 'equal', failOp: 'increment-wrap', depthFailOp: 'increment-clamp', passOp: 'zero'},
    stencilReadMask: 1686375355,
    stencilWriteMask: 2783365476,
  },
  vertex: {
    module: shaderModule51,
    buffers: [
      {arrayStride: 60, stepMode: 'vertex', attributes: []},
      {arrayStride: 264, stepMode: 'instance', attributes: []},
      {
        arrayStride: 24,
        attributes: [
          {format: 'float16x2', offset: 0, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 9},
          {format: 'sint32x2', offset: 0, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 284,
        attributes: [
          {format: 'snorm8x4', offset: 36, shaderLocation: 1},
          {format: 'unorm8x4', offset: 92, shaderLocation: 5},
          {format: 'float32', offset: 88, shaderLocation: 12},
          {format: 'uint32', offset: 84, shaderLocation: 4},
          {format: 'uint32', offset: 32, shaderLocation: 15},
          {format: 'sint32x3', offset: 4, shaderLocation: 14},
          {format: 'unorm8x2', offset: 2, shaderLocation: 3},
          {format: 'float32x4', offset: 4, shaderLocation: 2},
        ],
      },
      {arrayStride: 148, attributes: []},
      {arrayStride: 372, stepMode: 'instance', attributes: []},
      {arrayStride: 204, attributes: []},
      {
        arrayStride: 84,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 11},
          {format: 'float32x3', offset: 4, shaderLocation: 13},
          {format: 'unorm8x2', offset: 62, shaderLocation: 10},
          {format: 'snorm16x4', offset: 12, shaderLocation: 8},
          {format: 'sint32x3', offset: 4, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list'},
});
let commandBuffer71 = commandEncoder286.finish({label: '\u0ced\u0f0d\u{1fc89}\u{1fddb}\uc94f\u44fb\u{1fcf9}\u7305\u4155\u0b55'});
let texture195 = gpuCanvasContext0.getCurrentTexture();
let textureView352 = texture99.createView({
  label: '\u5f41\u4f7c\u5e01\u{1f7dc}\u{1f740}\u5d26\u7f6f\u0d64\u064f',
  format: 'bgra8unorm-srgb',
  baseMipLevel: 0,
  arrayLayerCount: 1,
});
let sampler133 = device1.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 82.09,
});
try {
computePassEncoder118.setPipeline(pipeline185);
} catch {}
try {
renderBundleEncoder34.draw(1, 0, 3);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer19, 3_444);
} catch {}
try {
commandEncoder245.copyBufferToBuffer(buffer15, 5908, buffer13, 92748, 4760);
} catch {}
try {
gpuCanvasContext20.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.writeBuffer(buffer36, 10940, new DataView(new ArrayBuffer(15905)), 851, 824);
} catch {}
let pipeline227 = device1.createComputePipeline({
  label: '\u0d82\u{1fa7b}\u0d92\u{1fee2}\u8ee1\u0566\u{1f75a}\u7b67\u30ca',
  layout: pipelineLayout5,
  compute: {module: shaderModule11, entryPoint: 'compute0', constants: {}},
});
try {
gpuCanvasContext12.unconfigure();
} catch {}
let texture196 = device6.createTexture({
  label: '\u{1fc99}\u{1f755}\u6185\u{1fd88}\udefd\u{1f888}\u0397\u{1fc56}\u{1f616}\u4ce3',
  size: [40, 10, 10],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView353 = texture191.createView({
  label: '\u72ad\u0fd9\u{1f9b7}\u50c4\uc021\u062e\u7596',
  baseMipLevel: 4,
  mipLevelCount: 1,
  baseArrayLayer: 0,
});
let sampler134 = device6.createSampler({
  label: '\u0653\u{1fd82}\u4782\u178f\ucd91\u3101\uad9c\u{1f859}\u3680',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 92.16,
  lodMaxClamp: 99.60,
  maxAnisotropy: 17,
});
try {
renderBundleEncoder142.setVertexBuffer(1, buffer60, 35_192, 30_532);
} catch {}
try {
commandEncoder289.copyBufferToTexture({
  /* bytesInLastRow: 356 widthInBlocks: 89 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 1460 */
  offset: 1460,
  buffer: buffer60,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 89, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer18.detached) { new Uint8Array(arrayBuffer18).fill(0x55) };
} catch {}
try {
  await promise76;
} catch {}
let bindGroup98 = device2.createBindGroup({
  label: '\u5b09\u{1fb8a}\u0b0e\u0cf8\u{1fd76}\u6e29\u4be3\u03d2\u8525\u2447',
  layout: bindGroupLayout47,
  entries: [{binding: 84, resource: sampler100}, {binding: 953, resource: sampler75}],
});
let commandEncoder300 = device2.createCommandEncoder({label: '\u5f68\ub5ce\u8cbd\udd75\uc327\u{1fb32}\ub04a\uaef5\u9d14\u{1f842}'});
let querySet147 = device2.createQuerySet({type: 'occlusion', count: 2549});
let commandBuffer72 = commandEncoder265.finish({label: '\u{1f661}\u7565\ueb11\u{1fc2b}\u036c'});
let texture197 = device2.createTexture({
  label: '\u00ae\uc466\u0990\uc0dd\ubd31\u6d84\u{1fa3c}\u555d\u0977',
  size: [96],
  dimension: '1d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r8sint', 'r8sint', 'r8sint'],
});
let renderBundleEncoder150 = device2.createRenderBundleEncoder({
  label: '\u0403\u{1fd48}\u010e',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
});
try {
renderBundleEncoder87.setBindGroup(3, bindGroup56);
} catch {}
try {
  await buffer55.mapAsync(GPUMapMode.READ, 35752, 11792);
} catch {}
try {
device2.queue.writeBuffer(buffer33, 113560, new Int16Array(27732), 15280, 148);
} catch {}
let pipeline228 = await device2.createComputePipelineAsync({
  label: '\u5ad4\u02ec',
  layout: pipelineLayout11,
  compute: {module: shaderModule28, entryPoint: 'compute0', constants: {}},
});
let externalTexture149 = device6.importExternalTexture({
  label: '\u007a\u0600\ue5c1\u{1f84a}\u{1ff42}\u{1fb5f}\u3538\uc3a0',
  source: videoFrame31,
  colorSpace: 'srgb',
});
try {
commandEncoder298.clearBuffer(buffer60, 102628, 38284);
} catch {}
let buffer66 = device0.createBuffer({
  label: '\u082c\u84a6',
  size: 104320,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: true,
});
let querySet148 = device0.createQuerySet({label: '\u{1fd70}\u453b\u7dd4\u7c2e\u5df6\u{1f7fd}\u{1f960}', type: 'occlusion', count: 1021});
let texture198 = device0.createTexture({
  label: '\uee80\u042a',
  size: [1320, 960, 1426],
  mipLevelCount: 11,
  dimension: '3d',
  format: 'rgb10a2unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgb10a2unorm', 'rgb10a2unorm'],
});
let textureView354 = texture72.createView({label: '\ueced\u0c4d\u0c49\u5484'});
let renderPassEncoder18 = commandEncoder253.beginRenderPass({
  label: '\u012f\ua58c\u1f58\u0296\u{1fc4d}\u7ad8\u0eb4\u{1f855}\u06d0\u{1f9d4}\u{1f8c0}',
  colorAttachments: [{
  view: textureView227,
  clearValue: { r: 978.9, g: 609.4, b: -147.4, a: 968.9, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet62,
  maxDrawCount: 218897738,
});
let sampler135 = device0.createSampler({
  label: '\u61c8\u{1fd3b}\u774c\u3f0e\u0bc9',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 69.02,
  lodMaxClamp: 87.20,
});
try {
computePassEncoder58.dispatchWorkgroupsIndirect(buffer11, 266836);
} catch {}
try {
renderPassEncoder13.setScissorRect(66, 23, 37, 26);
} catch {}
try {
renderPassEncoder12.setStencilReference(1567);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(5, buffer4, 31_068, 97_863);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer0, 6_300);
} catch {}
try {
renderPassEncoder13.insertDebugMarker('\u0c30');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture157,
  mipLevel: 6,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer17, /* required buffer size: 518 */
{offset: 518}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
gc();
let imageData46 = new ImageData(136, 108);
let buffer67 = device6.createBuffer({label: '\u9cd3\ubc11\u27f8\u09f1\u0deb\u10f5\u2f3e', size: 94217, usage: GPUBufferUsage.MAP_WRITE});
let textureView355 = texture189.createView({label: '\u788f\u{1ff63}\u{1feb0}\u{1f697}'});
let computePassEncoder153 = commandEncoder289.beginComputePass({label: '\u{1fd7a}\u45e6\u07b1\u7e02\u{1fb13}\u02d5'});
try {
computePassEncoder153.end();
} catch {}
try {
buffer67.destroy();
} catch {}
try {
commandEncoder289.copyTextureToBuffer({
  texture: texture165,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 96 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 5960 */
  offset: 5960,
  bytesPerRow: 256,
  buffer: buffer60,
}, {width: 48, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder288.copyTextureToTexture({
  texture: texture179,
  mipLevel: 0,
  origin: {x: 95, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture196,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device6.queue.writeTexture({
  texture: texture179,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(arrayBuffer7), /* required buffer size: 889 */
{offset: 889, bytesPerRow: 412}, {width: 94, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap30 = await createImageBitmap(videoFrame4);
let textureView356 = texture63.createView({dimension: '2d-array', aspect: 'depth-only', baseMipLevel: 2});
let renderBundleEncoder151 = device1.createRenderBundleEncoder({
  label: '\u0593\u{1f73e}\u07c7\ub47e\u{1f979}\u2299\u{1fcd0}\u{1fa2f}\ued97',
  colorFormats: ['rgba8sint', 'rg16uint', 'rg32sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle174 = renderBundleEncoder32.finish({});
try {
computePassEncoder132.setBindGroup(2, bindGroup30);
} catch {}
try {
computePassEncoder81.setBindGroup(0, bindGroup80, new Uint32Array(8296), 3142, 0);
} catch {}
try {
renderBundleEncoder34.drawIndexed(4_268, 117, 1_744, 367_409_313, 1_000_933_754);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer15, 1_216);
} catch {}
try {
commandEncoder156.copyTextureToBuffer({
  texture: texture42,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
}, {
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 8248 */
  offset: 8248,
  bytesPerRow: 256,
  buffer: buffer59,
}, {width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let textureView357 = texture193.createView({
  label: '\u0ccb\ue6ab\u0a72\u0765\u305e\u0ae9\u0275\u04c2',
  dimension: '2d-array',
  baseMipLevel: 1,
  mipLevelCount: 2,
});
let sampler136 = device6.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 63.78,
  lodMaxClamp: 75.76,
  maxAnisotropy: 6,
});
try {
commandEncoder288.copyBufferToTexture({
  /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 41820 */
  offset: 41544,
  bytesPerRow: 256,
  rowsPerImage: 221,
  buffer: buffer60,
}, {
  texture: texture196,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 5, height: 2, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder289.copyTextureToTexture({
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let commandBuffer73 = commandEncoder87.finish({label: '\u570c\uceca\u0054\ua060\u4d3e\u6c86\u001d\u0adc\u{1f8bb}\u2368'});
let texture199 = device0.createTexture({
  size: {width: 660, height: 480, depthOrArrayLayers: 124},
  mipLevelCount: 4,
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16float', 'r16float'],
});
let textureView358 = texture115.createView({dimension: '2d', baseArrayLayer: 31});
try {
computePassEncoder33.setBindGroup(0, bindGroup70);
} catch {}
try {
renderPassEncoder16.setStencilReference(3391);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline208);
} catch {}
try {
renderPassEncoder15.setVertexBuffer(0, buffer24, 0, 160_527);
} catch {}
try {
renderBundleEncoder50.draw(0, 138, 664_529_721, 552_272_358);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(3, buffer4, 51_924);
} catch {}
let pipeline229 = device0.createComputePipeline({
  label: '\u0651\u00be\u0386',
  layout: pipelineLayout31,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
let canvas43 = document.createElement('canvas');
let commandEncoder301 = device3.createCommandEncoder({label: '\u0816\u44a2\u{1fbf8}\ufcb9\u{1ffd1}\u11fb'});
let texture200 = device3.createTexture({
  label: '\uc63f\u028f\u0cb7\u9954',
  size: {width: 84, height: 3, depthOrArrayLayers: 109},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'],
});
let textureView359 = texture151.createView({label: '\u{1f936}\u{1fedc}\u00f9\u0227\u4788\u012d\u2fc8\u{1fb60}\u4061\u973c', format: 'bgra8unorm'});
let sampler137 = device3.createSampler({
  label: '\u{1ffc9}\u8e3d\u007d\u054c\ue9fa',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 52.99,
  lodMaxClamp: 91.92,
});
try {
  await device3.popErrorScope();
} catch {}
try {
commandEncoder277.copyBufferToBuffer(buffer47, 39852, buffer46, 634928, 71032);
} catch {}
try {
commandEncoder259.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 12752 */
  offset: 12752,
  buffer: buffer47,
}, {
  texture: texture186,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder168.copyTextureToBuffer({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 33014 */
  offset: 33014,
  rowsPerImage: 147,
  buffer: buffer47,
}, {width: 9, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
computePassEncoder85.insertDebugMarker('\u{1f858}');
} catch {}
try {
gpuCanvasContext23.configure({
  device: device3,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  alphaMode: 'premultiplied',
});
} catch {}
try {
device3.queue.writeBuffer(buffer64, 58116, new BigUint64Array(26600));
} catch {}
let pipeline230 = await device3.createComputePipelineAsync({
  label: '\u0f72\u{1f732}',
  layout: pipelineLayout25,
  compute: {module: shaderModule49, entryPoint: 'compute0', constants: {}},
});
let pipeline231 = await promise75;
let imageData47 = new ImageData(236, 224);
let texture201 = device6.createTexture({
  size: [744],
  dimension: '1d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder142.setVertexBuffer(6, buffer60, 12_068);
} catch {}
try {
  await promise78;
} catch {}
let img27 = await imageWithData(36, 235, '#aed1cfd2', '#3d1457e7');
let textureView360 = texture169.createView({label: '\u00de\u269a\u9b71\u0134\u4486\u{1f84e}\u0f62\u0164\u17e6\uca3e', baseArrayLayer: 0});
let renderBundleEncoder152 = device5.createRenderBundleEncoder({
  colorFormats: ['rg16uint', 'rgba32float', 'r32sint', 'r8unorm', 'rg8uint'],
  sampleCount: 1,
  depthReadOnly: true,
});
try {
renderBundleEncoder143.setBindGroup(1, bindGroup95);
} catch {}
let pipeline232 = device5.createComputePipeline({
  label: '\u07f2\u{1fc46}\u2cb7\u2e52',
  layout: 'auto',
  compute: {module: shaderModule51, entryPoint: 'compute0', constants: {}},
});
try {
  await adapter4.requestAdapterInfo();
} catch {}
let buffer68 = device2.createBuffer({
  label: '\u5315\u9aaa\u{1f9a9}\u9754\ua476\u645e',
  size: 104038,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let commandEncoder302 = device2.createCommandEncoder({label: '\u3337\u0473\u6a5f\uedeb\u0f95'});
let renderBundleEncoder153 = device2.createRenderBundleEncoder({
  label: '\uc952\u09f6\u{1f894}\uddfa\u0c0e\uf850\ufe6b\u264d',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  stencilReadOnly: true,
});
try {
commandEncoder186.copyBufferToBuffer(buffer41, 8888, buffer33, 107360, 1628);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture138,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 9_586 */
{offset: 718, bytesPerRow: 280, rowsPerImage: 89}, {width: 47, height: 32, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 720, height: 1, depthOrArrayLayers: 222}
*/
{
  source: imageData20,
  origin: { x: 32, y: 5 },
  flipY: true,
}, {
  texture: texture150,
  mipLevel: 0,
  origin: {x: 31, y: 0, z: 2},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 67, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline233 = device2.createComputePipeline({
  label: '\u{1fae8}\u0eb1\uaf57\u0a30\u3eb3',
  layout: 'auto',
  compute: {module: shaderModule27, entryPoint: 'compute0'},
});
try {
externalTexture140.label = '\u56ce\u1fda\u0e3f\u{1fb1c}\uc6d0\ufe02\u{1f9ec}\u414a\u{1f7b4}\u86d7';
} catch {}
let bindGroupLayout83 = device2.createBindGroupLayout({
  label: '\u0933\uf453',
  entries: [
    {binding: 85, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 753,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '3d' },
    },
    {binding: 324, visibility: GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let bindGroup99 = device2.createBindGroup({
  layout: bindGroupLayout57,
  entries: [
    {binding: 999, resource: {buffer: buffer33, offset: 131328, size: 53700}},
    {binding: 976, resource: textureView196},
  ],
});
let commandEncoder303 = device2.createCommandEncoder();
let texture202 = device2.createTexture({
  size: {width: 180, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  dimension: '2d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderBundleEncoder154 = device2.createRenderBundleEncoder({
  label: '\u6ddb\u6fdd\u0557\ueb35\u077b\u5d31',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
  stencilReadOnly: false,
});
let sampler138 = device2.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 23.66,
  lodMaxClamp: 31.96,
});
try {
computePassEncoder76.dispatchWorkgroups(1, 4, 3);
} catch {}
try {
commandEncoder292.copyTextureToTexture({
  texture: texture94,
  mipLevel: 5,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture97,
  mipLevel: 1,
  origin: {x: 5, y: 3, z: 0},
  aspect: 'all',
},
{width: 17, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder91.popDebugGroup();
} catch {}
let promise80 = navigator.gpu.requestAdapter({});
let texture203 = device5.createTexture({
  size: {width: 320, height: 960, depthOrArrayLayers: 143},
  mipLevelCount: 6,
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'],
});
let textureView361 = texture177.createView({label: '\u0753\u1cb1'});
try {
computePassEncoder135.setBindGroup(2, bindGroup95, new Uint32Array(1432), 627, 0);
} catch {}
try {
renderBundleEncoder143.setBindGroup(1, bindGroup95);
} catch {}
try {
renderBundleEncoder152.setVertexBuffer(6, undefined);
} catch {}
try {
renderBundleEncoder143.pushDebugGroup('\u8b3d');
} catch {}
try {
gpuCanvasContext37.configure({
  device: device5,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device5.queue.writeTexture({
  texture: texture203,
  mipLevel: 1,
  origin: {x: 6, y: 30, z: 4},
  aspect: 'all',
}, arrayBuffer4, /* required buffer size: 486_343 */
{offset: 283, bytesPerRow: 342, rowsPerImage: 395}, {width: 39, height: 237, depthOrArrayLayers: 4});
} catch {}
let pipeline234 = await device5.createComputePipelineAsync({
  label: '\u0cd9\u{1f83b}\u07b5\u0458\uf1ac',
  layout: pipelineLayout21,
  compute: {module: shaderModule51, entryPoint: 'compute0', constants: {}},
});
try {
pipeline63.label = '\u0840\u{1f823}\ud089\u{1f7e8}\u499e\u{1fc26}\u0908\ufef4\u{1fff0}\u3a45\u{1fb0c}';
} catch {}
let bindGroupLayout84 = device1.createBindGroupLayout({label: '\u9e52\u04ac', entries: [{binding: 63, visibility: 0, sampler: { type: 'non-filtering' }}]});
let commandEncoder304 = device1.createCommandEncoder({label: '\u004a\u{1faef}\u2de2'});
let texture204 = device1.createTexture({
  label: '\u038c\u6e65\u71a5\u7f36\u9179\u{1fae3}\u{1fa58}\u1d63',
  size: {width: 550},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder155 = device1.createRenderBundleEncoder({
  label: '\u8eaf\ua73d\u{1fc57}\u055b\u7dd0\u0e1f\u789c',
  colorFormats: ['rg16uint', 'r32uint', 'r8unorm', undefined, 'rg8sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder34.drawIndexed(616, 231, 1_076, -2_137_040_453, 201_126_149);
} catch {}
try {
renderBundleEncoder103.setIndexBuffer(buffer15, 'uint32', 6_320, 1_374);
} catch {}
try {
buffer31.unmap();
} catch {}
try {
commandEncoder304.clearBuffer(buffer12, 44, 5620);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture50,
  mipLevel: 3,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(72), /* required buffer size: 752 */
{offset: 752}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let promise81 = device1.queue.onSubmittedWorkDone();
try {
gpuCanvasContext25.unconfigure();
} catch {}
try {
if (!arrayBuffer16.detached) { new Uint8Array(arrayBuffer16).fill(0x55) };
} catch {}
let canvas44 = document.createElement('canvas');
let commandEncoder305 = device0.createCommandEncoder();
let texture205 = device0.createTexture({
  label: '\u{1f845}\u{1fb14}\u{1fdfd}\uf4d7\uf375\u5175',
  size: {width: 330, height: 240, depthOrArrayLayers: 124},
  mipLevelCount: 7,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8sint', 'rgba8sint'],
});
try {
renderBundleEncoder50.draw(129, 14, 136_022_023, 1_014_272_299);
} catch {}
try {
commandEncoder121.copyTextureToBuffer({
  texture: texture45,
  mipLevel: 0,
  origin: {x: 22, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2086 widthInBlocks: 1043 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 87864 */
  offset: 87864,
  buffer: buffer20,
}, {width: 1043, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline235 = device0.createRenderPipeline({
  label: '\u{1f924}\ue8b0',
  layout: pipelineLayout31,
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'add', srcFactor: 'constant', dstFactor: 'src'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'src', dstFactor: 'dst-alpha'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'never',
    stencilFront: {compare: 'less-equal', depthFailOp: 'decrement-wrap', passOp: 'increment-clamp'},
    stencilBack: {compare: 'never', failOp: 'decrement-clamp', depthFailOp: 'increment-clamp', passOp: 'replace'},
    stencilReadMask: 1241547540,
    stencilWriteMask: 3165741502,
    depthBias: -1703313215,
    depthBiasSlopeScale: 996.0710895044576,
    depthBiasClamp: -81.97936579805915,
  },
  vertex: {
    module: shaderModule1,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 1012, stepMode: 'instance', attributes: []},
      {
        arrayStride: 100,
        attributes: [{format: 'sint8x2', offset: 88, shaderLocation: 14}, {format: 'sint32', offset: 4, shaderLocation: 7}],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x2', offset: 6, shaderLocation: 8},
          {format: 'float32x4', offset: 396, shaderLocation: 1},
          {format: 'unorm8x4', offset: 128, shaderLocation: 9},
          {format: 'float32x2', offset: 36, shaderLocation: 5},
          {format: 'sint8x4', offset: 964, shaderLocation: 15},
          {format: 'sint32x4', offset: 140, shaderLocation: 6},
        ],
      },
      {arrayStride: 212, stepMode: 'instance', attributes: []},
      {arrayStride: 492, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'snorm16x4', offset: 136, shaderLocation: 10}],
      },
      {arrayStride: 372, attributes: [{format: 'float32x3', offset: 360, shaderLocation: 0}]},
      {
        arrayStride: 100,
        attributes: [
          {format: 'sint32x3', offset: 0, shaderLocation: 4},
          {format: 'uint8x2', offset: 18, shaderLocation: 3},
          {format: 'sint8x2', offset: 12, shaderLocation: 13},
          {format: 'sint32x3', offset: 0, shaderLocation: 2},
          {format: 'uint8x2', offset: 26, shaderLocation: 12},
          {format: 'sint32x3', offset: 12, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'},
});
try {
  await promise81;
} catch {}
let imageData48 = new ImageData(100, 56);
try {
canvas43.getContext('webgpu');
} catch {}
let commandEncoder306 = device2.createCommandEncoder();
let querySet149 = device2.createQuerySet({
  label: '\u3e35\ucc42\u{1f9cd}\u973b\u1249\u{1f840}\u072d\u026b\uf94f\uef28',
  type: 'occlusion',
  count: 3880,
});
let textureView362 = texture87.createView({label: '\u41fd\uc50d\u0daa', baseMipLevel: 2});
let computePassEncoder154 = commandEncoder147.beginComputePass();
let renderBundleEncoder156 = device2.createRenderBundleEncoder({
  label: '\u58a1\u9270\u{1f920}\u0d55\u2c17\ubbc7\u{1f8ef}\u4fb1\u07cc',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  stencilReadOnly: true,
});
try {
renderBundleEncoder150.setPipeline(pipeline133);
} catch {}
try {
renderBundleEncoder100.setVertexBuffer(1, buffer68);
} catch {}
try {
commandEncoder188.clearBuffer(buffer65, 19056, 248);
} catch {}
try {
computePassEncoder133.insertDebugMarker('\u{1f787}');
} catch {}
let bindGroup100 = device5.createBindGroup({
  layout: bindGroupLayout76,
  entries: [{binding: 236, resource: externalTexture125}, {binding: 463, resource: sampler119}],
});
let sampler139 = device5.createSampler({
  label: '\u10de\ua49f\ub938\udf69\u{1f8e1}\u80a3\ueffe\u3178\u81e9',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 37.78,
  lodMaxClamp: 61.49,
});
try {
computePassEncoder152.end();
} catch {}
try {
commandEncoder299.insertDebugMarker('\u7816');
} catch {}
let pipeline236 = await device5.createRenderPipelineAsync({
  label: '\ucadb\u9f53\u43a4\u{1fe53}\u4b6d\ufb33\u0d5b\u0bab',
  layout: pipelineLayout28,
  multisample: {mask: 0xffffffff},
  fragment: {
  module: shaderModule51,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16uint', writeMask: GPUColorWrite.ALPHA}, {format: 'rgba32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r8unorm'}, {format: 'rg8uint', writeMask: 0}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'less', failOp: 'replace', depthFailOp: 'increment-wrap', passOp: 'increment-wrap'},
    stencilBack: {compare: 'less-equal', failOp: 'invert', depthFailOp: 'increment-clamp', passOp: 'increment-clamp'},
    stencilReadMask: 4241948333,
    stencilWriteMask: 3069176351,
    depthBiasClamp: 324.5250019158775,
  },
  vertex: {
    module: shaderModule51,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 552, stepMode: 'instance', attributes: []},
      {arrayStride: 2048, stepMode: 'instance', attributes: []},
      {arrayStride: 192, stepMode: 'instance', attributes: []},
      {
        arrayStride: 332,
        stepMode: 'instance',
        attributes: [{format: 'float32x3', offset: 20, shaderLocation: 1}],
      },
      {arrayStride: 348, attributes: []},
      {
        arrayStride: 172,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 20, shaderLocation: 7},
          {format: 'sint32x2', offset: 12, shaderLocation: 14},
          {format: 'unorm16x2', offset: 32, shaderLocation: 5},
          {format: 'sint32', offset: 28, shaderLocation: 0},
          {format: 'unorm8x4', offset: 0, shaderLocation: 3},
          {format: 'snorm8x2', offset: 50, shaderLocation: 11},
          {format: 'float32x4', offset: 4, shaderLocation: 12},
          {format: 'unorm8x4', offset: 8, shaderLocation: 2},
          {format: 'float32', offset: 4, shaderLocation: 10},
          {format: 'snorm8x2', offset: 14, shaderLocation: 13},
          {format: 'snorm8x4', offset: 40, shaderLocation: 8},
        ],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 384,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 124, shaderLocation: 9},
          {format: 'float32x3', offset: 16, shaderLocation: 6},
          {format: 'uint32x3', offset: 44, shaderLocation: 15},
          {format: 'uint32x2', offset: 36, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'front'},
});
document.body.prepend(video2);
let textureView363 = texture191.createView({label: '\u02ba\u9445', baseMipLevel: 1, mipLevelCount: 3, baseArrayLayer: 0});
let renderBundle175 = renderBundleEncoder134.finish();
try {
device6.addEventListener('uncapturederror', e => { log('device6.uncapturederror'); log(e); e.label = device6.label; });
} catch {}
try {
texture191.destroy();
} catch {}
try {
commandEncoder289.copyTextureToBuffer({
  texture: texture165,
  mipLevel: 0,
  origin: {x: 16, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 8704 */
  offset: 8704,
  buffer: buffer60,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder289.clearBuffer(buffer60, 52740, 80320);
} catch {}
let pipelineLayout33 = device3.createPipelineLayout({
  label: '\u046f\u{1fc32}\u07e4\u{1f75f}\u1f5e\u04a9\u{1fb2a}',
  bindGroupLayouts: [bindGroupLayout56, bindGroupLayout53, bindGroupLayout53],
});
let textureView364 = texture103.createView({
  label: '\u8d92\u0c1d\u1983\u{1fd66}\u{1f9c0}\uca41',
  dimension: '2d',
  format: 'astc-10x5-unorm-srgb',
  baseMipLevel: 3,
  mipLevelCount: 1,
  baseArrayLayer: 44,
});
try {
computePassEncoder109.setPipeline(pipeline230);
} catch {}
try {
commandEncoder271.copyTextureToBuffer({
  texture: texture151,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2208 widthInBlocks: 552 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 9472 */
  offset: 9472,
  buffer: buffer46,
}, {width: 552, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device3.queue.writeTexture({
  texture: texture183,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Int16Array(new ArrayBuffer(8)), /* required buffer size: 405 */
{offset: 405}, {width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
let textureView365 = texture165.createView({label: '\u{1fd11}\ue5fd\u{1fbf6}\uad68\u8418\uabe0\uba6d\u31cf\u03c7', dimension: '2d-array'});
let renderBundleEncoder157 = device6.createRenderBundleEncoder({colorFormats: ['r16sint', 'rgba16sint', 'rgb10a2uint', 'rgb10a2uint'], stencilReadOnly: true});
let texture206 = device5.createTexture({
  label: '\u33bd\u3526\u{1fed3}',
  size: {width: 160},
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'],
});
try {
renderBundleEncoder143.setBindGroup(0, bindGroup100);
} catch {}
let pipeline237 = device5.createRenderPipeline({
  label: '\u09a7\u{1f632}\u{1fa8e}\u8086\u6697\u0dad\u9d00\u38ac\u{1f973}\u0f73',
  layout: pipelineLayout21,
  fragment: {
  module: shaderModule51,
  entryPoint: 'fragment0',
  targets: [{format: 'rg16uint', writeMask: 0}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {
  format: 'r32sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg8uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule51,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 104,
        stepMode: 'instance',
        attributes: [{format: 'sint8x2', offset: 2, shaderLocation: 14}],
      },
      {arrayStride: 328, stepMode: 'instance', attributes: []},
      {arrayStride: 900, stepMode: 'instance', attributes: []},
      {
        arrayStride: 580,
        attributes: [
          {format: 'float16x4', offset: 28, shaderLocation: 9},
          {format: 'snorm16x2', offset: 252, shaderLocation: 3},
          {format: 'snorm16x4', offset: 16, shaderLocation: 6},
        ],
      },
      {arrayStride: 60, stepMode: 'instance', attributes: []},
      {
        arrayStride: 60,
        attributes: [
          {format: 'unorm16x4', offset: 0, shaderLocation: 5},
          {format: 'uint32x3', offset: 8, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 92,
        stepMode: 'instance',
        attributes: [{format: 'uint32', offset: 0, shaderLocation: 15}],
      },
      {
        arrayStride: 900,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 0, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 264, shaderLocation: 11},
          {format: 'sint32', offset: 236, shaderLocation: 0},
          {format: 'sint32', offset: 284, shaderLocation: 7},
          {format: 'unorm8x2', offset: 180, shaderLocation: 13},
          {format: 'snorm16x4', offset: 88, shaderLocation: 1},
          {format: 'float32x4', offset: 184, shaderLocation: 8},
          {format: 'float16x4', offset: 212, shaderLocation: 2},
          {format: 'float32', offset: 88, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'front', unclippedDepth: true},
});
let video47 = await videoWithData();
let videoFrame33 = new VideoFrame(offscreenCanvas3, {timestamp: 0});
let commandEncoder307 = device5.createCommandEncoder({label: '\u097b\u02cb\ud265\u0bb1\u4c32\ud3b8\u10eb\u9fa5\ucaac'});
try {
renderBundleEncoder152.setBindGroup(1, bindGroup100);
} catch {}
try {
commandEncoder307.copyBufferToTexture({
  /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 60832 */
  offset: 10390,
  bytesPerRow: 256,
  rowsPerImage: 18,
  buffer: buffer50,
}, {
  texture: texture203,
  mipLevel: 5,
  origin: {x: 0, y: 3, z: 21},
  aspect: 'all',
}, {width: 5, height: 18, depthOrArrayLayers: 11});
} catch {}
try {
renderBundleEncoder143.popDebugGroup();
} catch {}
try {
gpuCanvasContext23.configure({
  device: device5,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm-srgb'],
  alphaMode: 'premultiplied',
});
} catch {}
let gpuCanvasContext38 = canvas44.getContext('webgpu');
let texture207 = device0.createTexture({
  label: '\u{1f768}\u0b0b\u41dc',
  size: [165, 120, 198],
  mipLevelCount: 6,
  dimension: '3d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgba16uint', 'rgba16uint'],
});
let textureView366 = texture32.createView({label: '\u594d\u9f16\u0a63\u22e6\ucc1a\u{1f7b9}\u09b1\u0a6c\u0311', baseMipLevel: 9});
let renderPassEncoder19 = commandEncoder96.beginRenderPass({
  label: '\uf888\ubc06\uea65\u2c0f\u{1fff0}\u{1f785}\ub925\u5858\u12d0',
  colorAttachments: [{view: textureView227, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet4,
  maxDrawCount: 912845245,
});
let renderBundleEncoder158 = device0.createRenderBundleEncoder({
  label: '\u6026\uc890',
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  depthReadOnly: true,
});
let externalTexture150 = device0.importExternalTexture({label: '\uf526\u0ca2\ub7b6\u5a41\u248f\u562f\u5163\u96a2\u839a\u64c8', source: video35});
try {
computePassEncoder90.dispatchWorkgroups(1);
} catch {}
try {
renderPassEncoder14.setBindGroup(3, bindGroup88);
} catch {}
try {
renderPassEncoder8.setBindGroup(3, bindGroup20, new Uint32Array(2659), 1454, 0);
} catch {}
try {
renderPassEncoder6.setViewport(62.25, 100.5, 79.48, 13.75, 0.8675, 0.9239);
} catch {}
try {
gpuCanvasContext31.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  alphaMode: 'premultiplied',
});
} catch {}
try {
device0.queue.writeBuffer(buffer7, 7448, new BigUint64Array(53468), 27170, 1592);
} catch {}
let pipeline238 = device0.createRenderPipeline({
  label: '\u6acb\ue5a1\u{1f645}\u9166',
  layout: pipelineLayout2,
  vertex: {module: shaderModule21, entryPoint: 'vertex0', constants: {}, buffers: []},
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
let bindGroupLayout85 = device5.createBindGroupLayout({entries: []});
let sampler140 = device5.createSampler({
  label: '\u04ba\ud1fa\u741c\u08e1\u{1fff5}\uaaa1\u{1fb48}\u9ac0\u0aa3\u{1fa87}',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 10.65,
});
try {
computePassEncoder142.setPipeline(pipeline232);
} catch {}
try {
renderBundleEncoder152.setBindGroup(2, bindGroup100);
} catch {}
try {
renderBundleEncoder143.setPipeline(pipeline237);
} catch {}
let textureView367 = texture206.createView({});
try {
computePassEncoder145.setPipeline(pipeline232);
} catch {}
try {
device5.pushErrorScope('validation');
} catch {}
let bindGroup101 = device5.createBindGroup({label: '\u{1f9fc}\u{1ff66}\uac89', layout: bindGroupLayout85, entries: []});
let commandBuffer74 = commandEncoder299.finish({label: '\u{1f910}\u223a\ud86e\u6146\u5618'});
let renderBundleEncoder159 = device5.createRenderBundleEncoder({
  label: '\u68ef\u0997\u1ec6\u{1fbc1}\ue8b0\ue97b',
  colorFormats: ['rg16uint', 'rgba32float', 'r32sint', 'r8unorm', 'rg8uint'],
  depthReadOnly: true,
});
try {
computePassEncoder142.setBindGroup(1, bindGroup95);
} catch {}
try {
renderBundleEncoder159.setVertexBuffer(7, undefined);
} catch {}
try {
device5.queue.writeTexture({
  texture: texture184,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer10, /* required buffer size: 452 */
{offset: 452}, {width: 8, height: 1, depthOrArrayLayers: 0});
} catch {}
let imageBitmap31 = await createImageBitmap(videoFrame4);
let bindGroup102 = device1.createBindGroup({label: '\uaf2b\u0ed8\ufde7', layout: bindGroupLayout52, entries: []});
try {
renderBundleEncoder52.setPipeline(pipeline131);
} catch {}
try {
commandEncoder269.copyBufferToBuffer(buffer37, 1580, buffer36, 42796, 1496);
} catch {}
try {
commandEncoder86.copyBufferToTexture({
  /* bytesInLastRow: 402 widthInBlocks: 201 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 6232 */
  offset: 6232,
  buffer: buffer36,
}, {
  texture: texture204,
  mipLevel: 0,
  origin: {x: 36, y: 0, z: 0},
  aspect: 'all',
}, {width: 201, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder80.copyTextureToTexture({
  texture: texture112,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture116,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 4},
  aspect: 'all',
},
{width: 3, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder245.clearBuffer(buffer28, 22664, 10320);
} catch {}
try {
commandEncoder165.resolveQuerySet(querySet122, 37, 0, buffer18, 28416);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture171,
  mipLevel: 0,
  origin: {x: 5, y: 10, z: 0},
  aspect: 'all',
}, arrayBuffer3, /* required buffer size: 630 */
{offset: 630, bytesPerRow: 345}, {width: 34, height: 35, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas10,
  origin: { x: 72, y: 44 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
video29.height = 7;
let bindGroup103 = device0.createBindGroup({
  label: '\u307d\u0730\u34b6\u06b8\u{1fd23}\u3057\u0f99',
  layout: bindGroupLayout25,
  entries: [{binding: 917, resource: sampler14}, {binding: 211, resource: externalTexture40}],
});
let querySet150 = device0.createQuerySet({label: '\u477a\u{1fe82}\u{1fe7e}\u72e2\u{1ff34}', type: 'occlusion', count: 3210});
let texture208 = device0.createTexture({
  label: '\u44bb\u{1f89d}',
  size: {width: 330, height: 240, depthOrArrayLayers: 1212},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16float'],
});
let textureView368 = texture14.createView({label: '\u0285\u{1ff5d}\u153b\u{1ff60}'});
let renderBundleEncoder160 = device0.createRenderBundleEncoder({
  label: '\u5d76\uf664\uc600\u93ff\ub384\u2fcf\u6a44\u559c\u{1fe4c}\u5acd\u{1fc33}',
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  depthReadOnly: true,
});
try {
computePassEncoder60.setBindGroup(0, bindGroup40);
} catch {}
try {
computePassEncoder90.setPipeline(pipeline221);
} catch {}
try {
renderPassEncoder17.setBlendConstant({ r: -223.5, g: 543.3, b: -309.0, a: -138.8, });
} catch {}
try {
renderBundleEncoder50.drawIndexed(585, 322, 236, -2_027_663_094, 1_321_668_267);
} catch {}
try {
renderBundleEncoder56.drawIndexedIndirect(buffer11, 21_708);
} catch {}
try {
renderBundleEncoder25.setIndexBuffer(buffer35, 'uint16', 4_512, 3_699);
} catch {}
try {
texture72.destroy();
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder170.copyBufferToBuffer(buffer29, 4280, buffer1, 50776, 9340);
} catch {}
try {
commandEncoder32.clearBuffer(buffer9);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 52584, new BigUint64Array(49830), 23271, 11244);
} catch {}
try {
if (!arrayBuffer18.detached) { new Uint8Array(arrayBuffer18).fill(0x55) };
} catch {}
let img28 = await imageWithData(252, 112, '#58547643', '#05f2f37b');
let videoFrame34 = videoFrame13.clone();
let computePassEncoder155 = commandEncoder244.beginComputePass({label: '\u0a63\u625f\uf7e4\u{1f689}\u99d8\u0ccf\u5956\u{1fbff}'});
let externalTexture151 = device0.importExternalTexture({source: videoFrame12});
try {
renderPassEncoder8.setBindGroup(0, bindGroup29);
} catch {}
try {
renderPassEncoder16.setBindGroup(2, bindGroup11, new Uint32Array(9624), 2474, 0);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(5, buffer6, 0);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(1, buffer53, 1_916, 77);
} catch {}
let arrayBuffer22 = buffer66.getMappedRange();
try {
commandEncoder89.copyBufferToBuffer(buffer66, 70088, buffer34, 195956, 2356);
} catch {}
try {
commandEncoder32.copyBufferToTexture({
  /* bytesInLastRow: 2236 widthInBlocks: 559 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 4464 */
  offset: 4464,
  bytesPerRow: 2304,
  buffer: buffer1,
}, {
  texture: texture62,
  mipLevel: 0,
  origin: {x: 4, y: 26, z: 6},
  aspect: 'all',
}, {width: 559, height: 176, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder305.copyTextureToTexture({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 33, y: 7, z: 14},
  aspect: 'all',
},
{
  texture: texture70,
  mipLevel: 0,
  origin: {x: 25, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder134.resolveQuerySet(querySet15, 722, 924, buffer24, 16384);
} catch {}
let bindGroup104 = device0.createBindGroup({layout: bindGroupLayout5, entries: []});
let textureView369 = texture55.createView({
  label: '\ua1c9\u7fd8\u6e98\u05a4\ucd45\u7db4',
  aspect: 'depth-only',
  mipLevelCount: 3,
  baseArrayLayer: 108,
});
try {
renderPassEncoder16.end();
} catch {}
try {
renderBundleEncoder50.draw(475, 177, 177_740_096, 861_826_971);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer35, 1_040);
} catch {}
try {
commandEncoder257.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 21640 */
  offset: 21640,
  bytesPerRow: 0,
  rowsPerImage: 4,
  buffer: buffer1,
}, {
  texture: texture77,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 8});
} catch {}
try {
commandEncoder175.clearBuffer(buffer14, 15532, 7056);
} catch {}
try {
gpuCanvasContext22.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline239 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout23,
  multisample: {mask: 0x4c3e90c7},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16float', writeMask: 0}, undefined, {format: 'rg8unorm', writeMask: 0}, {
  format: 'rg16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.RED,
}, {format: 'rgba16uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 44, stepMode: 'instance', attributes: []},
      {arrayStride: 100, stepMode: 'vertex', attributes: []},
      {arrayStride: 812, attributes: []},
      {arrayStride: 120, attributes: []},
      {arrayStride: 548, stepMode: 'vertex', attributes: []},
      {arrayStride: 112, stepMode: 'vertex', attributes: []},
      {arrayStride: 32, stepMode: 'instance', attributes: []},
      {
        arrayStride: 116,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x4', offset: 4, shaderLocation: 7},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: false,
},
});
let video48 = await videoWithData();
let buffer69 = device0.createBuffer({size: 178360, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true});
let textureView370 = texture11.createView({
  label: '\u0e92\u{1ff03}\u0546\u{1fbc9}\u0c3c\u03db\u9c6e',
  format: 'bgra8unorm',
  baseMipLevel: 1,
  mipLevelCount: 1,
});
try {
computePassEncoder134.setPipeline(pipeline74);
} catch {}
try {
renderBundleEncoder19.setBindGroup(0, bindGroup1);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer53, 276);
} catch {}
try {
commandEncoder295.resolveQuerySet(querySet34, 0, 246, buffer0, 62208);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
adapter3.label = '\u88ea\u{1f60f}\uad84\u{1f86a}\udd2d';
} catch {}
let textureView371 = texture183.createView({
  label: '\u0c9f\u85eb\u{1fe25}\u{1ffef}\ua772\u01d4\u{1fd3e}\u0013\u4fda\u0656\u01d9',
  dimension: '2d-array',
  baseMipLevel: 5,
  mipLevelCount: 1,
});
let renderBundleEncoder161 = device3.createRenderBundleEncoder({
  colorFormats: ['rgba32sint', 'rg32uint', 'rg16sint', 'r32uint'],
  sampleCount: 4,
  depthReadOnly: true,
  stencilReadOnly: false,
});
let renderBundle176 = renderBundleEncoder118.finish({label: '\uc7d9\u7e3d\u{1fade}\u0e21\u9cab\uff45\uee86\u5393'});
try {
computePassEncoder120.setPipeline(pipeline230);
} catch {}
let arrayBuffer23 = buffer38.getMappedRange(38096, 23336);
try {
commandEncoder277.clearBuffer(buffer47);
} catch {}
let commandEncoder308 = device4.createCommandEncoder({label: '\ub605\u07e3\u8a43\ud394'});
let texture209 = device4.createTexture({
  label: '\u0f1e\u58cf\u1f2e\uc5b4\uc80f\u1526\u8dfd',
  size: [656, 12, 1],
  mipLevelCount: 7,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgb10a2uint', 'rgb10a2uint'],
});
let sampler141 = device4.createSampler({
  label: '\u0131\u{1f8bf}\u{1fe84}\u8c78\uaddf\u1bcc\u{1f67a}\ub2e7\u7768\uee2c\u04e6',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 17.93,
});
try {
commandEncoder238.copyTextureToBuffer({
  texture: texture163,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 17368 */
  offset: 17368,
  bytesPerRow: 256,
  buffer: buffer54,
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder267.clearBuffer(buffer56, 60232);
} catch {}
try {
commandEncoder243.resolveQuerySet(querySet119, 423, 803, buffer48, 52480);
} catch {}
try {
gpuCanvasContext33.configure({
  device: device4,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device4.queue.writeBuffer(buffer54, 1988, new Int16Array(32958), 7627, 2132);
} catch {}
let pipeline240 = await device4.createComputePipelineAsync({
  label: '\u{1fab1}\u0cee\u38c3',
  layout: pipelineLayout17,
  compute: {module: shaderModule41, entryPoint: 'compute0'},
});
let pipeline241 = device4.createRenderPipeline({
  label: '\u0cb2\u{1f97e}\u0105\u434e',
  layout: pipelineLayout26,
  multisample: {count: 4, mask: 0xa4b4cd44},
  fragment: {
  module: shaderModule50,
  entryPoint: 'fragment0',
  targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.BLUE}, {format: 'rgba8sint', writeMask: 0}, {format: 'rg8unorm', writeMask: GPUColorWrite.GREEN}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg8sint', writeMask: 0}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule50,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 392,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 124, shaderLocation: 12},
          {format: 'float32x3', offset: 16, shaderLocation: 5},
          {format: 'sint32x4', offset: 128, shaderLocation: 13},
          {format: 'unorm8x4', offset: 12, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 492,
        attributes: [
          {format: 'uint8x2', offset: 12, shaderLocation: 10},
          {format: 'float32x4', offset: 28, shaderLocation: 4},
          {format: 'float16x2', offset: 236, shaderLocation: 1},
        ],
      },
      {arrayStride: 112, attributes: []},
      {arrayStride: 448, attributes: []},
      {
        arrayStride: 112,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 0, shaderLocation: 7},
          {format: 'unorm16x2', offset: 4, shaderLocation: 6},
        ],
      },
      {arrayStride: 108, stepMode: 'vertex', attributes: []},
      {arrayStride: 40, attributes: []},
      {
        arrayStride: 840,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 364, shaderLocation: 14},
          {format: 'sint32x3', offset: 56, shaderLocation: 3},
          {format: 'snorm8x2', offset: 24, shaderLocation: 2},
          {format: 'unorm8x2', offset: 138, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'ccw', cullMode: 'back', unclippedDepth: true},
});
canvas30.width = 132;
try {
computePassEncoder92.setBindGroup(1, bindGroup75, new Uint32Array(5465), 4761, 0);
} catch {}
try {
buffer65.unmap();
} catch {}
try {
commandEncoder302.copyTextureToBuffer({
  texture: texture114,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 2449 */
  offset: 2449,
  buffer: buffer23,
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder293.copyTextureToTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 12, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture79,
  mipLevel: 0,
  origin: {x: 0, y: 12, z: 0},
  aspect: 'all',
},
{width: 108, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder293.insertDebugMarker('\u16da');
} catch {}
let pipeline242 = device2.createRenderPipeline({
  label: '\uce6e\u076d\u6775\u0718',
  layout: pipelineLayout9,
  multisample: {count: 4, mask: 0x0a78fd},
  fragment: {
  module: shaderModule25,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rgba8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'rgba8unorm-srgb', writeMask: 0}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-constant'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE,
}, {format: 'r8sint', writeMask: GPUColorWrite.ALPHA}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: 0,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'not-equal', failOp: 'replace', depthFailOp: 'decrement-clamp', passOp: 'zero'},
    stencilBack: {failOp: 'invert', passOp: 'increment-wrap'},
    stencilReadMask: 2512945344,
    stencilWriteMask: 412357001,
    depthBiasSlopeScale: 926.7998092329976,
  },
  vertex: {
    module: shaderModule25,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 428, attributes: []},
      {arrayStride: 1316, stepMode: 'instance', attributes: []},
      {arrayStride: 256, stepMode: 'instance', attributes: []},
      {arrayStride: 96, stepMode: 'instance', attributes: []},
      {arrayStride: 312, attributes: []},
      {arrayStride: 220, stepMode: 'instance', attributes: []},
      {arrayStride: 736, stepMode: 'instance', attributes: []},
      {
        arrayStride: 536,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x2', offset: 228, shaderLocation: 13},
          {format: 'unorm8x4', offset: 164, shaderLocation: 0},
        ],
      },
    ],
  },
});
let commandEncoder309 = device5.createCommandEncoder();
let renderBundle177 = renderBundleEncoder159.finish({label: '\u{1f8bf}\u0ab7\ucba9\u{1f70b}\u0f62\u{1fc00}\u0563\u1af1'});
let sampler142 = device5.createSampler({
  label: '\u02b1\u763a\u3628\u03f8\u1c21\u{1f724}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 50.62,
  lodMaxClamp: 89.78,
});
gc();
let commandEncoder310 = device2.createCommandEncoder({});
let querySet151 = device2.createQuerySet({label: '\u0a18\u3bcd\u76a3\u{1f6fc}\ud608\u03e3', type: 'occlusion', count: 201});
try {
computePassEncoder133.setBindGroup(0, bindGroup94, new Uint32Array(4952), 4532, 0);
} catch {}
try {
computePassEncoder117.setPipeline(pipeline105);
} catch {}
try {
renderBundleEncoder138.setBindGroup(3, bindGroup49);
} catch {}
try {
renderBundleEncoder91.setIndexBuffer(buffer43, 'uint16', 134, 497);
} catch {}
try {
commandEncoder264.copyBufferToBuffer(buffer41, 8032, buffer23, 218160, 1828);
} catch {}
try {
commandEncoder292.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 188 */
  offset: 180,
  buffer: buffer41,
}, {
  texture: texture132,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder186.clearBuffer(buffer43);
} catch {}
let pipeline243 = device2.createRenderPipeline({
  label: '\u0f0a\u0426\ue53e\ue62e',
  layout: pipelineLayout29,
  multisample: {count: 4, alphaToCoverageEnabled: true},
  fragment: {
  module: shaderModule46,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'src', dstFactor: 'one-minus-src'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgba8unorm'}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'rg8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba8sint', writeMask: 0}],
},
  vertex: {
    module: shaderModule46,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 416,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 24, shaderLocation: 11}],
      },
      {arrayStride: 1132, attributes: []},
      {arrayStride: 864, stepMode: 'instance', attributes: []},
      {arrayStride: 76, attributes: [{format: 'unorm8x4', offset: 20, shaderLocation: 2}]},
      {arrayStride: 332, attributes: [{format: 'unorm16x4', offset: 16, shaderLocation: 12}]},
      {arrayStride: 164, stepMode: 'vertex', attributes: []},
      {arrayStride: 228, stepMode: 'instance', attributes: []},
      {
        arrayStride: 224,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 12, shaderLocation: 13},
          {format: 'sint32', offset: 16, shaderLocation: 3},
          {format: 'sint16x4', offset: 20, shaderLocation: 4},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 7},
          {format: 'sint8x2', offset: 10, shaderLocation: 14},
          {format: 'uint32x4', offset: 28, shaderLocation: 5},
          {format: 'unorm16x4', offset: 152, shaderLocation: 10},
          {format: 'sint32x2', offset: 48, shaderLocation: 9},
          {format: 'uint8x2', offset: 8, shaderLocation: 1},
          {format: 'float32x2', offset: 4, shaderLocation: 8},
          {format: 'float32x4', offset: 4, shaderLocation: 6},
          {format: 'unorm8x2', offset: 80, shaderLocation: 15},
          {format: 'sint8x2', offset: 14, shaderLocation: 0},
        ],
      },
    ],
  },
});
let bindGroup105 = device2.createBindGroup({
  label: '\u{1faf1}\uea60\u41a8\u092d\ua47d',
  layout: bindGroupLayout57,
  entries: [
    {binding: 976, resource: textureView196},
    {binding: 999, resource: {buffer: buffer33, offset: 154880, size: 7640}},
  ],
});
let commandEncoder311 = device2.createCommandEncoder({label: '\u0c5b\ubb00\u22d3\u0f38\u6cde'});
let commandBuffer75 = commandEncoder255.finish({label: '\uf6ba\u0311\u0439\u{1fdbf}\u0aa2'});
let textureView372 = texture114.createView({label: '\u37af\u077c\u{1f8b0}\u0be0', baseMipLevel: 2});
let renderBundleEncoder162 = device2.createRenderBundleEncoder({
  label: '\ud225\u1662\u50fa',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
  stencilReadOnly: false,
});
try {
commandEncoder273.copyBufferToBuffer(buffer23, 56216, buffer62, 306176, 1980);
} catch {}
try {
commandEncoder188.copyTextureToTexture({
  texture: texture132,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture97,
  mipLevel: 0,
  origin: {x: 94, y: 2, z: 0},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext23.configure({
  device: device2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 180, height: 1, depthOrArrayLayers: 1}
*/
{
  source: videoFrame5,
  origin: { x: 3, y: 474 },
  flipY: false,
}, {
  texture: texture93,
  mipLevel: 0,
  origin: {x: 15, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 81, height: 0, depthOrArrayLayers: 0});
} catch {}
let renderBundle178 = renderBundleEncoder132.finish({label: '\uf556\u6d54\u77f8\uf104\u8d60\u{1fa71}\u{1f7e0}\u0273\u96fe\u2ad5'});
let sampler143 = device6.createSampler({
  label: '\ubb2e\u1e62\ue33c\u0392\ud4a6\uf694\uef67\ubdbb\u{1f8f5}\u{1ffb6}\u0cc7',
  minFilter: 'linear',
  lodMinClamp: 57.30,
  lodMaxClamp: 90.86,
});
let externalTexture152 = device6.importExternalTexture({
  label: '\ue14b\u{1fd06}\uee26\u4584\u{1f768}\u5267\u0bb2\u4e19\u64f5\u087b\u09ee',
  source: videoFrame14,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder142.setVertexBuffer(0, buffer60, 0, 44_655);
} catch {}
try {
commandEncoder289.resolveQuerySet(querySet146, 74, 65, buffer60, 24832);
} catch {}
try {
  await device6.queue.onSubmittedWorkDone();
} catch {}
let bindGroupLayout86 = device6.createBindGroupLayout({
  entries: [
    {
      binding: 196,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 664,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let commandBuffer76 = commandEncoder289.finish({label: '\u8575\ucb1c\u5292\u{1f83c}\u0a93\uc233\u436f\u921c'});
try {
renderBundleEncoder149.setVertexBuffer(0, buffer60, 21_404, 58_013);
} catch {}
try {
commandEncoder288.clearBuffer(buffer60, 103672, 19632);
} catch {}
try {
  await device6.queue.onSubmittedWorkDone();
} catch {}
let offscreenCanvas38 = new OffscreenCanvas(770, 304);
let img29 = await imageWithData(221, 172, '#b041e2ea', '#9995026f');
let commandEncoder312 = device0.createCommandEncoder({});
let textureView373 = texture32.createView({label: '\u45f9\u003f\u{1f688}\u29c7\u0762\u134e', baseMipLevel: 2, mipLevelCount: 6});
let renderBundle179 = renderBundleEncoder6.finish({label: '\u0d37\ub4f7\u8cc2'});
let externalTexture153 = device0.importExternalTexture({source: video0, colorSpace: 'srgb'});
try {
computePassEncoder18.setBindGroup(0, bindGroup78, new Uint32Array(1321), 715, 0);
} catch {}
try {
renderPassEncoder19.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder18.setViewport(518.5, 111.8, 136.6, 203.5, 0.06268, 0.4339);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer11, 118_616);
} catch {}
try {
commandEncoder202.resolveQuerySet(querySet46, 2600, 74, buffer11, 12544);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 2}
*/
{
  source: img29,
  origin: { x: 62, y: 13 },
  flipY: false,
}, {
  texture: texture77,
  mipLevel: 9,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline244 = device0.createComputePipeline({
  label: '\u089e\u{1f71a}\u0b34\u0595\u0411\ub8d8\u92b5',
  layout: pipelineLayout31,
  compute: {module: shaderModule1, entryPoint: 'compute0'},
});
try {
offscreenCanvas38.getContext('bitmaprenderer');
} catch {}
let texture210 = device1.createTexture({
  label: '\u58d0\u0e27\u{1f6fb}\u{1fd8a}',
  size: {width: 20, height: 20, depthOrArrayLayers: 73},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16sint'],
});
let textureView374 = texture121.createView({
  label: '\u{1f6ab}\u{1fa92}\ua29a\u065a\uef64\u{1f8ce}\u{1ff3f}\u{1fa9c}\u3431\uf53e',
  dimension: '2d-array',
  format: 'rg32sint',
  baseMipLevel: 3,
  mipLevelCount: 2,
  arrayLayerCount: 1,
});
let computePassEncoder156 = commandEncoder80.beginComputePass({label: '\u30b6\u8c56\u{1f627}\u80d8'});
let sampler144 = device1.createSampler({
  label: '\u03d9\uceb1\u695e\u0c44\u9ee9',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 60.33,
  maxAnisotropy: 16,
});
try {
renderBundleEncoder34.drawIndexed(6_797, 50, 7_248, 454_046_559, 849_994_193);
} catch {}
try {
commandEncoder88.copyBufferToTexture({
  /* bytesInLastRow: 644 widthInBlocks: 161 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 19808 */
  offset: 19808,
  buffer: buffer13,
}, {
  texture: texture155,
  mipLevel: 0,
  origin: {x: 28, y: 0, z: 1},
  aspect: 'all',
}, {width: 161, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder245.resolveQuerySet(querySet36, 239, 135, buffer15, 5120);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap13,
  origin: { x: 22, y: 4 },
  flipY: false,
}, {
  texture: texture74,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline245 = await device1.createComputePipelineAsync({
  label: '\ud201\u6fb8\u{1fcda}\u0aa9\u{1fb2a}\ua4c0\udfe6\u6597',
  layout: pipelineLayout24,
  compute: {module: shaderModule48, entryPoint: 'compute0', constants: {}},
});
let pipeline246 = await device1.createRenderPipelineAsync({
  layout: pipelineLayout24,
  multisample: {mask: 0x15a96531},
  fragment: {
  module: shaderModule29,
  entryPoint: 'fragment0',
  targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg32sint'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'less-equal', failOp: 'increment-wrap', depthFailOp: 'increment-wrap', passOp: 'replace'},
    stencilBack: {compare: 'equal', failOp: 'zero', depthFailOp: 'invert', passOp: 'increment-clamp'},
    stencilReadMask: 2660572989,
    stencilWriteMask: 1468105987,
    depthBias: 1704741410,
    depthBiasSlopeScale: 996.8595262270969,
  },
  vertex: {
    module: shaderModule29,
    buffers: [
      {arrayStride: 184, stepMode: 'instance', attributes: []},
      {arrayStride: 172, attributes: []},
      {
        arrayStride: 72,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 20, shaderLocation: 11},
          {format: 'float32x2', offset: 12, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', cullMode: 'back'},
});
let bindGroup106 = device1.createBindGroup({layout: bindGroupLayout84, entries: [{binding: 63, resource: sampler74}]});
let commandEncoder313 = device1.createCommandEncoder({label: '\u930f\u78d9\u073e\ub367'});
let textureView375 = texture210.createView({label: '\u6f7b\u0db1\u038f\u6579\u{1fa93}\u00c0\u0ddc\u074e\u5d71', baseMipLevel: 3, mipLevelCount: 1});
let renderBundleEncoder163 = device1.createRenderBundleEncoder({
  label: '\u4af9\u3f39\u0509\u{1f7ae}\u41b6\u{1f711}\u0b8c\u0f10',
  colorFormats: ['rg16uint', 'r32uint', 'r8unorm', undefined, 'rg8sint'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
try {
computePassEncoder105.setPipeline(pipeline164);
} catch {}
try {
commandEncoder250.copyBufferToBuffer(buffer15, 3060, buffer12, 3772, 1740);
} catch {}
let bindGroupLayout87 = device4.createBindGroupLayout({
  label: '\u030d\uf06e\u167e\u{1fbe3}\u12df\u{1faf9}\ub520\u0852\u6af2\u5be1\u0e0f',
  entries: [
    {
      binding: 167,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 17512070, hasDynamicOffset: false },
    },
    {binding: 618, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
    {
      binding: 317,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let textureView376 = texture188.createView({
  label: '\uf10f\u05a2\u5ee1\uafd9\udbdd\u046d\u3a84\u0acb\u6f6e',
  dimension: '2d-array',
  baseMipLevel: 2,
  mipLevelCount: 4,
  baseArrayLayer: 0,
  arrayLayerCount: 1,
});
try {
computePassEncoder108.end();
} catch {}
try {
commandEncoder256.resolveQuerySet(querySet95, 171, 26, buffer48, 1024);
} catch {}
let commandEncoder314 = device4.createCommandEncoder({});
let textureView377 = texture153.createView({
  label: '\uff2c\uca37\u{1fdc3}\u0068\u9d92\uaffb\ucee6\uc542\u6a0e\uc6e8',
  dimension: '2d-array',
  baseMipLevel: 5,
  mipLevelCount: 1,
});
try {
renderBundleEncoder101.setBindGroup(2, bindGroup85);
} catch {}
try {
renderBundleEncoder131.setVertexBuffer(2, buffer56, 4_912, 75_509);
} catch {}
try {
commandEncoder256.copyTextureToTexture({
  texture: texture153,
  mipLevel: 0,
  origin: {x: 27, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture127,
  mipLevel: 0,
  origin: {x: 26, y: 0, z: 0},
  aspect: 'all',
},
{width: 10, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
device4.queue.writeBuffer(buffer54, 6288, new Float32Array(10045));
} catch {}
let videoFrame35 = new VideoFrame(imageBitmap4, {timestamp: 0});
let shaderModule52 = device1.createShaderModule({
  label: '\u{1fe59}\ub2a8\u0bb6\u0ad0\uf002\u05b0\ue210',
  code: `

@compute @workgroup_size(3, 2, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S44 {
  @location(7) f0: vec2<u32>,
  @location(4) f1: f32,
  @location(9) f2: f32,
  @location(14) f3: i32,
  @location(11) f4: vec3<u32>,
  @location(13) f5: f32
}
struct FragmentOutput0 {
  @location(3) f0: vec2<i32>,
  @location(2) f1: vec4<i32>,
  @builtin(sample_mask) f2: u32,
  @location(1) f3: vec2<u32>,
  @location(0) f4: vec2<u32>
}

@fragment
fn fragment0(@location(1) a0: vec2<f16>, @location(10) a1: vec2<f32>, @location(5) a2: vec3<u32>, @location(3) a3: vec2<f32>, a4: S44) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S43 {
  @location(14) f0: vec2<f32>,
  @location(0) f1: vec3<i32>,
  @location(5) f2: f16,
  @location(10) f3: vec4<i32>,
  @location(9) f4: vec2<f16>,
  @location(7) f5: u32,
  @location(12) f6: vec4<f16>,
  @location(8) f7: vec2<f16>,
  @location(13) f8: f16,
  @location(1) f9: vec3<f16>
}
struct VertexOutput0 {
  @location(5) f261: vec3<u32>,
  @location(9) f262: f32,
  @location(4) f263: f32,
  @location(1) f264: vec2<f16>,
  @location(10) f265: vec2<f32>,
  @location(11) f266: vec3<u32>,
  @location(7) f267: vec2<u32>,
  @location(14) f268: i32,
  @location(15) f269: vec3<i32>,
  @location(13) f270: f32,
  @builtin(position) f271: vec4<f32>,
  @location(3) f272: vec2<f32>
}

@vertex
fn vertex0(@location(4) a0: vec4<f16>, @location(11) a1: vec2<i32>, @location(3) a2: vec3<u32>, a3: S43, @builtin(instance_index) a4: u32, @location(2) a5: vec4<f16>, @location(15) a6: vec3<u32>, @location(6) a7: vec4<u32>, @builtin(vertex_index) a8: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let renderBundleEncoder164 = device1.createRenderBundleEncoder({
  label: '\u2363\ua72b\u{1f844}\u{1fbd3}\u09fe\u1807\u0c00\ucbff\u4243',
  colorFormats: ['rgba8sint', 'rg16uint', 'rg32sint'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder47.setPipeline(pipeline136);
} catch {}
try {
renderBundleEncoder63.setIndexBuffer(buffer18, 'uint32', 39_320, 23_403);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(2, buffer13, 0);
} catch {}
try {
commandEncoder165.copyTextureToBuffer({
  texture: texture156,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 6600 */
  offset: 5280,
  bytesPerRow: 256,
  buffer: buffer13,
}, {width: 10, height: 6, depthOrArrayLayers: 1});
} catch {}
let pipeline247 = device1.createComputePipeline({
  label: '\u6485\u5a37\u08ac\u0159\u0c23',
  layout: pipelineLayout19,
  compute: {module: shaderModule48, entryPoint: 'compute0', constants: {}},
});
let buffer70 = device3.createBuffer({
  label: '\u{1ff82}\u07d6\u9020\u552c\u0802',
  size: 283492,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder315 = device3.createCommandEncoder({});
let commandBuffer77 = commandEncoder168.finish({label: '\u{1fa0f}\u98bf\uba4a\u{1fc19}\u44c1'});
let textureView378 = texture175.createView({label: '\u{1f994}\uc0f5\u6754\u7053\uf7db\u82e7\uaa0d\u8896\ua7bc', baseMipLevel: 7, mipLevelCount: 3});
try {
renderBundleEncoder104.setVertexBuffer(2, buffer64);
} catch {}
try {
commandEncoder287.copyBufferToBuffer(buffer47, 18144, buffer70, 96364, 15040);
} catch {}
try {
commandEncoder287.resolveQuerySet(querySet94, 76, 1695, buffer64, 26880);
} catch {}
let imageBitmap32 = await createImageBitmap(video33);
let commandEncoder316 = device5.createCommandEncoder({label: '\u{1fac2}\u006a'});
let textureView379 = texture162.createView({label: '\u91e1\u86f1\ue4d8\u7b41\ud165', baseMipLevel: 2});
let computePassEncoder157 = commandEncoder316.beginComputePass({label: '\u37d0\ubc8c\u7e58\u0e6d\ube39\u{1fca5}\u87c8\u0c5e\u01d2\u6c98'});
let externalTexture154 = device5.importExternalTexture({label: '\u0db5\u7b9a\u{1f715}\u82bc', source: videoFrame21, colorSpace: 'display-p3'});
try {
renderBundleEncoder152.setPipeline(pipeline237);
} catch {}
let commandEncoder317 = device2.createCommandEncoder({label: '\u{1fd80}\u{1f66b}\u99eb'});
let textureView380 = texture167.createView({label: '\ueeed\u560f\u{1f849}', dimension: '2d-array', baseMipLevel: 0});
let renderBundle180 = renderBundleEncoder154.finish();
try {
renderBundleEncoder138.setBindGroup(0, bindGroup47);
} catch {}
try {
commandEncoder276.resolveQuerySet(querySet74, 158, 76, buffer65, 256);
} catch {}
try {
device2.queue.writeBuffer(buffer65, 16736, new Int16Array(31950), 22629, 2384);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture140,
  mipLevel: 4,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer22), /* required buffer size: 7_036_086 */
{offset: 750, bytesPerRow: 396, rowsPerImage: 189}, {width: 47, height: 0, depthOrArrayLayers: 95});
} catch {}
let commandEncoder318 = device4.createCommandEncoder({});
let textureView381 = texture166.createView({label: '\u3608\ubd61\u5310\ua147\u3af8\u0f90', arrayLayerCount: 1});
try {
computePassEncoder125.end();
} catch {}
try {
buffer48.unmap();
} catch {}
try {
gpuCanvasContext2.configure({
  device: device4,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let textureView382 = texture201.createView({label: '\ude9f\u{1fcc6}\u{1fd67}\u97a3\u0dcb\u0416\u9ab5\u2dbe\u3651\u0a75'});
let renderBundle181 = renderBundleEncoder145.finish({label: '\u67c7\ub24c\u{1faa7}\u08ca\u75cf\ua84c\u{1fb5b}\u1783\u{1fc91}'});
try {
commandEncoder288.resolveQuerySet(querySet131, 7, 12, buffer60, 19456);
} catch {}
try {
gpuCanvasContext29.configure({
  device: device6,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let offscreenCanvas39 = new OffscreenCanvas(168, 387);
let video49 = await videoWithData();
let imageData49 = new ImageData(104, 16);
let videoFrame36 = new VideoFrame(imageBitmap5, {timestamp: 0});
try {
offscreenCanvas39.getContext('webgl2');
} catch {}
let querySet152 = device3.createQuerySet({label: '\u06c3\u0eee\u2d2a\u0967\u4760\u04df\u{1fef5}', type: 'occlusion', count: 3220});
let textureView383 = texture122.createView({label: '\u4e9f\u{1f78c}\ucdfe\ud07b\u341e\u{1fb09}', dimension: '2d-array', format: 'rgba8unorm-srgb'});
let externalTexture155 = device3.importExternalTexture({label: '\u944a\u3567\u9688\u4e21\u{1f8bd}\ub7e7\u0783\u310d\u0143\u{1f914}', source: video32});
try {
computePassEncoder120.setPipeline(pipeline230);
} catch {}
try {
commandEncoder237.copyBufferToBuffer(buffer47, 159516, buffer70, 157476, 7956);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture131,
  mipLevel: 4,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(223_570), /* required buffer size: 223_570 */
{offset: 480, bytesPerRow: 143, rowsPerImage: 260}, {width: 5, height: 1, depthOrArrayLayers: 7});
} catch {}
let pipeline248 = device3.createRenderPipeline({
  label: '\u1408\u{1fe6d}\udb44\u0b7b\u5c63\uf99c\u5cb3\u8b18\u1dd3\ub5c2',
  layout: pipelineLayout33,
  fragment: {
  module: shaderModule45,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg32uint', writeMask: GPUColorWrite.RED}, {format: 'rg16sint', writeMask: 0}, {format: 'r32uint', writeMask: GPUColorWrite.ALL}],
},
  vertex: {
    module: shaderModule45,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 112,
        stepMode: 'vertex',
        attributes: [{format: 'uint8x2', offset: 30, shaderLocation: 5}],
      },
      {arrayStride: 80, stepMode: 'instance', attributes: []},
      {
        arrayStride: 616,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 36, shaderLocation: 2},
          {format: 'sint16x4', offset: 24, shaderLocation: 13},
          {format: 'uint8x4', offset: 212, shaderLocation: 10},
          {format: 'sint32x3', offset: 104, shaderLocation: 15},
          {format: 'sint16x2', offset: 0, shaderLocation: 0},
          {format: 'unorm16x2', offset: 180, shaderLocation: 12},
          {format: 'float32', offset: 0, shaderLocation: 7},
          {format: 'unorm8x4', offset: 104, shaderLocation: 11},
          {format: 'snorm16x4', offset: 320, shaderLocation: 6},
        ],
      },
      {arrayStride: 484, attributes: []},
      {
        arrayStride: 424,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 64, shaderLocation: 3}],
      },
      {arrayStride: 252, stepMode: 'instance', attributes: []},
      {arrayStride: 44, attributes: []},
      {
        arrayStride: 460,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 0, shaderLocation: 8},
          {format: 'uint32', offset: 396, shaderLocation: 4},
          {format: 'unorm8x2', offset: 42, shaderLocation: 1},
          {format: 'unorm16x4', offset: 92, shaderLocation: 9},
          {format: 'float32x2', offset: 12, shaderLocation: 14},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'front'},
});
let pipelineLayout34 = device2.createPipelineLayout({
  label: '\u41e8\uc956\u0401\uf84b\u8f0e\ud0d3',
  bindGroupLayouts: [bindGroupLayout75, bindGroupLayout50],
});
let commandEncoder319 = device2.createCommandEncoder({label: '\u8f2b\u{1fe83}\u05a3\u{1fd11}\u0549'});
let querySet153 = device2.createQuerySet({
  label: '\u7ada\ud12b\u5a1f\ua82d\u5810\u6661\u0b56\u423d\u0ea6\u07e1\u025e',
  type: 'occlusion',
  count: 3493,
});
let textureView384 = texture132.createView({label: '\u467f\u2bc6\u086c\ud889\u04bc', dimension: '2d-array', aspect: 'all', baseMipLevel: 1});
let renderBundle182 = renderBundleEncoder150.finish({label: '\uea09\u0229\u05bd\u6afd\u04fc'});
try {
commandEncoder283.copyBufferToBuffer(buffer41, 10780, buffer43, 4340, 948);
} catch {}
try {
commandEncoder300.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 61608 */
  offset: 61608,
  buffer: buffer33,
}, {
  texture: texture85,
  mipLevel: 0,
  origin: {x: 9, y: 0, z: 0},
  aspect: 'all',
}, {width: 20, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder226.copyTextureToTexture({
  texture: texture181,
  mipLevel: 2,
  origin: {x: 0, y: 2, z: 1},
  aspect: 'all',
},
{
  texture: texture117,
  mipLevel: 2,
  origin: {x: 10, y: 0, z: 28},
  aspect: 'all',
},
{width: 7, height: 0, depthOrArrayLayers: 16});
} catch {}
try {
window.someLabel = externalTexture28.label;
} catch {}
let buffer71 = device1.createBuffer({
  label: '\u5947\uacc9\ub487\u04a9',
  size: 70432,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let commandEncoder320 = device1.createCommandEncoder({label: '\u{1fcc2}\u2141\u{1f7ce}\u{1ff43}\ude51\u0736\u7a18\u68fa\u86b6'});
let querySet154 = device1.createQuerySet({label: '\u497d\u086a\ubbda\u0068\u368e', type: 'occlusion', count: 2069});
let textureView385 = texture52.createView({
  label: '\u635d\u{1fbc8}\ub8c7\u{1fdb6}\u28bb\u7fa9\u{1f6d0}\u69d1\u{1f9ec}',
  mipLevelCount: 5,
  baseArrayLayer: 90,
  arrayLayerCount: 75,
});
let computePassEncoder158 = commandEncoder182.beginComputePass();
try {
renderBundleEncoder144.setVertexBuffer(3, buffer36, 6_408, 13_426);
} catch {}
let promise82 = buffer37.mapAsync(GPUMapMode.WRITE, 0, 3904);
try {
adapter0.label = '\u55d6\udfbc\u0c65\u0b98\u{1f790}\u39da\ua58b\ub552\u090f\u69b8\u{1f869}';
} catch {}
let commandEncoder321 = device4.createCommandEncoder({});
let textureView386 = texture192.createView({
  label: '\u0471\u5331\u03d8\u{1f7b8}\u{1fc51}\u0b95\u9781',
  dimension: '2d-array',
  aspect: 'all',
  baseMipLevel: 1,
});
try {
computePassEncoder151.setPipeline(pipeline154);
} catch {}
try {
renderBundleEncoder131.setVertexBuffer(3, buffer56);
} catch {}
try {
commandEncoder308.copyBufferToBuffer(buffer48, 204360, buffer30, 106488, 952);
} catch {}
try {
commandEncoder321.copyTextureToTexture({
  texture: texture153,
  mipLevel: 8,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture127,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device4.queue.writeBuffer(buffer54, 36380, new DataView(new ArrayBuffer(56667)), 36436, 1052);
} catch {}
let imageBitmap33 = await createImageBitmap(offscreenCanvas23);
try {
adapter5.label = '\u0a9d\u0abf';
} catch {}
let shaderModule53 = device3.createShaderModule({
  label: '\u752c\u05f4\uf319\u0dd5\u9501',
  code: `@group(2) @binding(381)
var<storage, read_write> local17: array<u32>;
@group(0) @binding(75)
var<storage, read_write> type14: array<u32>;
@group(2) @binding(655)
var<storage, read_write> parameter20: array<u32>;
@group(1) @binding(132)
var<storage, read_write> field15: array<u32>;
@group(2) @binding(132)
var<storage, read_write> field16: array<u32>;
@group(1) @binding(381)
var<storage, read_write> n23: array<u32>;

@compute @workgroup_size(2, 2, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S46 {
  @builtin(sample_mask) f0: u32,
  @location(2) f1: f32,
  @location(4) f2: vec2<f32>,
  @location(7) f3: vec4<f16>,
  @location(6) f4: f32,
  @location(14) f5: i32
}
struct FragmentOutput0 {
  @location(4) f0: vec4<i32>,
  @location(2) f1: vec4<u32>,
  @location(1) f2: vec4<f32>,
  @location(6) f3: vec3<f32>,
  @location(5) f4: vec2<u32>,
  @location(0) f5: vec3<i32>
}

@fragment
fn fragment0(@location(11) a0: vec3<f16>, @location(5) a1: vec4<i32>, @location(12) a2: vec4<u32>, @location(3) a3: u32, @location(8) a4: u32, @location(10) a5: vec3<u32>, @location(13) a6: vec2<f32>, @location(0) a7: vec4<f16>, @location(15) a8: vec4<f32>, @builtin(position) a9: vec4<f32>, @location(9) a10: vec4<u32>, @location(1) a11: vec2<u32>, a12: S46, @builtin(front_facing) a13: bool) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S45 {
  @location(2) f0: i32,
  @location(5) f1: vec4<f32>,
  @location(9) f2: vec2<i32>,
  @location(1) f3: vec3<f32>,
  @location(15) f4: vec3<f32>,
  @location(0) f5: vec3<i32>,
  @location(6) f6: vec3<f16>
}
struct VertexOutput0 {
  @location(5) f273: vec4<i32>,
  @location(3) f274: u32,
  @location(12) f275: vec4<u32>,
  @location(0) f276: vec4<f16>,
  @location(10) f277: vec3<u32>,
  @location(4) f278: vec2<f32>,
  @location(15) f279: vec4<f32>,
  @location(1) f280: vec2<u32>,
  @location(13) f281: vec2<f32>,
  @location(9) f282: vec4<u32>,
  @location(14) f283: i32,
  @location(11) f284: vec3<f16>,
  @location(2) f285: f32,
  @location(6) f286: f32,
  @location(8) f287: u32,
  @builtin(position) f288: vec4<f32>,
  @location(7) f289: vec4<f16>
}

@vertex
fn vertex0(@location(3) a0: vec4<u32>, @builtin(vertex_index) a1: u32, @location(12) a2: vec3<f16>, @location(8) a3: u32, @location(10) a4: vec4<f16>, @location(13) a5: i32, @location(4) a6: vec4<f16>, @builtin(instance_index) a7: u32, @location(11) a8: i32, a9: S45, @location(14) a10: vec4<f32>, @location(7) a11: f32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
try {
commandEncoder281.copyBufferToBuffer(buffer47, 148840, buffer70, 222560, 29756);
} catch {}
let canvas45 = document.createElement('canvas');
let commandEncoder322 = device4.createCommandEncoder({label: '\u4d63\uf15e\u{1fe5d}\u0719\ue9d9\u31c1'});
let commandBuffer78 = commandEncoder256.finish({});
let renderBundle183 = renderBundleEncoder147.finish({label: '\u013a\u0c1a\u8f91\u02a3\u01da\u002f\u05ec\u0134\u03cb\u58f8\u2b5d'});
let sampler145 = device4.createSampler({
  label: '\u11b1\u00c1\u{1fa5d}\uae01\u0d20\u07cd\u08da',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 93.66,
  lodMaxClamp: 97.92,
  maxAnisotropy: 1,
});
try {
computePassEncoder129.setPipeline(pipeline165);
} catch {}
try {
renderBundleEncoder131.setBindGroup(2, bindGroup85, new Uint32Array(6897), 354, 0);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let bindGroupLayout88 = device6.createBindGroupLayout({label: '\u0679\u{1f8f2}\u{1fc09}\u0eee\u1f79\ue6f8\u0465\u{1f670}', entries: []});
let commandBuffer79 = commandEncoder288.finish({label: '\ud53f\u{1fd8b}\u{1f840}\uf211\ud835\u{1fbd6}\ud4d4\u{1fe85}'});
let textureView387 = texture193.createView({label: '\u0ee8\u0442\u{1f7d1}\ub494\u88e1\u00d9\u456e\uf175\u0b70', baseMipLevel: 2});
try {
renderBundleEncoder142.setVertexBuffer(5, buffer60, 9_704, 89_068);
} catch {}
try {
commandEncoder298.resolveQuerySet(querySet131, 2, 1, buffer60, 3584);
} catch {}
gc();
let img30 = await imageWithData(33, 185, '#d6719483', '#ffe39f71');
let texture211 = device0.createTexture({
  label: '\u71c7\u8164\u{1fb0d}\uf8a0\u0b9a\u76e3\u4d0c\ueca7',
  size: [660, 480, 124],
  mipLevelCount: 4,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
let renderBundleEncoder165 = device0.createRenderBundleEncoder({
  label: '\u8c90\u0c56\u0af0\u0121\u9e28\u0fd4',
  colorFormats: ['rgba8unorm'],
  sampleCount: 4,
  depthReadOnly: true,
});
let renderBundle184 = renderBundleEncoder24.finish({label: '\u0bdf\u{1fbfc}'});
try {
computePassEncoder54.dispatchWorkgroups(2, 2, 3);
} catch {}
try {
computePassEncoder33.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder13.setScissorRect(17, 66, 137, 1);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer9, 75_764);
} catch {}
try {
renderBundleEncoder160.setBindGroup(2, bindGroup14);
} catch {}
try {
renderBundleEncoder50.drawIndexed(983, 80, 976, 524_950_384, 110_766_906);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer44, 3_520);
} catch {}
try {
renderBundleEncoder29.setIndexBuffer(buffer35, 'uint32', 108, 2_976);
} catch {}
try {
renderBundleEncoder50.setPipeline(pipeline135);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(4, buffer4, 0, 140);
} catch {}
try {
renderPassEncoder18.insertDebugMarker('\u0dfd');
} catch {}
try {
device0.queue.writeBuffer(buffer34, 29020, new DataView(new ArrayBuffer(32294)), 19462, 436);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 16, y: 6, z: 3},
  aspect: 'all',
}, new Uint32Array(arrayBuffer12), /* required buffer size: 123_391 */
{offset: 393, bytesPerRow: 785}, {width: 269, height: 157, depthOrArrayLayers: 1});
} catch {}
try {
canvas45.getContext('webgl');
} catch {}
let texture212 = device1.createTexture({
  label: '\u8a34\u1b60\u043f\uf93f\u{1f90b}\uad27\ua1db\u0d23\u{1fc0d}\u65b8\ubafc',
  size: [640, 1, 142],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32sint', 'rgba32sint'],
});
let textureView388 = texture44.createView({label: '\u8d50\uea59\u8b37\u3dfd\u{1f7f1}', baseMipLevel: 1, arrayLayerCount: 1});
try {
computePassEncoder105.setPipeline(pipeline200);
} catch {}
try {
commandEncoder165.copyBufferToBuffer(buffer15, 10052, buffer12, 3628, 1056);
} catch {}
try {
commandEncoder284.resolveQuerySet(querySet52, 1548, 786, buffer15, 4608);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture116,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 7},
  aspect: 'all',
}, new ArrayBuffer(228_106), /* required buffer size: 228_106 */
{offset: 278, bytesPerRow: 193, rowsPerImage: 234}, {width: 11, height: 11, depthOrArrayLayers: 6});
} catch {}
let bindGroup107 = device1.createBindGroup({
  label: '\u2505\u0c4d\u1821\u11c1\u{1f6ee}\u0340\u7353\u0f3a\u{1f85d}',
  layout: bindGroupLayout45,
  entries: [
    {binding: 424, resource: externalTexture46},
    {binding: 379, resource: {buffer: buffer19, offset: 9216, size: 2368}},
    {binding: 377, resource: externalTexture30},
  ],
});
let commandEncoder323 = device1.createCommandEncoder({});
let texture213 = device1.createTexture({
  label: '\u9823\u0c20\u7841\u{1fd7b}\u5643\u04f3\u3797\u827c\uc389\ue162\uaa89',
  size: [75, 24, 66],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView389 = texture46.createView({
  label: '\uf249\u{1f8e7}\u05cb\u0bdd\u3d34\u{1f98c}\u0ab6\u36c5\u37dd\u34f7',
  dimension: '2d',
  baseMipLevel: 1,
  mipLevelCount: 4,
  baseArrayLayer: 23,
});
try {
renderBundleEncoder34.draw(0, 1, 1, 4);
} catch {}
try {
renderBundleEncoder34.setVertexBuffer(7, buffer12);
} catch {}
try {
commandEncoder250.copyBufferToTexture({
  /* bytesInLastRow: 1020 widthInBlocks: 255 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 15404 */
  offset: 15404,
  bytesPerRow: 1024,
  buffer: buffer36,
}, {
  texture: texture155,
  mipLevel: 0,
  origin: {x: 29, y: 0, z: 0},
  aspect: 'all',
}, {width: 255, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder222.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3664 */
  offset: 3664,
  rowsPerImage: 69,
  buffer: buffer12,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let pipeline249 = device1.createRenderPipeline({
  label: '\u0438\u7e5d\u0c2a\u06d3\u{1fba7}\ua40e\u01b9\u7a4f',
  layout: pipelineLayout5,
  multisample: {mask: 0x79ea73aa},
  fragment: {
  module: shaderModule32,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'r32sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less',
    stencilFront: {compare: 'equal', failOp: 'increment-clamp', depthFailOp: 'increment-wrap', passOp: 'increment-clamp'},
    stencilBack: {failOp: 'increment-wrap', depthFailOp: 'replace', passOp: 'replace'},
    stencilWriteMask: 2140680576,
    depthBiasSlopeScale: 822.2118534395172,
    depthBiasClamp: 676.1895839689081,
  },
  vertex: {
    module: shaderModule32,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1380,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 376, shaderLocation: 13},
          {format: 'uint8x4', offset: 168, shaderLocation: 10},
          {format: 'float32x4', offset: 64, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 128,
        attributes: [
          {format: 'snorm16x2', offset: 12, shaderLocation: 14},
          {format: 'unorm8x2', offset: 20, shaderLocation: 15},
        ],
      },
      {arrayStride: 80, attributes: [{format: 'snorm8x2', offset: 0, shaderLocation: 11}]},
      {arrayStride: 1516, stepMode: 'instance', attributes: []},
      {
        arrayStride: 64,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 4, shaderLocation: 12}],
      },
      {arrayStride: 228, stepMode: 'instance', attributes: []},
      {arrayStride: 144, attributes: []},
      {
        arrayStride: 60,
        attributes: [
          {format: 'sint32x4', offset: 20, shaderLocation: 8},
          {format: 'uint16x4', offset: 4, shaderLocation: 4},
          {format: 'uint32', offset: 0, shaderLocation: 5},
          {format: 'sint16x4', offset: 4, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'front'},
});
let commandEncoder324 = device6.createCommandEncoder();
let texture214 = device6.createTexture({
  size: [10, 2, 2027],
  mipLevelCount: 7,
  dimension: '3d',
  format: 'r16sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder166 = device6.createRenderBundleEncoder({colorFormats: ['r16sint', 'rgba16sint', 'rgb10a2uint', 'rgb10a2uint'], depthReadOnly: true});
try {
renderBundleEncoder142.setVertexBuffer(2, buffer60, 47_968);
} catch {}
try {
commandEncoder324.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 134296 */
  offset: 8588,
  bytesPerRow: 256,
  rowsPerImage: 245,
  buffer: buffer60,
}, {
  texture: texture196,
  mipLevel: 1,
  origin: {x: 7, y: 1, z: 0},
  aspect: 'all',
}, {width: 3, height: 2, depthOrArrayLayers: 3});
} catch {}
try {
commandEncoder324.copyTextureToTexture({
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext23.unconfigure();
} catch {}
let video50 = await videoWithData();
let bindGroup108 = device1.createBindGroup({
  label: '\uec4c\u0dd4\uabd5\u0c3c\uee49\u75a5\u0b3d\uc073',
  layout: bindGroupLayout45,
  entries: [
    {binding: 379, resource: {buffer: buffer36, offset: 34048, size: 7844}},
    {binding: 424, resource: externalTexture28},
    {binding: 377, resource: externalTexture44},
  ],
});
let textureView390 = texture47.createView({});
let computePassEncoder159 = commandEncoder269.beginComputePass({});
try {
renderBundleEncoder105.setBindGroup(3, bindGroup61);
} catch {}
try {
commandEncoder323.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 294296 */
  offset: 5016,
  bytesPerRow: 256,
  rowsPerImage: 226,
  buffer: buffer18,
}, {
  texture: texture116,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 0, depthOrArrayLayers: 6});
} catch {}
try {
commandEncoder117.copyTextureToTexture({
  texture: texture171,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture171,
  mipLevel: 0,
  origin: {x: 0, y: 8, z: 0},
  aspect: 'all',
},
{width: 76, height: 27, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder245.resolveQuerySet(querySet59, 12, 57, buffer15, 4608);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture78,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(72), /* required buffer size: 40 */
{offset: 40, bytesPerRow: 57}, {width: 1, height: 5, depthOrArrayLayers: 0});
} catch {}
let pipeline250 = device1.createRenderPipeline({
  label: '\uef6c\u0bf1\ufb14',
  layout: pipelineLayout19,
  multisample: {count: 4, mask: 0x55db5033},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less',
    stencilFront: {compare: 'less-equal', failOp: 'invert', passOp: 'increment-wrap'},
    stencilBack: {failOp: 'increment-wrap', depthFailOp: 'decrement-wrap', passOp: 'replace'},
    stencilReadMask: 1140210751,
    stencilWriteMask: 2243577227,
  },
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 696, stepMode: 'instance', attributes: []},
      {
        arrayStride: 24,
        attributes: [
          {format: 'uint16x2', offset: 0, shaderLocation: 7},
          {format: 'uint32', offset: 0, shaderLocation: 15},
          {format: 'unorm8x2', offset: 0, shaderLocation: 0},
          {format: 'uint32x4', offset: 0, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 192,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 8, shaderLocation: 14},
          {format: 'uint32x2', offset: 68, shaderLocation: 1},
          {format: 'uint32', offset: 76, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 260,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 18, shaderLocation: 13},
          {format: 'sint8x2', offset: 28, shaderLocation: 10},
          {format: 'uint32x4', offset: 96, shaderLocation: 11},
          {format: 'uint32x3', offset: 72, shaderLocation: 6},
        ],
      },
      {arrayStride: 184, stepMode: 'instance', attributes: []},
      {arrayStride: 128, attributes: []},
      {arrayStride: 88, attributes: []},
      {
        arrayStride: 772,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 2},
          {format: 'float32', offset: 36, shaderLocation: 3},
          {format: 'float32x2', offset: 124, shaderLocation: 12},
          {format: 'uint8x2', offset: 230, shaderLocation: 4},
          {format: 'unorm16x2', offset: 40, shaderLocation: 5},
        ],
      },
    ],
  },
});
let canvas46 = document.createElement('canvas');
let commandEncoder325 = device6.createCommandEncoder({label: '\u{1f658}\u6ad9\u0482\uf51c\u{1fe7c}\u17ea\u46d6\u{1f791}\uf7b8'});
let sampler146 = device6.createSampler({
  label: '\u6b7e\u{1f74c}\ue4be\ub6e8',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 95.47,
  lodMaxClamp: 95.79,
  maxAnisotropy: 10,
});
try {
renderBundleEncoder166.setVertexBuffer(0, buffer60, 9_660, 21_201);
} catch {}
try {
commandEncoder325.copyBufferToTexture({
  /* bytesInLastRow: 2212 widthInBlocks: 553 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5164 */
  offset: 5164,
  rowsPerImage: 77,
  buffer: buffer60,
}, {
  texture: texture201,
  mipLevel: 0,
  origin: {x: 117, y: 0, z: 0},
  aspect: 'all',
}, {width: 553, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder325.clearBuffer(buffer60, 134452, 8676);
} catch {}
try {
canvas46.getContext('webgl');
} catch {}
let commandEncoder326 = device5.createCommandEncoder({label: '\u0fbd\udecc\u02e7\uc44d\u02b7\uf72e\u01ca\uf8b9\u0228\u03c3\u0f72'});
try {
  await buffer50.mapAsync(GPUMapMode.WRITE, 37944, 7296);
} catch {}
try {
commandEncoder307.copyTextureToTexture({
  texture: texture174,
  mipLevel: 0,
  origin: {x: 24, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture169,
  mipLevel: 0,
  origin: {x: 1183, y: 0, z: 0},
  aspect: 'all',
},
{width: 299, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline251 = device5.createRenderPipeline({
  label: '\ub9c0\uaac9\u40ff\u0dc5\u610c\u{1fd50}\u1cba\ud79d\u{1f83d}',
  layout: pipelineLayout22,
  multisample: {count: 4, mask: 0x72d15664},
  fragment: {
  module: shaderModule51,
  entryPoint: 'fragment0',
  targets: [{format: 'rg16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba32float', writeMask: 0}, {format: 'r32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED,
}, {format: 'rg8uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule51,
    buffers: [
      {
        arrayStride: 744,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 3},
          {format: 'uint16x4', offset: 0, shaderLocation: 15},
          {format: 'sint32x4', offset: 224, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 340,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 116, shaderLocation: 9},
          {format: 'float32x3', offset: 36, shaderLocation: 13},
          {format: 'snorm16x4', offset: 104, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 456,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm16x4', offset: 108, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 44, shaderLocation: 11},
          {format: 'sint32x2', offset: 60, shaderLocation: 0},
          {format: 'unorm16x4', offset: 52, shaderLocation: 2},
          {format: 'snorm16x2', offset: 0, shaderLocation: 1},
          {format: 'float32x3', offset: 64, shaderLocation: 12},
        ],
      },
      {arrayStride: 96, stepMode: 'instance', attributes: []},
      {arrayStride: 480, stepMode: 'instance', attributes: []},
      {arrayStride: 792, stepMode: 'instance', attributes: []},
      {arrayStride: 468, stepMode: 'instance', attributes: []},
      {
        arrayStride: 124,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 0, shaderLocation: 4},
          {format: 'unorm16x4', offset: 16, shaderLocation: 10},
          {format: 'sint32x4', offset: 16, shaderLocation: 7},
          {format: 'float16x2', offset: 20, shaderLocation: 5},
        ],
      },
    ],
  },
});
let canvas47 = document.createElement('canvas');
let imageData50 = new ImageData(60, 52);
let commandEncoder327 = device5.createCommandEncoder({label: '\u6da0\u0e34\u098c\u0c28\u383f\u940c\u26df'});
let textureView391 = texture160.createView({});
let renderBundle185 = renderBundleEncoder152.finish();
try {
computePassEncoder145.setPipeline(pipeline234);
} catch {}
let arrayBuffer24 = buffer50.getMappedRange(38512, 188);
try {
buffer50.destroy();
} catch {}
try {
buffer50.unmap();
} catch {}
canvas7.height = 1274;
let commandEncoder328 = device5.createCommandEncoder();
let textureView392 = texture203.createView({label: '\ua763\u{1f733}', dimension: '2d', mipLevelCount: 6, baseArrayLayer: 101, arrayLayerCount: 1});
let computePassEncoder160 = commandEncoder307.beginComputePass({label: '\u{1f776}\uede1\u{1ff11}\u{1ffc2}\u63d1\u21d9\u1cca'});
let renderBundleEncoder167 = device5.createRenderBundleEncoder({
  label: '\u05e9\u75e5\u{1fe7c}\u{1fd03}\u7db0\u{1fe41}\ucd05\u4915\u8b8e\u{1fd8d}',
  colorFormats: ['rg16uint', 'rgba32float', 'r32sint', 'r8unorm', 'rg8uint'],
  depthReadOnly: true,
});
try {
commandEncoder328.copyBufferToTexture({
  /* bytesInLastRow: 212 widthInBlocks: 106 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 18760 */
  offset: 18760,
  bytesPerRow: 256,
  rowsPerImage: 684,
  buffer: buffer50,
}, {
  texture: texture203,
  mipLevel: 0,
  origin: {x: 10, y: 30, z: 19},
  aspect: 'all',
}, {width: 106, height: 607, depthOrArrayLayers: 0});
} catch {}
let img31 = await imageWithData(202, 281, '#68f107b7', '#70fad429');
try {
canvas47.getContext('webgpu');
} catch {}
let computePassEncoder161 = commandEncoder214.beginComputePass({label: '\u0959\u{1f60f}\u02bb'});
try {
computePassEncoder127.setPipeline(pipeline230);
} catch {}
try {
renderBundleEncoder135.setVertexBuffer(1, buffer64, 20_012, 20_170);
} catch {}
try {
commandEncoder217.clearBuffer(buffer38, 89516, 46316);
} catch {}
let pipeline252 = await device3.createComputePipelineAsync({
  label: '\u2605\u0ed5\u05a1\ued8f\u{1fa16}\ufc3b',
  layout: pipelineLayout33,
  compute: {module: shaderModule45, entryPoint: 'compute0', constants: {}},
});
let promise83 = device3.createRenderPipelineAsync({
  layout: pipelineLayout15,
  fragment: {
  module: shaderModule49,
  entryPoint: 'fragment0',
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg32uint', writeMask: 0}, {
  format: 'rg16sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r32uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule49,
    buffers: [
      {
        arrayStride: 360,
        stepMode: 'instance',
        attributes: [{format: 'float16x2', offset: 16, shaderLocation: 10}],
      },
      {
        arrayStride: 180,
        attributes: [
          {format: 'sint32x2', offset: 0, shaderLocation: 2},
          {format: 'unorm8x4', offset: 20, shaderLocation: 6},
        ],
      },
      {arrayStride: 444, stepMode: 'instance', attributes: []},
      {
        arrayStride: 424,
        attributes: [
          {format: 'uint32x4', offset: 80, shaderLocation: 0},
          {format: 'unorm16x2', offset: 36, shaderLocation: 1},
        ],
      },
      {arrayStride: 788, stepMode: 'instance', attributes: []},
      {
        arrayStride: 208,
        attributes: [
          {format: 'float32x2', offset: 72, shaderLocation: 7},
          {format: 'float32', offset: 4, shaderLocation: 4},
        ],
      },
      {arrayStride: 552, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 308, shaderLocation: 5},
          {format: 'sint8x4', offset: 212, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 312, shaderLocation: 3},
          {format: 'float32', offset: 76, shaderLocation: 11},
          {format: 'uint32x2', offset: 264, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw'},
});
let renderBundle186 = renderBundleEncoder156.finish({label: '\u04f4\u414d\ub858\u0497\u79ed\u02f7\ueb2e\ufd0b\uffbb\u{1f9d2}'});
let externalTexture156 = device2.importExternalTexture({label: '\u0c02\ud9fe\u{1f68a}\ub31f\ua9ac', source: video27});
try {
renderBundleEncoder69.setPipeline(pipeline133);
} catch {}
try {
renderBundleEncoder76.setVertexBuffer(0, buffer43, 2_012, 567);
} catch {}
try {
commandEncoder285.copyBufferToBuffer(buffer41, 5780, buffer65, 18616, 11208);
} catch {}
try {
commandEncoder291.clearBuffer(buffer62, 184708, 56176);
} catch {}
try {
gpuCanvasContext38.configure({
  device: device2,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let bindGroupLayout89 = device4.createBindGroupLayout({
  label: '\u990a\ud757\ue6e6\uca71\u0463\u{1f7c9}',
  entries: [
    {binding: 541, visibility: 0, externalTexture: {}},
    {
      binding: 894,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 6,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let renderBundleEncoder168 = device4.createRenderBundleEncoder({
  label: '\u0cb9\u5b05\u529e',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: true,
});
try {
renderBundleEncoder129.setIndexBuffer(buffer48, 'uint16', 10_434, 16_236);
} catch {}
try {
renderBundleEncoder93.setVertexBuffer(6, buffer56);
} catch {}
try {
commandEncoder321.copyTextureToBuffer({
  texture: texture125,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 10936 */
  offset: 10936,
  bytesPerRow: 0,
  buffer: buffer54,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder321.clearBuffer(buffer30, 133704, 24024);
} catch {}
let img32 = await imageWithData(177, 265, '#55d0d0e4', '#66eb65ee');
let querySet155 = device4.createQuerySet({type: 'occlusion', count: 2499});
let textureView393 = texture163.createView({label: '\uc606\ud162\ucc85', baseMipLevel: 5, mipLevelCount: 1});
let sampler147 = device4.createSampler({addressModeW: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 96.81});
try {
computePassEncoder151.setPipeline(pipeline186);
} catch {}
try {
renderBundleEncoder168.setPipeline(pipeline166);
} catch {}
try {
renderBundleEncoder101.setVertexBuffer(2, buffer56, 121_052, 1_655);
} catch {}
try {
commandEncoder243.copyTextureToTexture({
  texture: texture153,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture136,
  mipLevel: 4,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder321.resolveQuerySet(querySet143, 71, 1062, buffer56, 85760);
} catch {}
document.body.prepend(video1);
let texture215 = device2.createTexture({
  label: '\u0158\u002f\u04a4\u{1f77a}\u3467\u0f84\u84aa',
  size: [240, 24, 6],
  mipLevelCount: 7,
  sampleCount: 1,
  dimension: '3d',
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm'],
});
let renderBundle187 = renderBundleEncoder109.finish({});
try {
renderBundleEncoder69.setVertexBuffer(0, buffer43, 0, 2_048);
} catch {}
try {
commandEncoder188.resolveQuerySet(querySet86, 4, 2, buffer68, 7936);
} catch {}
try {
computePassEncoder137.insertDebugMarker('\u7248');
} catch {}
try {
device2.queue.writeBuffer(buffer33, 31600, new BigUint64Array(12648), 8361, 292);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture108,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(arrayBuffer15), /* required buffer size: 66_770 */
{offset: 184, bytesPerRow: 50, rowsPerImage: 83}, {width: 9, height: 4, depthOrArrayLayers: 17});
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise82;
} catch {}
document.body.prepend(canvas37);
let videoFrame37 = new VideoFrame(img30, {timestamp: 0});
let promise84 = adapter3.requestAdapterInfo();
try {
computePassEncoder107.setBindGroup(3, bindGroup69);
} catch {}
try {
renderBundleEncoder126.setVertexBuffer(7, buffer64);
} catch {}
try {
commandEncoder315.copyBufferToBuffer(buffer47, 116184, buffer64, 210248, 6560);
} catch {}
try {
commandEncoder271.copyTextureToBuffer({
  texture: texture183,
  mipLevel: 3,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 14388 */
  offset: 14388,
  bytesPerRow: 512,
  buffer: buffer47,
}, {width: 11, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline253 = device3.createRenderPipeline({
  label: '\u00ee\ueb42\u42d1\u1e72\u47f6\u{1f765}\u004f\u09e7\u{1fc24}',
  layout: pipelineLayout25,
  multisample: {mask: 0x5baa495b},
  fragment: {
  module: shaderModule53,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, undefined, {format: 'rgba8sint', writeMask: 0}, {format: 'rg32uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'dst', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: 0,
}],
},
  vertex: {
    module: shaderModule53,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 360,
        attributes: [
          {format: 'uint8x2', offset: 54, shaderLocation: 3},
          {format: 'sint32x4', offset: 12, shaderLocation: 11},
          {format: 'unorm16x2', offset: 24, shaderLocation: 4},
          {format: 'sint8x4', offset: 72, shaderLocation: 0},
          {format: 'unorm10-10-10-2', offset: 36, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 688,
        stepMode: 'instance',
        attributes: [{format: 'float16x4', offset: 280, shaderLocation: 12}],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 64, attributes: [{format: 'sint32', offset: 0, shaderLocation: 9}]},
      {
        arrayStride: 156,
        stepMode: 'instance',
        attributes: [{format: 'float16x4', offset: 20, shaderLocation: 5}],
      },
      {arrayStride: 908, stepMode: 'instance', attributes: []},
      {arrayStride: 832, stepMode: 'instance', attributes: []},
      {
        arrayStride: 256,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 24, shaderLocation: 10},
          {format: 'float32x3', offset: 0, shaderLocation: 1},
          {format: 'snorm16x4', offset: 28, shaderLocation: 15},
          {format: 'snorm8x4', offset: 8, shaderLocation: 7},
          {format: 'sint32x2', offset: 160, shaderLocation: 13},
          {format: 'sint16x2', offset: 56, shaderLocation: 2},
          {format: 'uint8x2', offset: 34, shaderLocation: 8},
          {format: 'float32x4', offset: 168, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw'},
});
let commandEncoder329 = device2.createCommandEncoder({label: '\u9b51\u3e98\u{1f7fd}\u084e'});
let querySet156 = device2.createQuerySet({
  label: '\u{1fe6e}\u6d86\u063b\u897f\uc92f\u0811\u2156\u{1f876}\uabe9\u0f5a',
  type: 'occlusion',
  count: 2235,
});
try {
renderBundleEncoder138.setVertexBuffer(1, buffer68, 0, 4_599);
} catch {}
try {
commandEncoder273.copyTextureToTexture({
  texture: texture197,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture114,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 12, height: 8, depthOrArrayLayers: 52}
*/
{
  source: img19,
  origin: { x: 72, y: 4 },
  flipY: true,
}, {
  texture: texture108,
  mipLevel: 1,
  origin: {x: 2, y: 4, z: 9},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline254 = device2.createComputePipeline({
  label: '\u2b45\u{1ff1b}\u0556\u{1fb7a}\u0ab8\uc610',
  layout: pipelineLayout11,
  compute: {module: shaderModule40, entryPoint: 'compute0', constants: {}},
});
let canvas48 = document.createElement('canvas');
let videoFrame38 = new VideoFrame(canvas37, {timestamp: 0});
let bindGroupLayout90 = device0.createBindGroupLayout({
  label: '\u{1fe75}\u4b1f\u{1fd02}\ucbb7\u95fa\ub268\u{1fc40}\u6bb4\ud4e3\u0c52\u9e69',
  entries: [{binding: 250, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}],
});
let bindGroup109 = device0.createBindGroup({
  label: '\u0321\u{1f659}\u{1f805}\u{1fa55}',
  layout: bindGroupLayout25,
  entries: [{binding: 917, resource: sampler23}, {binding: 211, resource: externalTexture5}],
});
let textureView394 = texture119.createView({dimension: '1d'});
let renderBundleEncoder169 = device0.createRenderBundleEncoder({
  colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder131.dispatchWorkgroupsIndirect(buffer44, 14136);
} catch {}
try {
renderPassEncoder18.setBindGroup(1, bindGroup10);
} catch {}
try {
buffer66.unmap();
} catch {}
let imageBitmap34 = await createImageBitmap(offscreenCanvas11);
let commandEncoder330 = device2.createCommandEncoder({});
let texture216 = device2.createTexture({
  label: '\u83f5\uc62a\udb0a\uefff\u2371\uea7a\u{1fc12}\ue21d\u{1f6d0}\u645b\u0401',
  size: [45, 192, 1],
  mipLevelCount: 8,
  dimension: '2d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r8sint', 'r8sint', 'r8sint'],
});
let renderBundle188 = renderBundleEncoder83.finish({label: '\u8d09\u0818\u35db\uc76d\ueb1d\u1bd5\u72b0\u{1fa50}\u{1f618}'});
try {
renderBundleEncoder100.setBindGroup(1, bindGroup63);
} catch {}
try {
buffer57.unmap();
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 24, height: 16, depthOrArrayLayers: 104}
*/
{
  source: imageData5,
  origin: { x: 22, y: 22 },
  flipY: false,
}, {
  texture: texture108,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 8},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 14, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer22.detached) { new Uint8Array(arrayBuffer22).fill(0x55) };
} catch {}
let img33 = await imageWithData(27, 19, '#a8e5c53c', '#64bdbff6');
let textureView395 = texture150.createView({
  label: '\u42dd\u03e8\u345a\u{1f7d7}\udb3a\u{1f6b8}\u{1fe23}\u832e\u{1f919}\u{1f759}',
  dimension: '2d',
  baseMipLevel: 1,
  baseArrayLayer: 120,
});
let arrayBuffer25 = buffer22.getMappedRange(212536, 272);
let pipeline255 = device2.createComputePipeline({
  label: '\u{1f834}\u0533\u5510\u448e\u8ee3\u{1fc1c}\u27c7\u2aec\u0761\u{1ff75}\u0a81',
  layout: pipelineLayout11,
  compute: {module: shaderModule42, entryPoint: 'compute0', constants: {}},
});
let buffer72 = device5.createBuffer({label: '\u02a2\u{1fb0d}', size: 13096, usage: GPUBufferUsage.MAP_READ});
let commandEncoder331 = device5.createCommandEncoder({});
let texture217 = device5.createTexture({
  label: '\ucb11\u05ad\u0bda\u0beb\u0ff3\u01f0',
  size: {width: 234, height: 1, depthOrArrayLayers: 1},
  sampleCount: 4,
  format: 'r8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r8unorm', 'r8unorm', 'r8unorm'],
});
let textureView396 = texture203.createView({
  label: '\u0f0a\ubc82\u07fa\u0b8a\u1c76\u96c8\u{1fdd6}\ub7d4',
  dimension: '2d',
  aspect: 'all',
  format: 'rg8uint',
  baseMipLevel: 5,
  mipLevelCount: 1,
  baseArrayLayer: 49,
});
try {
renderBundleEncoder167.setVertexBuffer(4_294_967_295, undefined, 0, 1_083_651_660);
} catch {}
let pipeline256 = device5.createRenderPipeline({
  layout: pipelineLayout28,
  fragment: {
  module: shaderModule51,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg16uint', writeMask: GPUColorWrite.ALPHA}, {format: 'rgba32float'}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r8unorm'}, {format: 'rg8uint', writeMask: 0}],
},
  depthStencil: {
    format: 'stencil8',
    stencilFront: {failOp: 'increment-clamp', depthFailOp: 'invert', passOp: 'keep'},
    stencilBack: {compare: 'greater-equal', failOp: 'invert', depthFailOp: 'invert', passOp: 'increment-clamp'},
    stencilReadMask: 2754862470,
    depthBias: 0,
  },
  vertex: {
    module: shaderModule51,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 532, stepMode: 'instance', attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'snorm16x4', offset: 196, shaderLocation: 8},
          {format: 'unorm8x4', offset: 204, shaderLocation: 10},
          {format: 'unorm16x2', offset: 8, shaderLocation: 2},
          {format: 'float16x2', offset: 12, shaderLocation: 5},
          {format: 'sint32x2', offset: 424, shaderLocation: 7},
          {format: 'float32x2', offset: 108, shaderLocation: 9},
          {format: 'uint8x2', offset: 48, shaderLocation: 15},
        ],
      },
      {arrayStride: 240, attributes: []},
      {arrayStride: 16, attributes: []},
      {arrayStride: 148, attributes: []},
      {arrayStride: 28, stepMode: 'instance', attributes: []},
      {
        arrayStride: 1664,
        stepMode: 'instance',
        attributes: [{format: 'sint16x2', offset: 232, shaderLocation: 0}],
      },
      {
        arrayStride: 112,
        attributes: [
          {format: 'unorm16x4', offset: 4, shaderLocation: 1},
          {format: 'float32', offset: 8, shaderLocation: 6},
          {format: 'snorm8x4', offset: 52, shaderLocation: 13},
          {format: 'sint32x4', offset: 12, shaderLocation: 14},
          {format: 'float16x4', offset: 32, shaderLocation: 12},
          {format: 'unorm16x2', offset: 32, shaderLocation: 3},
          {format: 'snorm16x2', offset: 0, shaderLocation: 11},
          {format: 'uint16x4', offset: 20, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'front'},
});
let commandEncoder332 = device0.createCommandEncoder({});
let querySet157 = device0.createQuerySet({label: '\ub7ea\u{1f9ef}\u{1f947}\u068a\u71ab\u78f2\u0eb9', type: 'occlusion', count: 2592});
let texture218 = device0.createTexture({
  label: '\u0eab\u1637\uaee3\u2be8\u0dbf',
  size: {width: 660},
  dimension: '1d',
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg16uint', 'rg16uint'],
});
try {
computePassEncoder26.dispatchWorkgroupsIndirect(buffer53, 5896);
} catch {}
try {
renderPassEncoder8.beginOcclusionQuery(129);
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: 107.5, g: -517.5, b: 429.2, a: 664.1, });
} catch {}
try {
renderPassEncoder13.setScissorRect(91, 119, 73, 1);
} catch {}
try {
renderPassEncoder18.setStencilReference(101);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(6, buffer4, 0);
} catch {}
try {
renderBundleEncoder89.setBindGroup(3, bindGroup7, new Uint32Array(7829), 2318, 0);
} catch {}
try {
commandEncoder13.clearBuffer(buffer44, 9544, 9852);
} catch {}
try {
commandEncoder84.resolveQuerySet(querySet13, 377, 191, buffer0, 27904);
} catch {}
let pipeline257 = device0.createRenderPipeline({
  layout: pipelineLayout18,
  fragment: {
  module: shaderModule20,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32float', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule20,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 672,
        stepMode: 'instance',
        attributes: [{format: 'float32x3', offset: 4, shaderLocation: 0}],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'snorm8x2', offset: 46, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 116, shaderLocation: 2},
          {format: 'snorm8x4', offset: 128, shaderLocation: 13},
          {format: 'unorm8x4', offset: 88, shaderLocation: 14},
          {format: 'float32x4', offset: 84, shaderLocation: 3},
          {format: 'float16x4', offset: 336, shaderLocation: 8},
          {format: 'snorm8x4', offset: 224, shaderLocation: 4},
          {format: 'uint32x4', offset: 204, shaderLocation: 15},
        ],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 172, attributes: []},
      {arrayStride: 244, attributes: []},
      {arrayStride: 92, attributes: []},
      {arrayStride: 156, attributes: []},
      {
        arrayStride: 280,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 4, shaderLocation: 1},
          {format: 'sint32x3', offset: 24, shaderLocation: 5},
          {format: 'sint16x2', offset: 92, shaderLocation: 9},
          {format: 'float16x2', offset: 8, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
let shaderModule54 = device1.createShaderModule({
  code: `@group(0) @binding(180)
var<storage, read_write> type15: array<u32>;
@group(0) @binding(406)
var<storage, read_write> parameter21: array<u32>;
@group(1) @binding(959)
var<storage, read_write> function20: array<u32>;
@group(1) @binding(522)
var<storage, read_write> n24: array<u32>;
@group(0) @binding(354)
var<storage, read_write> function21: array<u32>;

@compute @workgroup_size(4, 1, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S47 {
  @location(7) f0: vec2<u32>,
  @location(13) f1: vec3<u32>,
  @location(9) f2: vec2<i32>,
  @location(2) f3: vec3<u32>,
  @location(10) f4: vec2<u32>,
  @location(12) f5: u32
}
struct FragmentOutput0 {
  @location(2) f0: vec4<f32>,
  @builtin(frag_depth) f1: f32,
  @location(0) f2: vec4<i32>,
  @location(1) f3: vec4<i32>
}

@fragment
fn fragment0(@location(15) a0: vec2<i32>, @builtin(front_facing) a1: bool, a2: S47, @location(5) a3: f32, @location(8) a4: i32, @location(1) a5: vec4<f32>, @location(0) a6: i32, @builtin(position) a7: vec4<f32>, @builtin(sample_mask) a8: u32, @builtin(sample_index) a9: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(7) f290: vec2<u32>,
  @location(10) f291: vec2<u32>,
  @location(8) f292: i32,
  @location(0) f293: i32,
  @location(15) f294: vec2<i32>,
  @location(12) f295: u32,
  @builtin(position) f296: vec4<f32>,
  @location(13) f297: vec3<u32>,
  @location(2) f298: vec3<u32>,
  @location(9) f299: vec2<i32>,
  @location(5) f300: f32,
  @location(1) f301: vec4<f32>
}

@vertex
fn vertex0(@location(0) a0: vec2<f32>, @location(8) a1: vec3<u32>, @location(11) a2: vec2<u32>, @location(3) a3: vec3<u32>, @location(4) a4: vec2<i32>, @location(5) a5: vec4<f16>, @builtin(vertex_index) a6: u32, @location(14) a7: vec3<u32>, @location(13) a8: vec2<u32>, @location(15) a9: u32, @location(12) a10: vec4<f32>, @location(7) a11: vec4<f32>, @location(6) a12: u32, @location(9) a13: vec2<f32>, @location(2) a14: vec4<i32>, @location(10) a15: vec4<u32>, @location(1) a16: i32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let texture219 = device1.createTexture({
  label: '\u{1f889}\u4c7d\u04eb\u{1fcd3}',
  size: {width: 275, height: 3, depthOrArrayLayers: 1},
  mipLevelCount: 9,
  format: 'depth32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['depth32float', 'depth32float', 'depth32float'],
});
let sampler148 = device1.createSampler({
  label: '\u{1fc11}\u0f9b\u{1fb63}\uc308',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 93.09,
  lodMaxClamp: 95.75,
});
try {
computePassEncoder158.setPipeline(pipeline59);
} catch {}
try {
renderBundleEncoder151.setBindGroup(0, bindGroup60);
} catch {}
try {
renderBundleEncoder34.draw(0, 0, 2, 4);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer15, 740);
} catch {}
try {
commandEncoder320.copyTextureToBuffer({
  texture: texture52,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 160226 */
  offset: 19930,
  bytesPerRow: 256,
  rowsPerImage: 137,
  buffer: buffer13,
}, {width: 4, height: 1, depthOrArrayLayers: 5});
} catch {}
try {
commandEncoder279.copyTextureToTexture({
  texture: texture156,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture47,
  mipLevel: 0,
  origin: {x: 13, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder304.resolveQuerySet(querySet118, 548, 97, buffer63, 768);
} catch {}
try {
gpuCanvasContext34.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm-srgb', 'bgra8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
gpuCanvasContext16.unconfigure();
} catch {}
let imageBitmap35 = await createImageBitmap(videoFrame9);
let shaderModule55 = device2.createShaderModule({
  code: `@group(0) @binding(593)
var<storage, read_write> parameter22: array<u32>;
@group(1) @binding(976)
var<storage, read_write> local18: array<u32>;
@group(0) @binding(699)
var<storage, read_write> n25: array<u32>;
@group(0) @binding(461)
var<storage, read_write> parameter23: array<u32>;
@group(1) @binding(999)
var<storage, read_write> field17: array<u32>;

@compute @workgroup_size(3, 2, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S48 {
  @location(7) f0: f16,
  @location(4) f1: i32,
  @location(0) f2: f32,
  @location(1) f3: i32,
  @location(13) f4: vec3<f16>,
  @location(2) f5: f16,
  @location(12) f6: f32,
  @location(8) f7: vec4<f16>,
  @location(11) f8: vec4<u32>,
  @location(14) f9: f32,
  @location(5) f10: vec3<f32>,
  @builtin(sample_mask) f11: u32,
  @builtin(position) f12: vec4<f32>
}
struct FragmentOutput0 {
  @location(4) f0: i32,
  @location(5) f1: vec3<f32>,
  @location(3) f2: vec4<f32>,
  @location(1) f3: vec4<f32>,
  @location(6) f4: vec4<i32>,
  @location(0) f5: vec4<f32>,
  @location(2) f6: vec4<f32>
}

@fragment
fn fragment0(@location(15) a0: vec2<f16>, @location(9) a1: vec4<u32>, @builtin(sample_index) a2: u32, @location(10) a3: vec2<f32>, @location(6) a4: vec2<f32>, @builtin(front_facing) a5: bool, @location(3) a6: vec3<f32>, a7: S48) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @builtin(position) f302: vec4<f32>,
  @location(7) f303: f16,
  @location(6) f304: vec2<f32>,
  @location(12) f305: f32,
  @location(15) f306: vec2<f16>,
  @location(5) f307: vec3<f32>,
  @location(10) f308: vec2<f32>,
  @location(8) f309: vec4<f16>,
  @location(9) f310: vec4<u32>,
  @location(4) f311: i32,
  @location(3) f312: vec3<f32>,
  @location(2) f313: f16,
  @location(11) f314: vec4<u32>,
  @location(14) f315: f32,
  @location(13) f316: vec3<f16>,
  @location(0) f317: f32,
  @location(1) f318: i32
}

@vertex
fn vertex0(@location(1) a0: vec2<u32>, @location(13) a1: i32, @location(8) a2: u32, @location(9) a3: i32, @location(15) a4: vec3<f32>, @location(7) a5: vec2<f16>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
});
let bindGroup110 = device2.createBindGroup({
  label: '\u{1fc07}\u9c93\u6b00\u{1f8e7}',
  layout: bindGroupLayout59,
  entries: [{binding: 193, resource: sampler113}, {binding: 59, resource: externalTexture129}],
});
let texture220 = device2.createTexture({
  label: '\uc895\u7f03\u73bb\u53d8\u0e2e\uab8e\u0b6b\u0a25\u044a',
  size: [720, 1, 493],
  mipLevelCount: 7,
  dimension: '3d',
  format: 'r8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['r8sint', 'r8sint', 'r8sint'],
});
let textureView397 = texture82.createView({baseArrayLayer: 36, arrayLayerCount: 18});
try {
computePassEncoder74.setBindGroup(2, bindGroup94);
} catch {}
try {
renderBundleEncoder138.setBindGroup(2, bindGroup65);
} catch {}
try {
renderBundleEncoder91.setVertexBuffer(3, buffer43);
} catch {}
try {
commandEncoder188.resolveQuerySet(querySet125, 1, 93, buffer65, 7424);
} catch {}
try {
device2.queue.writeBuffer(buffer33, 37512, new DataView(new ArrayBuffer(63943)), 32880, 2884);
} catch {}
let promise85 = device2.queue.onSubmittedWorkDone();
let pipelineLayout35 = device3.createPipelineLayout({label: '\u039a\u075d', bindGroupLayouts: [bindGroupLayout56, bindGroupLayout56, bindGroupLayout53]});
let commandEncoder333 = device3.createCommandEncoder({label: '\u{1f91b}\u52dc\uede8'});
let texture221 = device3.createTexture({
  label: '\u448c\ub6e5\u{1f80a}\u4456\u5c8a\u0e59\ua62e\u046b\u2517\u0fac\u{1ff79}',
  size: {width: 702, height: 1, depthOrArrayLayers: 252},
  mipLevelCount: 7,
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rg16sint', 'rg16sint'],
});
let computePassEncoder162 = commandEncoder259.beginComputePass({label: '\u4601\u06c8\ub6d0\u085e'});
let externalTexture157 = device3.importExternalTexture({label: '\u8f88\uc94a\u0e0f\u5898\u476a\u1f66', source: video17, colorSpace: 'display-p3'});
try {
computePassEncoder147.setPipeline(pipeline230);
} catch {}
try {
commandEncoder271.copyBufferToBuffer(buffer47, 210416, buffer38, 100752, 4948);
} catch {}
try {
commandEncoder260.clearBuffer(buffer70);
} catch {}
try {
commandEncoder271.resolveQuerySet(querySet89, 96, 859, buffer47, 219136);
} catch {}
try {
renderBundleEncoder104.insertDebugMarker('\ubbc4');
} catch {}
try {
device3.queue.writeTexture({
  texture: texture186,
  mipLevel: 0,
  origin: {x: 122, y: 1, z: 0},
  aspect: 'all',
}, new DataView(arrayBuffer20), /* required buffer size: 211 */
{offset: 211}, {width: 74, height: 0, depthOrArrayLayers: 1});
} catch {}
let img34 = await imageWithData(187, 130, '#3516ab04', '#913dcceb');
let computePassEncoder163 = commandEncoder86.beginComputePass({label: '\u9d96\ue260\u0d6e\u0343\u082d\u68a1\u8449\u0da2\u4c3f'});
try {
computePassEncoder132.setPipeline(pipeline188);
} catch {}
try {
renderBundleEncoder139.setBindGroup(1, bindGroup83, []);
} catch {}
try {
renderBundleEncoder34.drawIndexed(3_056, 423, 5_936, 196_959_671, 232_686_033);
} catch {}
try {
renderBundleEncoder34.drawIndexedIndirect(buffer63, 10_760);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer63, 284);
} catch {}
try {
commandEncoder280.resolveQuerySet(querySet39, 380, 22, buffer18, 63488);
} catch {}
let promise86 = device1.queue.onSubmittedWorkDone();
let videoFrame39 = new VideoFrame(canvas5, {timestamp: 0});
let texture222 = device0.createTexture({
  label: '\u9cb1\u0ae0\u01b3\u{1fde7}\udaee\u6923',
  size: [165],
  dimension: '1d',
  format: 'bgra8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView398 = texture139.createView({format: 'rgba8snorm', baseMipLevel: 0});
let sampler149 = device0.createSampler({
  label: '\u7a47\u0b9d\u{1fe58}\u00ca\uf177\u84e7\u{1fb0d}\uace8\uc930',
  addressModeU: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMinClamp: 84.47,
  lodMaxClamp: 92.34,
  maxAnisotropy: 1,
});
let externalTexture158 = device0.importExternalTexture({label: '\u{1f661}\ua107\u{1fd4b}\u4512\u4d82', source: video8});
try {
renderPassEncoder12.setBlendConstant({ r: -97.06, g: 637.1, b: -679.5, a: -493.7, });
} catch {}
try {
renderPassEncoder18.setScissorRect(58, 2, 462, 273);
} catch {}
try {
renderPassEncoder19.setViewport(238.7, 179.5, 124.8, 207.9, 0.5575, 0.9361);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer24, 65_888);
} catch {}
try {
renderBundleEncoder50.drawIndirect(buffer44, 3_916);
} catch {}
let promise87 = device0.popErrorScope();
try {
buffer44.unmap();
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 124}
*/
{
  source: canvas29,
  origin: { x: 25, y: 38 },
  flipY: true,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 17, y: 39, z: 85},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 9, depthOrArrayLayers: 0});
} catch {}
let textureView399 = texture136.createView({label: '\u989b\ud708\u0c54\ud5d8\u{1fb18}\u0a33\u6a2a\u176c\u{1fe6f}\u6ea2', baseMipLevel: 3});
let sampler150 = device4.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 78.56,
  lodMaxClamp: 93.47,
  compare: 'less-equal',
  maxAnisotropy: 4,
});
try {
gpuCanvasContext15.configure({
  device: device4,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device4.queue.writeBuffer(buffer54, 28824, new BigUint64Array(5069));
} catch {}
let pipeline258 = await device4.createComputePipelineAsync({layout: pipelineLayout26, compute: {module: shaderModule47, entryPoint: 'compute0', constants: {}}});
try {
gpuCanvasContext31.unconfigure();
} catch {}
canvas2.width = 246;
let video51 = await videoWithData();
let videoFrame40 = new VideoFrame(video33, {timestamp: 0});
let shaderModule56 = device5.createShaderModule({
  label: '\ucc5b\u0ac3\ucd12\u{1f82f}',
  code: `@group(1) @binding(932)
var<storage, read_write> type16: array<u32>;
@group(0) @binding(932)
var<storage, read_write> function22: array<u32>;

@compute @workgroup_size(1, 2, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<u32>,
  @location(2) f1: vec2<i32>,
  @location(1) f2: vec4<f32>,
  @location(4) f3: vec4<u32>,
  @location(3) f4: vec2<f32>
}

@fragment
fn fragment0(@location(9) a0: vec4<i32>, @location(14) a1: vec4<f32>, @location(5) a2: vec3<f32>, @location(10) a3: vec4<u32>, @location(3) a4: vec3<i32>, @location(4) a5: vec4<u32>, @builtin(front_facing) a6: bool, @builtin(sample_index) a7: u32, @location(0) a8: vec3<f32>, @builtin(position) a9: vec4<f32>, @location(15) a10: vec4<u32>, @location(6) a11: i32, @builtin(sample_mask) a12: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(10) f319: vec4<u32>,
  @location(6) f320: i32,
  @location(13) f321: vec2<u32>,
  @location(12) f322: vec3<i32>,
  @location(1) f323: vec2<u32>,
  @location(5) f324: vec3<f32>,
  @location(4) f325: vec4<u32>,
  @builtin(position) f326: vec4<f32>,
  @location(14) f327: vec4<f32>,
  @location(2) f328: i32,
  @location(3) f329: vec3<i32>,
  @location(9) f330: vec4<i32>,
  @location(15) f331: vec4<u32>,
  @location(7) f332: u32,
  @location(11) f333: u32,
  @location(0) f334: vec3<f32>
}

@vertex
fn vertex0(@location(13) a0: vec3<u32>, @location(9) a1: vec4<f32>, @builtin(instance_index) a2: u32, @location(5) a3: vec4<f32>, @builtin(vertex_index) a4: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
});
let bindGroup111 = device5.createBindGroup({label: '\u1bb4\u{1fef4}', layout: bindGroupLayout85, entries: []});
let textureView400 = texture160.createView({label: '\u0659\u0a55'});
let renderBundleEncoder170 = device5.createRenderBundleEncoder({label: '\u2960\u{1ffbf}', colorFormats: ['rg16uint', 'rgba32float', 'r32sint', 'r8unorm', 'rg8uint']});
try {
computePassEncoder160.setPipeline(pipeline232);
} catch {}
try {
renderBundleEncoder170.setBindGroup(0, bindGroup111, new Uint32Array(4029), 2560, 0);
} catch {}
let promise88 = device5.queue.onSubmittedWorkDone();
let pipeline259 = await device5.createComputePipelineAsync({
  label: '\u{1fd4e}\u025b\u9431\u9911\u{1fa3d}\u01e6\u6269\u5278\u{1fd2e}\u6812',
  layout: pipelineLayout21,
  compute: {module: shaderModule51, entryPoint: 'compute0', constants: {}},
});
let promise89 = adapter4.requestAdapterInfo();
let bindGroupLayout91 = device4.createBindGroupLayout({
  label: '\u0933\u0792\u{1f98a}\u{1f61c}\u0936\u08c8\ub15a\u5926',
  entries: [
    {
      binding: 524,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false },
    },
    {
      binding: 944,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '2d' },
    },
  ],
});
let commandEncoder334 = device4.createCommandEncoder({label: '\u8ccc\u{1f688}'});
let renderBundleEncoder171 = device4.createRenderBundleEncoder({
  label: '\u36e6\u{1f687}\u{1fbca}\uc924\u{1fffa}\u315c\u3913',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: true,
});
let renderBundle189 = renderBundleEncoder147.finish({label: '\uea97\u091f'});
try {
computePassEncoder151.setPipeline(pipeline224);
} catch {}
try {
renderBundleEncoder101.setPipeline(pipeline170);
} catch {}
try {
commandEncoder321.copyBufferToTexture({
  /* bytesInLastRow: 316 widthInBlocks: 79 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 42164 */
  offset: 42164,
  buffer: buffer48,
}, {
  texture: texture124,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 79, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder334.clearBuffer(buffer30, 167444, 60532);
} catch {}
try {
device4.queue.writeTexture({
  texture: texture166,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 69 */
{offset: 69}, {width: 105, height: 1, depthOrArrayLayers: 0});
} catch {}
canvas47.height = 482;
let canvas49 = document.createElement('canvas');
try {
  await adapter4.requestAdapterInfo();
} catch {}
let renderBundle190 = renderBundleEncoder161.finish({});
try {
commandEncoder333.clearBuffer(buffer64);
} catch {}
try {
renderBundleEncoder135.insertDebugMarker('\u{1ffc8}');
} catch {}
try {
device3.queue.writeBuffer(buffer46, 233076, new Float32Array(27836), 15239, 1852);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture221,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Float32Array(arrayBuffer9), /* required buffer size: 15_044_521 */
{offset: 912, bytesPerRow: 235, rowsPerImage: 295}, {width: 21, height: 1, depthOrArrayLayers: 218});
} catch {}
let renderBundle191 = renderBundleEncoder121.finish();
try {
device5.addEventListener('uncapturederror', e => { log('device5.uncapturederror'); log(e); e.label = device5.label; });
} catch {}
try {
gpuCanvasContext38.configure({
  device: device5,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
} catch {}
let commandEncoder335 = device4.createCommandEncoder({label: '\u{1f861}\ue47c\u0713'});
let textureView401 = texture163.createView({label: '\u08ab\uc4b0\u015c\u{1ff3d}\u6ff5\u8fcf\u{1f78f}', baseMipLevel: 6});
let computePassEncoder164 = commandEncoder322.beginComputePass({label: '\u47da\u{1f7ba}\u{1f7c7}\u0091'});
let externalTexture159 = device4.importExternalTexture({
  label: '\u{1fe01}\u5ef5\u268c\u2c9b\u047d\u8335\u1276\ua099\uf555',
  source: video34,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder131.setVertexBuffer(6, buffer56, 34_632, 58_538);
} catch {}
try {
  await buffer54.mapAsync(GPUMapMode.READ, 90944, 39360);
} catch {}
try {
commandEncoder335.clearBuffer(buffer54);
} catch {}
let textureView402 = texture133.createView({
  label: '\u9e2a\udabf\u{1f8a7}\ua3d7\u38c5\u08ed\u153a\u859a\u{1fc4a}\u7c6d\u0231',
  dimension: '2d',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 20,
  arrayLayerCount: 1,
});
let renderBundle192 = renderBundleEncoder86.finish({label: '\u01b7\u9ebf\uc58f\udb6c\u0513\u0702\ufe57\u127b\u04cb\u{1f71f}'});
try {
renderBundleEncoder98.setIndexBuffer(buffer64, 'uint32', 6_024, 1_762);
} catch {}
try {
commandEncoder315.copyBufferToBuffer(buffer47, 212080, buffer70, 130164, 8280);
} catch {}
try {
commandEncoder232.copyTextureToTexture({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture131,
  mipLevel: 1,
  origin: {x: 25, y: 0, z: 7},
  aspect: 'all',
},
{width: 11, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder260.insertDebugMarker('\u2521');
} catch {}
let pipeline260 = device3.createRenderPipeline({
  label: '\u4920\u0c89\u0477\u52c0\ua0c3\u0168\u0dad',
  layout: pipelineLayout35,
  multisample: {mask: 0x4e560cd8},
  fragment: {
  module: shaderModule45,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALL}, {format: 'rg32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg16sint'}, {format: 'r32uint'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilFront: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'increment-wrap', passOp: 'invert'},
    stencilBack: {compare: 'greater-equal', failOp: 'zero', depthFailOp: 'increment-wrap', passOp: 'replace'},
    stencilWriteMask: 446476402,
    depthBiasSlopeScale: 0.0,
  },
  vertex: {
    module: shaderModule45,
    buffers: [
      {
        arrayStride: 528,
        attributes: [
          {format: 'float32x3', offset: 388, shaderLocation: 8},
          {format: 'sint8x4', offset: 16, shaderLocation: 0},
          {format: 'float16x2', offset: 88, shaderLocation: 6},
          {format: 'uint16x2', offset: 48, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 112,
        stepMode: 'vertex',
        attributes: [{format: 'float32x2', offset: 4, shaderLocation: 3}],
      },
      {
        arrayStride: 184,
        stepMode: 'instance',
        attributes: [{format: 'uint32', offset: 44, shaderLocation: 4}],
      },
      {arrayStride: 176, stepMode: 'vertex', attributes: []},
      {arrayStride: 900, attributes: [{format: 'unorm10-10-10-2', offset: 140, shaderLocation: 11}]},
      {arrayStride: 96, stepMode: 'instance', attributes: []},
      {
        arrayStride: 252,
        stepMode: 'vertex',
        attributes: [{format: 'float32x4', offset: 0, shaderLocation: 14}],
      },
      {
        arrayStride: 296,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 16, shaderLocation: 13},
          {format: 'float32x2', offset: 0, shaderLocation: 7},
          {format: 'sint32x2', offset: 48, shaderLocation: 15},
          {format: 'unorm16x4', offset: 12, shaderLocation: 12},
          {format: 'snorm16x4', offset: 108, shaderLocation: 9},
          {format: 'snorm16x2', offset: 20, shaderLocation: 2},
          {format: 'float32', offset: 128, shaderLocation: 1},
          {format: 'uint32x2', offset: 100, shaderLocation: 10},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
let textureView403 = texture193.createView({
  label: '\u{1f6b0}\u1207\u20fd\u{1facf}\u{1fbd4}',
  dimension: '2d-array',
  baseMipLevel: 1,
  mipLevelCount: 2,
});
let renderBundle193 = renderBundleEncoder142.finish({label: '\u{1ff5b}\u{1fc14}'});
try {
renderBundleEncoder149.setVertexBuffer(6, buffer60);
} catch {}
try {
commandEncoder325.copyTextureToBuffer({
  texture: texture165,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 112 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 93824 */
  offset: 93824,
  bytesPerRow: 512,
  buffer: buffer60,
}, {width: 56, height: 12, depthOrArrayLayers: 0});
} catch {}
try {
device6.queue.writeTexture({
  texture: texture201,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer4, /* required buffer size: 966 */
{offset: 966}, {width: 731, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(video28);
let buffer73 = device1.createBuffer({
  label: '\u{1f964}\u96fd\u{1f65c}',
  size: 290276,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let renderBundleEncoder172 = device1.createRenderBundleEncoder({
  label: '\u0ca1\u02b0',
  colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'],
  depthStencilFormat: 'depth32float',
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder141.setBindGroup(3, bindGroup55);
} catch {}
try {
renderBundleEncoder34.drawIndexedIndirect(buffer19, 284);
} catch {}
canvas26.width = 151;
gc();
try {
  await adapter0.requestAdapterInfo();
} catch {}
let commandEncoder336 = device2.createCommandEncoder({label: '\u{1f988}\u{1fa56}\u24c9\u{1f666}\u{1f98b}\udbd3'});
let querySet158 = device2.createQuerySet({label: '\u5944\u8169\u{1fd2b}\u03f4\udca4\ub4eb\uf4ca\ub90b', type: 'occlusion', count: 2123});
let texture223 = device2.createTexture({
  label: '\uc5d8\u0011\u0c97\u663b',
  size: {width: 1440, height: 1, depthOrArrayLayers: 182},
  mipLevelCount: 7,
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let computePassEncoder165 = commandEncoder248.beginComputePass();
let sampler151 = device2.createSampler({
  label: '\u006a\ubc2b\u{1fbc0}\u72bb\u5e89\u379a\u{1fc85}\u2685\u4f6b\u0dd0',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 30.41,
  lodMaxClamp: 66.16,
  maxAnisotropy: 9,
});
let externalTexture160 = device2.importExternalTexture({label: '\u0429\u9fbd\u0525', source: video33, colorSpace: 'display-p3'});
try {
commandEncoder216.copyBufferToBuffer(buffer52, 68668, buffer43, 5660, 284);
} catch {}
try {
commandEncoder264.copyBufferToTexture({
  /* bytesInLastRow: 176 widthInBlocks: 44 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 105668 */
  offset: 12820,
  bytesPerRow: 512,
  buffer: buffer23,
}, {
  texture: texture180,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {width: 44, height: 182, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext25.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device2.queue.writeBuffer(buffer43, 28, new Int16Array(50399), 43138, 900);
} catch {}
let pipeline261 = device2.createRenderPipeline({
  label: '\u{1f673}\u{1f812}\ufc2a\u03d2\u6261\uc83f\u0495\uee0d\u042f\ue168',
  layout: pipelineLayout16,
  multisample: {count: 4, mask: 0xfb272195},
  fragment: {
  module: shaderModule40,
  entryPoint: 'fragment0',
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rgba8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'r8unorm', writeMask: GPUColorWrite.BLUE}, {format: 'r8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'dst-alpha'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'src-alpha-saturated'},
  },
}, {format: 'rgba8sint'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'greater', failOp: 'replace', depthFailOp: 'zero', passOp: 'invert'},
    stencilBack: {compare: 'less-equal', failOp: 'replace', depthFailOp: 'increment-clamp', passOp: 'decrement-wrap'},
    stencilReadMask: 5409423,
    depthBiasSlopeScale: 545.9462239846523,
    depthBiasClamp: 342.48153441547606,
  },
  vertex: {
    module: shaderModule40,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 272, shaderLocation: 5},
          {format: 'sint8x2', offset: 720, shaderLocation: 15},
        ],
      },
      {arrayStride: 1168, attributes: []},
      {
        arrayStride: 276,
        attributes: [
          {format: 'sint32x2', offset: 32, shaderLocation: 2},
          {format: 'uint8x2', offset: 22, shaderLocation: 10},
          {format: 'float32x4', offset: 36, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 280,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x2', offset: 28, shaderLocation: 9}],
      },
      {arrayStride: 152, attributes: [{format: 'uint32x2', offset: 8, shaderLocation: 14}]},
      {arrayStride: 68, stepMode: 'instance', attributes: []},
      {arrayStride: 916, stepMode: 'instance', attributes: []},
      {
        arrayStride: 92,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32', offset: 8, shaderLocation: 6},
          {format: 'snorm16x2', offset: 0, shaderLocation: 12},
          {format: 'unorm16x2', offset: 4, shaderLocation: 13},
          {format: 'sint16x4', offset: 4, shaderLocation: 0},
          {format: 'sint8x2', offset: 2, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'none', unclippedDepth: true},
});
let bindGroup112 = device5.createBindGroup({
  label: '\u47f9\u2426\u0d4f\u618b\u0669\uae47\u06cf\u3126\u{1fc16}\u0b10',
  layout: bindGroupLayout76,
  entries: [{binding: 236, resource: externalTexture121}, {binding: 463, resource: sampler140}],
});
let commandEncoder337 = device5.createCommandEncoder({label: '\u{1f6b3}\u0def\ub6e1\u875a'});
let computePassEncoder166 = commandEncoder331.beginComputePass();
let sampler152 = device5.createSampler({
  label: '\u0507\u0a73\u5c0b\ud7f1\u3710\ub74e',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 19.64,
  lodMaxClamp: 22.04,
  compare: 'never',
});
try {
computePassEncoder157.setBindGroup(0, bindGroup112);
} catch {}
try {
renderBundleEncoder170.setPipeline(pipeline237);
} catch {}
try {
buffer72.unmap();
} catch {}
try {
commandEncoder337.copyTextureToTexture({
  texture: texture174,
  mipLevel: 0,
  origin: {x: 33, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture169,
  mipLevel: 0,
  origin: {x: 67, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
device5.queue.writeTexture({
  texture: texture168,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, arrayBuffer23, /* required buffer size: 142 */
{offset: 142, bytesPerRow: 252}, {width: 0, height: 7, depthOrArrayLayers: 0});
} catch {}
try {
device5.destroy();
} catch {}
let bindGroupLayout92 = device4.createBindGroupLayout({
  label: '\u00c4\u192a\u04b0\u098b\u0837\u{1feac}\u{1fb71}\ubb4f\u6f91\u{1fb56}\u{1f641}',
  entries: [
    {
      binding: 538,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
    },
    {binding: 480, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let textureView404 = texture124.createView({label: '\u5b47\u{1fab0}\u69c2\u0561'});
let renderBundle194 = renderBundleEncoder95.finish();
try {
computePassEncoder151.setBindGroup(2, bindGroup85);
} catch {}
try {
buffer56.unmap();
} catch {}
try {
commandEncoder193.clearBuffer(buffer51);
} catch {}
try {
device4.queue.writeBuffer(buffer56, 12788, new Int16Array(8745), 3056, 540);
} catch {}
try {
  await device4.queue.onSubmittedWorkDone();
} catch {}
let texture224 = device3.createTexture({
  label: '\u9865\uc79e\u0315\u0db9',
  size: {width: 351},
  dimension: '1d',
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm'],
});
try {
computePassEncoder136.setBindGroup(0, bindGroup76);
} catch {}
try {
  await buffer46.mapAsync(GPUMapMode.READ, 0, 765728);
} catch {}
try {
commandEncoder281.copyBufferToBuffer(buffer47, 166128, buffer38, 40064, 37448);
} catch {}
try {
commandEncoder217.copyBufferToTexture({
  /* bytesInLastRow: 492 widthInBlocks: 123 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2840 */
  offset: 2840,
  bytesPerRow: 768,
  buffer: buffer47,
}, {
  texture: texture224,
  mipLevel: 0,
  origin: {x: 104, y: 0, z: 0},
  aspect: 'all',
}, {width: 123, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder333.copyTextureToBuffer({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 7224 */
  offset: 7224,
  buffer: buffer49,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder297.clearBuffer(buffer47);
} catch {}
try {
gpuCanvasContext36.configure({
  device: device3,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let bindGroupLayout93 = device4.createBindGroupLayout({
  entries: [
    {
      binding: 702,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let pipelineLayout36 = device4.createPipelineLayout({bindGroupLayouts: [bindGroupLayout93, bindGroupLayout93, bindGroupLayout87]});
let querySet159 = device4.createQuerySet({label: '\u03c9\u088f\uf043\u0d8e\u06b4', type: 'occlusion', count: 298});
let textureView405 = texture125.createView({arrayLayerCount: 1});
let renderBundle195 = renderBundleEncoder93.finish({label: '\u9b97\u6189\u77e0\uc6e8\ue791\u{1f782}\u4a43\u047d\u397e'});
let sampler153 = device4.createSampler({
  label: '\u{1f644}\ue640\u{1fdba}',
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 57.53,
  lodMaxClamp: 82.44,
  maxAnisotropy: 17,
});
try {
computePassEncoder151.setBindGroup(2, bindGroup85, new Uint32Array(626), 610, 0);
} catch {}
try {
renderBundleEncoder171.setPipeline(pipeline180);
} catch {}
try {
buffer48.unmap();
} catch {}
try {
commandEncoder235.pushDebugGroup('\u870a');
} catch {}
try {
commandEncoder318.insertDebugMarker('\u9b7c');
} catch {}
try {
  await device4.queue.onSubmittedWorkDone();
} catch {}
let pipeline262 = device4.createComputePipeline({layout: pipelineLayout36, compute: {module: shaderModule50, entryPoint: 'compute0', constants: {}}});
let pipelineLayout37 = device4.createPipelineLayout({bindGroupLayouts: [bindGroupLayout92, bindGroupLayout89]});
let computePassEncoder167 = commandEncoder238.beginComputePass({label: '\uceab\u{1fbb3}\uda57\u0c63\u249f\u9dcb'});
try {
computePassEncoder167.setBindGroup(3, bindGroup85);
} catch {}
try {
computePassEncoder151.setBindGroup(1, bindGroup85, new Uint32Array(8160), 7505, 0);
} catch {}
try {
commandEncoder243.copyBufferToTexture({
  /* bytesInLastRow: 588 widthInBlocks: 147 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 9060 */
  offset: 8472,
  buffer: buffer48,
}, {
  texture: texture166,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 147, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder308.copyTextureToBuffer({
  texture: texture153,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 13454 */
  offset: 13454,
  bytesPerRow: 256,
  buffer: buffer56,
}, {width: 4, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext39 = canvas48.getContext('webgpu');
try {
  await promise85;
} catch {}
let video52 = await videoWithData();
let shaderModule57 = device4.createShaderModule({
  label: '\u{1fa29}\u6cfd\u03da\uf801\u864b\u0e07',
  code: `@group(1) @binding(6)
var<storage, read_write> local19: array<u32>;
@group(1) @binding(894)
var<storage, read_write> type17: array<u32>;
@group(1) @binding(541)
var<storage, read_write> field18: array<u32>;
@group(0) @binding(480)
var<storage, read_write> local20: array<u32>;
@group(0) @binding(538)
var<storage, read_write> function23: array<u32>;

@compute @workgroup_size(8, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S50 {
  @location(0) f0: vec3<u32>,
  @builtin(position) f1: vec4<f32>
}
struct FragmentOutput0 {
  @location(0) f0: vec4<u32>,
  @location(4) f1: vec4<i32>,
  @location(5) f2: vec3<f32>,
  @location(2) f3: vec2<f32>,
  @location(3) f4: vec3<f32>
}

@fragment
fn fragment0(@location(2) a0: vec2<f32>, a1: S50, @location(4) a2: vec2<f32>, @location(9) a3: vec2<f16>, @location(11) a4: vec2<f16>, @location(1) a5: vec4<i32>, @location(13) a6: vec4<f32>, @location(7) a7: u32, @location(14) a8: vec3<f16>, @location(5) a9: i32, @location(6) a10: vec3<i32>, @location(15) a11: vec2<f16>, @location(12) a12: vec2<u32>, @location(10) a13: vec3<i32>, @builtin(sample_index) a14: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S49 {
  @location(1) f0: vec3<f32>,
  @location(3) f1: vec2<u32>,
  @location(5) f2: vec3<i32>,
  @location(14) f3: vec2<i32>,
  @location(15) f4: vec2<i32>,
  @location(8) f5: vec4<f32>,
  @location(12) f6: vec2<f16>,
  @location(4) f7: vec2<i32>,
  @location(11) f8: vec2<f16>
}
struct VertexOutput0 {
  @location(7) f335: u32,
  @location(2) f336: vec2<f32>,
  @location(11) f337: vec2<f16>,
  @location(4) f338: vec2<f32>,
  @location(12) f339: vec2<u32>,
  @builtin(position) f340: vec4<f32>,
  @location(0) f341: vec3<u32>,
  @location(14) f342: vec3<f16>,
  @location(10) f343: vec3<i32>,
  @location(15) f344: vec2<f16>,
  @location(6) f345: vec3<i32>,
  @location(5) f346: i32,
  @location(13) f347: vec4<f32>,
  @location(9) f348: vec2<f16>,
  @location(1) f349: vec4<i32>
}

@vertex
fn vertex0(a0: S49) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  hints: {},
});
let pipelineLayout38 = device4.createPipelineLayout({
  label: '\u5299\u7cec\u67c0\u06d7\u64b7\u{1fb18}\u{1feea}\u64f7\u9763\u{1f98f}',
  bindGroupLayouts: [bindGroupLayout61],
});
let commandEncoder338 = device4.createCommandEncoder({label: '\uf7f5\uab74\u3c3b\uf15c\u02f1\u3275\u33fc\u084c\uf97c\u3990\u0d90'});
let sampler154 = device4.createSampler({
  label: '\u2a13\u8626\u0231\u0330\uc39c\ufa69\u1f34',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 53.27,
  lodMaxClamp: 98.81,
});
try {
renderBundleEncoder168.setPipeline(pipeline170);
} catch {}
try {
device4.queue.writeTexture({
  texture: texture124,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, new Uint8ClampedArray(arrayBuffer3), /* required buffer size: 466 */
{offset: 466}, {width: 105, height: 0, depthOrArrayLayers: 1});
} catch {}
let textureView406 = texture166.createView({});
try {
renderBundleEncoder101.setPipeline(pipeline166);
} catch {}
try {
renderBundleEncoder101.setVertexBuffer(7, buffer56, 0, 34_780);
} catch {}
try {
commandEncoder308.copyBufferToBuffer(buffer48, 83584, buffer56, 162688, 107448);
} catch {}
try {
commandEncoder338.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 434 */
  offset: 434,
  bytesPerRow: 0,
  rowsPerImage: 288,
  buffer: buffer48,
}, {
  texture: texture136,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 2});
} catch {}
try {
commandEncoder193.copyTextureToBuffer({
  texture: texture163,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 162 widthInBlocks: 81 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 424 */
  offset: 424,
  buffer: buffer56,
}, {width: 81, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder318.clearBuffer(buffer56);
} catch {}
try {
renderBundleEncoder135.setBindGroup(3, bindGroup91);
} catch {}
try {
commandEncoder232.copyBufferToBuffer(buffer47, 138804, buffer70, 173664, 23868);
} catch {}
try {
commandEncoder287.clearBuffer(buffer47);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture131,
  mipLevel: 2,
  origin: {x: 46, y: 1, z: 2},
  aspect: 'all',
}, arrayBuffer17, /* required buffer size: 311_139 */
{offset: 549, bytesPerRow: 174, rowsPerImage: 105}, {width: 29, height: 0, depthOrArrayLayers: 18});
} catch {}
try {
commandEncoder258.label = '\u{1fb78}\u{1fe4d}\ua4ba\u7e11\u0751\u{1f8d4}\u{1fdd8}';
} catch {}
offscreenCanvas31.height = 2756;
let canvas50 = document.createElement('canvas');
let commandEncoder339 = device4.createCommandEncoder({label: '\u{1fee4}\u0af9\uda68\u05b9\ud437\u{1fc46}\u9d66'});
let renderBundleEncoder173 = device4.createRenderBundleEncoder({
  label: '\ueeba\u08e3\u726d\u4b9f\u{1fecd}\ua191',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let sampler155 = device4.createSampler({
  label: '\u2506\ucce3\u4953\ue510\u0c09\u{1f805}\u{1f7f0}\uf45a\u{1fa57}\ua08c',
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  lodMinClamp: 99.09,
  lodMaxClamp: 99.45,
});
let externalTexture161 = device4.importExternalTexture({
  label: '\u9f8a\u0051\u013e\u0d15\u3e68\u12b8\u4fff\u0e8b',
  source: videoFrame37,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder101.setIndexBuffer(buffer48, 'uint16', 12_814, 2_370);
} catch {}
try {
commandEncoder321.copyBufferToTexture({
  /* bytesInLastRow: 76 widthInBlocks: 38 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 32592 */
  offset: 32592,
  bytesPerRow: 512,
  buffer: buffer48,
}, {
  texture: texture127,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, {width: 38, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder321.copyTextureToTexture({
  texture: texture192,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture124,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{width: 137, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device4.queue.writeTexture({
  texture: texture127,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, new ArrayBuffer(0), /* required buffer size: 85 */
{offset: 85}, {width: 127, height: 1, depthOrArrayLayers: 0});
} catch {}
let promise90 = device4.createRenderPipelineAsync({
  label: '\u268b\u7c6d\ufda6\u0768\uc476\u0380\uc85f',
  layout: pipelineLayout38,
  multisample: {count: 4},
  fragment: {
  module: shaderModule39,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rgba8sint', writeMask: 0}, {format: 'rg8unorm', writeMask: GPUColorWrite.BLUE}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'dst-alpha', dstFactor: 'src-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rg8sint'}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'src-alpha-saturated'},
  },
}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {compare: 'greater', failOp: 'increment-clamp', depthFailOp: 'zero', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'greater', failOp: 'invert', depthFailOp: 'increment-clamp', passOp: 'increment-clamp'},
    stencilReadMask: 2335705193,
    stencilWriteMask: 1342722991,
    depthBiasClamp: 392.18137736384034,
  },
  vertex: {
    module: shaderModule39,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 328,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 112, shaderLocation: 13},
          {format: 'uint16x2', offset: 80, shaderLocation: 0},
          {format: 'uint8x2', offset: 30, shaderLocation: 12},
          {format: 'snorm8x2', offset: 48, shaderLocation: 1},
        ],
      },
      {arrayStride: 628, attributes: []},
      {
        arrayStride: 688,
        stepMode: 'instance',
        attributes: [{format: 'float32x3', offset: 128, shaderLocation: 7}],
      },
      {
        arrayStride: 276,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x4', offset: 56, shaderLocation: 14},
          {format: 'uint8x2', offset: 64, shaderLocation: 8},
          {format: 'uint32x2', offset: 144, shaderLocation: 9},
        ],
      },
      {arrayStride: 412, stepMode: 'instance', attributes: []},
      {arrayStride: 96, stepMode: 'instance', attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 392,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 76, shaderLocation: 2},
          {format: 'sint32x2', offset: 60, shaderLocation: 3},
          {format: 'sint32x3', offset: 4, shaderLocation: 15},
          {format: 'snorm8x2', offset: 106, shaderLocation: 5},
          {format: 'sint32x4', offset: 12, shaderLocation: 11},
          {format: 'snorm8x2', offset: 32, shaderLocation: 10},
          {format: 'sint16x2', offset: 148, shaderLocation: 4},
          {format: 'snorm16x2', offset: 60, shaderLocation: 6},
        ],
      },
    ],
  },
});
try {
  await promise89;
} catch {}
let commandEncoder340 = device6.createCommandEncoder({});
let querySet160 = device6.createQuerySet({type: 'occlusion', count: 234});
let computePassEncoder168 = commandEncoder298.beginComputePass({});
let sampler156 = device6.createSampler({
  label: '\ud672\ufb7a\u0542\u02f7\u{1f9e4}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  minFilter: 'linear',
  lodMinClamp: 21.00,
  lodMaxClamp: 67.66,
});
let externalTexture162 = device6.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'});
try {
commandEncoder340.copyTextureToBuffer({
  texture: texture179,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 460 widthInBlocks: 115 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 19376 */
  offset: 18916,
  rowsPerImage: 267,
  buffer: buffer60,
}, {width: 115, height: 1, depthOrArrayLayers: 1});
} catch {}
let offscreenCanvas40 = new OffscreenCanvas(425, 770);
let shaderModule58 = device4.createShaderModule({
  label: '\u4057\ub12f\ua608\uc62a\u5b75\u2e62\u{1fc8d}\ua1d6\u1012\u0c82\ue3c1',
  code: `@group(0) @binding(702)
var<storage, read_write> local21: array<u32>;
@group(2) @binding(317)
var<storage, read_write> function24: array<u32>;
@group(2) @binding(618)
var<storage, read_write> function25: array<u32>;

@compute @workgroup_size(5, 2, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(3) f0: vec3<f32>,
  @location(7) f1: vec4<f32>,
  @location(2) f2: vec2<f32>,
  @location(0) f3: vec4<u32>,
  @location(5) f4: vec3<f32>,
  @location(4) f5: vec3<i32>
}

@fragment
fn fragment0(@location(1) a0: i32, @location(4) a1: vec3<f16>, @location(14) a2: vec2<i32>, @location(15) a3: i32, @location(6) a4: vec3<i32>, @location(3) a5: vec3<f32>, @builtin(sample_index) a6: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S51 {
  @location(12) f0: vec4<i32>,
  @location(9) f1: vec4<u32>,
  @location(4) f2: vec3<f16>,
  @location(3) f3: vec4<f16>,
  @location(13) f4: i32,
  @location(14) f5: vec3<u32>,
  @location(7) f6: vec3<i32>,
  @location(2) f7: vec4<f16>,
  @location(15) f8: f32,
  @location(10) f9: vec4<f32>,
  @location(11) f10: vec4<f32>,
  @location(8) f11: vec4<f16>
}
struct VertexOutput0 {
  @location(4) f350: vec3<f16>,
  @location(3) f351: vec3<f32>,
  @location(1) f352: i32,
  @location(14) f353: vec2<i32>,
  @location(6) f354: vec3<i32>,
  @builtin(position) f355: vec4<f32>,
  @location(15) f356: i32
}

@vertex
fn vertex0(@location(5) a0: vec3<u32>, @location(6) a1: vec4<i32>, @location(0) a2: vec4<f16>, @location(1) a3: vec4<u32>, a4: S51, @builtin(instance_index) a5: u32, @builtin(vertex_index) a6: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  hints: {},
});
let buffer74 = device4.createBuffer({
  label: '\ub454\u{1ff11}\u0b09\uaac8\u92b9\u{1ffed}',
  size: 71400,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
  mappedAtCreation: true,
});
let commandEncoder341 = device4.createCommandEncoder({label: '\u8389\udfd9\uea7f\u07eb\u07d9'});
let texture225 = device4.createTexture({
  label: '\u{1ff60}\ub175\u{1feed}\u{1fc69}\u0a96\uaaab\uc19b',
  size: [164, 3, 937],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm'],
});
let textureView407 = texture154.createView({label: '\uc864\u7a9e\u9fd2\u2839\ue8f5\u97c5\u345d\u{1fa4a}', baseMipLevel: 7});
try {
computePassEncoder151.setBindGroup(0, bindGroup85);
} catch {}
try {
computePassEncoder167.end();
} catch {}
try {
querySet143.destroy();
} catch {}
let pipeline263 = device4.createComputePipeline({
  label: '\u{1fc2b}\u4a18\u{1f946}\ub44f\uc552',
  layout: pipelineLayout38,
  compute: {module: shaderModule50, entryPoint: 'compute0', constants: {}},
});
let gpuCanvasContext40 = offscreenCanvas40.getContext('webgpu');
let video53 = await videoWithData();
let imageData51 = new ImageData(56, 24);
let renderBundle196 = renderBundleEncoder141.finish({label: '\u0bf5\u{1ff31}\uc1c1\u{1f8df}\u74b4\u079c\ufefa\u{1fc37}\u0fbe'});
try {
renderBundleEncoder34.drawIndexed(157, 401, 1_859, 57_890_594, 885_093_263);
} catch {}
try {
renderBundleEncoder34.drawIndirect(buffer71, 37_888);
} catch {}
try {
renderBundleEncoder164.setVertexBuffer(0, buffer36, 0, 18_297);
} catch {}
let promise91 = buffer59.mapAsync(GPUMapMode.READ, 0, 329956);
try {
commandEncoder88.copyTextureToBuffer({
  texture: texture204,
  mipLevel: 0,
  origin: {x: 48, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 626 widthInBlocks: 313 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4534 */
  offset: 4534,
  bytesPerRow: 768,
  buffer: buffer12,
}, {width: 313, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder250.resolveQuerySet(querySet132, 42, 23, buffer18, 59904);
} catch {}
try {
device1.queue.submit([commandBuffer35, commandBuffer67]);
} catch {}
let promise92 = device1.createRenderPipelineAsync({
  label: '\u0f5c\u{1fecc}\u02ec\u{1f93d}\u6bb5\u03a6\ub079\u45f2\u{1fff9}\u6801',
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule24,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16uint'}, {format: 'rg32sint'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'never',
    stencilFront: {compare: 'less-equal', failOp: 'increment-clamp', depthFailOp: 'keep', passOp: 'decrement-wrap'},
    stencilBack: {failOp: 'decrement-wrap', depthFailOp: 'invert', passOp: 'decrement-wrap'},
    depthBias: 1973815322,
    depthBiasSlopeScale: 525.519843124337,
    depthBiasClamp: 658.3084620162164,
  },
  vertex: {
    module: shaderModule24,
    buffers: [
      {
        arrayStride: 280,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x2', offset: 96, shaderLocation: 1},
          {format: 'uint16x2', offset: 4, shaderLocation: 14},
        ],
      },
      {arrayStride: 128, stepMode: 'instance', attributes: []},
      {
        arrayStride: 104,
        attributes: [
          {format: 'sint32x2', offset: 0, shaderLocation: 12},
          {format: 'sint32', offset: 48, shaderLocation: 10},
        ],
      },
      {arrayStride: 188, stepMode: 'instance', attributes: []},
      {arrayStride: 1304, stepMode: 'instance', attributes: []},
      {arrayStride: 36, attributes: []},
      {arrayStride: 164, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 56,
        attributes: [
          {format: 'float32x4', offset: 0, shaderLocation: 6},
          {format: 'float32x4', offset: 0, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back'},
});
let shaderModule59 = device2.createShaderModule({
  label: '\u0caf\u{1f9d7}\u07a1\u{1ff8c}\u8fec',
  code: `@group(0) @binding(385)
var<storage, read_write> local22: array<u32>;
@group(0) @binding(552)
var<storage, read_write> local23: array<u32>;

@compute @workgroup_size(4, 1, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<f32>,
  @location(3) f1: vec3<f32>,
  @location(6) f2: vec4<i32>,
  @location(1) f3: vec4<f32>,
  @location(7) f4: i32,
  @location(4) f5: vec2<i32>,
  @location(2) f6: vec4<f32>,
  @location(5) f7: vec4<f32>
}

@fragment
fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(sample_mask) a1: u32, @builtin(sample_index) a2: u32, @builtin(front_facing) a3: bool) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S52 {
  @location(13) f0: vec2<i32>,
  @location(9) f1: vec4<i32>,
  @location(3) f2: vec4<u32>,
  @location(0) f3: f32,
  @location(12) f4: u32,
  @location(8) f5: vec2<f32>,
  @location(6) f6: vec3<f32>,
  @location(15) f7: vec2<u32>,
  @builtin(vertex_index) f8: u32,
  @location(10) f9: vec3<f32>,
  @location(4) f10: vec4<f32>,
  @location(1) f11: vec2<i32>,
  @location(2) f12: u32
}

@vertex
fn vertex0(@location(7) a0: vec2<u32>, @location(11) a1: vec3<f16>, a2: S52, @location(14) a3: vec2<u32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let textureView408 = texture138.createView({label: '\u{1f628}\ubc99\u1ab1\ud350\u{1fb80}', format: 'rgba8unorm-srgb', mipLevelCount: 4});
try {
renderBundleEncoder162.setBindGroup(3, bindGroup96);
} catch {}
try {
querySet83.destroy();
} catch {}
try {
commandEncoder159.resolveQuerySet(querySet90, 109, 108, buffer68, 8960);
} catch {}
let pipeline264 = device2.createRenderPipeline({
  label: '\ud481\uf25d\u0fae\u0840',
  layout: pipelineLayout14,
  multisample: {count: 4, mask: 0x316c316},
  fragment: {
  module: shaderModule42,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: 0}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst-alpha', dstFactor: 'constant'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-dst'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {
  format: 'rgba8unorm-srgb',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'r8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'dst-alpha', dstFactor: 'constant'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {
  format: 'r8sint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-constant', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one-minus-src', dstFactor: 'src-alpha'},
  },
  writeMask: 0,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule42,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 152, stepMode: 'instance', attributes: []},
      {arrayStride: 396, attributes: []},
      {
        arrayStride: 116,
        stepMode: 'vertex',
        attributes: [{format: 'float16x2', offset: 8, shaderLocation: 2}],
      },
      {arrayStride: 544, attributes: [{format: 'unorm16x4', offset: 200, shaderLocation: 1}]},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 160, attributes: [{format: 'snorm16x4', offset: 24, shaderLocation: 10}]},
      {arrayStride: 108, attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 80, shaderLocation: 15},
          {format: 'float32x4', offset: 756, shaderLocation: 11},
          {format: 'float16x2', offset: 12, shaderLocation: 9},
          {format: 'sint8x4', offset: 624, shaderLocation: 3},
          {format: 'sint32x3', offset: 376, shaderLocation: 4},
          {format: 'unorm8x2', offset: 236, shaderLocation: 13},
          {format: 'snorm16x2', offset: 92, shaderLocation: 6},
          {format: 'sint32x3', offset: 412, shaderLocation: 12},
          {format: 'uint32x4', offset: 672, shaderLocation: 8},
          {format: 'uint32', offset: 24, shaderLocation: 7},
          {format: 'snorm16x2', offset: 164, shaderLocation: 14},
          {format: 'unorm10-10-10-2', offset: 12, shaderLocation: 5},
          {format: 'unorm8x2', offset: 544, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'cw'},
});
let commandEncoder342 = device3.createCommandEncoder({label: '\uda16\ufae3\u087b\u0580\u{1ffd8}\u{1f996}\u0502\u{1fafc}\u0c68\u158a\u0050'});
let externalTexture163 = device3.importExternalTexture({
  label: '\u{1fd77}\u0177\u{1f73f}\u0fee\u40de\u0d99\u7f4e\u051b\u641d\u7d67',
  source: video17,
  colorSpace: 'display-p3',
});
try {
commandEncoder225.copyBufferToTexture({
  /* bytesInLastRow: 342 widthInBlocks: 171 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 79478 */
  offset: 78368,
  bytesPerRow: 768,
  buffer: buffer47,
}, {
  texture: texture186,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 171, height: 2, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder225.clearBuffer(buffer47);
} catch {}
let pipeline265 = await promise83;
let querySet161 = device2.createQuerySet({label: '\u0247\u16b4\u778b\u{1fda0}\u042b\u0442\u0d17\ubc96\u4669', type: 'occlusion', count: 2502});
try {
renderBundleEncoder74.setVertexBuffer(6, buffer68, 0, 97_686);
} catch {}
try {
commandEncoder216.copyTextureToBuffer({
  texture: texture197,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 93 widthInBlocks: 93 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 3465 */
  offset: 3372,
  rowsPerImage: 237,
  buffer: buffer43,
}, {width: 93, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
externalTexture106.label = '\u0956\u{1fe81}\u3819\ufd60\u91f3\u{1f675}\u0159\u0224\u071d';
} catch {}
let commandEncoder343 = device2.createCommandEncoder();
let textureView409 = texture118.createView({label: '\uf7eb\u6cb4\u0d07\ubde8\ub834\u703d\uddf3\u8777\u0827\u08da', baseMipLevel: 1});
let sampler157 = device2.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 33.90,
  lodMaxClamp: 70.40,
  maxAnisotropy: 16,
});
let externalTexture164 = device2.importExternalTexture({label: '\u8868\u{1f79c}', source: video28, colorSpace: 'display-p3'});
try {
renderBundleEncoder106.setBindGroup(1, bindGroup98);
} catch {}
try {
commandEncoder262.copyTextureToTexture({
  texture: texture94,
  mipLevel: 1,
  origin: {x: 40, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture132,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 60, height: 6, depthOrArrayLayers: 1}
*/
{
  source: video28,
  origin: { x: 0, y: 1 },
  flipY: true,
}, {
  texture: texture215,
  mipLevel: 2,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
  await promise84;
} catch {}
video9.height = 110;
gc();
try {
adapter4.label = '\u00fa\u{1fc7d}\u0235\u{1ff1c}\u1132\u53bb\u0b21';
} catch {}
let bindGroupLayout94 = device1.createBindGroupLayout({
  label: '\u8156\ud551\u9219',
  entries: [
    {
      binding: 310,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 336,
      visibility: GPUShaderStage.VERTEX,
      texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false },
    },
  ],
});
let commandEncoder344 = device1.createCommandEncoder();
let renderBundleEncoder174 = device1.createRenderBundleEncoder({
  label: '\uc67b\u{1f634}\u{1f7fd}\u{1f909}\u79f9\uf0ef\ua1bc\u4fca\u{1f817}\u5b8e\u00c1',
  colorFormats: ['rgba8sint', 'rg16uint', 'rg32sint'],
  depthReadOnly: true,
});
try {
renderBundleEncoder34.drawIndirect(buffer15, 4_404);
} catch {}
try {
renderBundleEncoder68.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder68.setVertexBuffer(4, buffer13, 404, 11_773);
} catch {}
try {
commandEncoder294.copyBufferToTexture({
  /* bytesInLastRow: 1248 widthInBlocks: 312 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3600 */
  offset: 2352,
  buffer: buffer15,
}, {
  texture: texture155,
  mipLevel: 0,
  origin: {x: 67, y: 0, z: 0},
  aspect: 'all',
}, {width: 312, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder245.copyTextureToBuffer({
  texture: texture171,
  mipLevel: 0,
  origin: {x: 10, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 20716 */
  offset: 20716,
  bytesPerRow: 256,
  buffer: buffer13,
}, {width: 1, height: 49, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder116.copyTextureToTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture142,
  mipLevel: 3,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 4, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder284.clearBuffer(buffer71, 36352);
} catch {}
try {
commandEncoder320.resolveQuerySet(querySet122, 38, 58, buffer36, 5120);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture116,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer21, /* required buffer size: 180_399 */
{offset: 477, bytesPerRow: 314, rowsPerImage: 191}, {width: 5, height: 0, depthOrArrayLayers: 4});
} catch {}
let pipeline266 = device1.createComputePipeline({
  label: '\u4185\u1518\u0886\u0539\u68b7\u{1fdc9}\ub78d\u4948',
  layout: pipelineLayout5,
  compute: {module: shaderModule33, entryPoint: 'compute0', constants: {}},
});
try {
if (!arrayBuffer15.detached) { new Uint8Array(arrayBuffer15).fill(0x55) };
} catch {}
let commandEncoder345 = device3.createCommandEncoder({label: '\u{1fd6a}\u463e\uc283\u097b\u{1ff05}\u7a38'});
let computePassEncoder169 = commandEncoder271.beginComputePass({label: '\u8b4b\u1f2b\u0fe3\u52ed\u5583\u0267\u1757\u0773'});
try {
commandEncoder287.copyBufferToBuffer(buffer47, 165780, buffer70, 36624, 25692);
} catch {}
try {
if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55) };
} catch {}
let pipelineLayout39 = device3.createPipelineLayout({
  label: '\uf574\u0996\u06e9\u050f\u06ff\u033b\u{1f705}\u21ec\ufca6\u{1fe94}',
  bindGroupLayouts: [bindGroupLayout56, bindGroupLayout64],
});
let textureView410 = texture176.createView({aspect: 'all', baseMipLevel: 3, mipLevelCount: 1});
let renderBundleEncoder175 = device3.createRenderBundleEncoder({
  label: '\ud912\u{1fd0d}\ub7c1\u6495\u1bd5\u0a20',
  colorFormats: ['r16float', 'rgba32float', 'rg8unorm', 'r16uint', 'rgba8uint'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: false,
});
let externalTexture165 = device3.importExternalTexture({source: video38, colorSpace: 'display-p3'});
try {
renderBundleEncoder126.setBindGroup(3, bindGroup69);
} catch {}
let arrayBuffer26 = buffer46.getMappedRange(0, 454056);
try {
buffer45.unmap();
} catch {}
try {
  await promise87;
} catch {}
let texture226 = device0.createTexture({
  size: [165, 120, 124],
  mipLevelCount: 3,
  format: 'rg16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg16float', 'rg16float', 'rg16float'],
});
let computePassEncoder170 = commandEncoder290.beginComputePass();
let renderBundle197 = renderBundleEncoder160.finish({label: '\u0520\ua768\u5a08\u402c\u1f4d\u8068\u0207\u{1fedc}'});
try {
computePassEncoder1.setBindGroup(3, bindGroup10);
} catch {}
try {
renderPassEncoder6.setBindGroup(2, bindGroup53);
} catch {}
try {
renderPassEncoder8.endOcclusionQuery();
} catch {}
try {
renderPassEncoder17.setPipeline(pipeline67);
} catch {}
try {
renderBundleEncoder158.setBindGroup(2, bindGroup104, new Uint32Array(4873), 1894, 0);
} catch {}
try {
renderBundleEncoder50.draw(29, 289, 1_264_099_785, 198_670_076);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(5, buffer35, 7_028, 2_090);
} catch {}
try {
commandEncoder95.copyBufferToBuffer(buffer9, 132316, buffer6, 3244, 16968);
} catch {}
try {
device0.queue.submit([]);
} catch {}
try {
device0.queue.writeBuffer(buffer3, 468, new Float32Array(59598), 5679, 312);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 165, height: 120, depthOrArrayLayers: 164}
*/
{
  source: img34,
  origin: { x: 9, y: 4 },
  flipY: true,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 27, y: 3, z: 30},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 4, height: 13, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext41 = canvas49.getContext('webgpu');
let pipelineLayout40 = device6.createPipelineLayout({
  label: '\uc2af\u06ea\u0f98\ua471\u{1fc17}',
  bindGroupLayouts: [bindGroupLayout86, bindGroupLayout88, bindGroupLayout86],
});
let textureView411 = texture191.createView({label: '\u8427\u0ec2\u0146\ud36e\ue46e\u64d0', mipLevelCount: 3});
let texture227 = device3.createTexture({
  label: '\u{1fabb}\u{1f6ba}\u{1f609}\u{1f635}\u9989',
  size: {width: 351, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 7,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba32float'],
});
let renderBundle198 = renderBundleEncoder98.finish();
try {
computePassEncoder126.setPipeline(pipeline252);
} catch {}
try {
renderBundleEncoder126.setIndexBuffer(buffer47, 'uint16', 16_002, 36_945);
} catch {}
try {
commandEncoder315.copyBufferToBuffer(buffer47, 52216, buffer46, 25796, 65536);
} catch {}
try {
commandEncoder225.clearBuffer(buffer70);
} catch {}
try {
commandEncoder301.resolveQuerySet(querySet130, 0, 0, buffer64, 12800);
} catch {}
try {
device3.queue.submit([commandBuffer48]);
} catch {}
let imageData52 = new ImageData(16, 84);
let shaderModule60 = device6.createShaderModule({
  label: '\u{1f647}\u024e\u56f7\u0a86\uf004\u7a6e\u0499',
  code: `@group(2) @binding(196)
var<storage, read_write> parameter24: array<u32>;
@group(2) @binding(664)
var<storage, read_write> local24: array<u32>;
@group(0) @binding(196)
var<storage, read_write> local25: array<u32>;
@group(0) @binding(664)
var<storage, read_write> function26: array<u32>;

@compute @workgroup_size(5, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(2) f0: vec4<u32>,
  @location(1) f1: vec4<i32>,
  @location(0) f2: i32,
  @location(3) f3: vec4<u32>
}

@fragment
fn fragment0(@location(1) a0: vec4<u32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S53 {
  @location(14) f0: f16,
  @location(9) f1: f32,
  @location(2) f2: vec3<f32>,
  @location(7) f3: f16,
  @location(5) f4: vec4<f16>,
  @location(4) f5: vec2<i32>,
  @location(12) f6: u32,
  @location(15) f7: f32,
  @location(6) f8: i32
}
struct VertexOutput0 {
  @location(10) f357: f16,
  @location(4) f358: vec3<f32>,
  @builtin(position) f359: vec4<f32>,
  @location(1) f360: vec4<u32>
}

@vertex
fn vertex0(@location(1) a0: vec3<i32>, @location(13) a1: vec3<i32>, @location(8) a2: f32, @location(11) a3: vec3<u32>, @location(3) a4: vec3<f32>, @location(0) a5: vec4<u32>, a6: S53, @builtin(vertex_index) a7: u32, @location(10) a8: f16, @builtin(instance_index) a9: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let renderBundle199 = renderBundleEncoder142.finish({label: '\udb31\ud14f\u476b\u{1f91c}\u0d44\u0dd5\u{1f7c3}\u{1faa7}'});
try {
commandEncoder340.copyTextureToTexture({
  texture: texture179,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture196,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder340.clearBuffer(buffer60, 119864, 42508);
} catch {}
try {
commandEncoder324.resolveQuerySet(querySet160, 2, 19, buffer60, 256);
} catch {}
let adapter8 = await promise30;
let shaderModule61 = device4.createShaderModule({
  label: '\u0968\u706f\u0670\u245a\u026d\u03bb\u9959',
  code: `@group(0) @binding(878)
var<storage, read_write> n26: array<u32>;
@group(0) @binding(37)
var<storage, read_write> type18: array<u32>;
@group(0) @binding(362)
var<storage, read_write> n27: array<u32>;

@compute @workgroup_size(1, 4, 2)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S55 {
  @location(15) f0: vec2<f16>,
  @builtin(front_facing) f1: bool,
  @location(9) f2: vec2<i32>,
  @location(7) f3: f32,
  @location(8) f4: vec2<u32>,
  @location(2) f5: vec3<f32>,
  @location(3) f6: vec3<i32>,
  @location(1) f7: f16,
  @location(13) f8: vec2<f16>,
  @location(5) f9: vec4<f16>
}
struct FragmentOutput0 {
  @location(2) f0: vec2<f32>,
  @location(5) f1: vec4<f32>,
  @location(4) f2: vec3<i32>,
  @location(0) f3: vec4<u32>,
  @location(1) f4: vec4<i32>,
  @location(3) f5: vec3<f32>
}

@fragment
fn fragment0(@location(4) a0: i32, @builtin(position) a1: vec4<f32>, @builtin(sample_mask) a2: u32, @location(14) a3: vec2<u32>, @location(0) a4: vec2<u32>, a5: S55, @location(6) a6: vec3<f16>, @builtin(sample_index) a7: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S54 {
  @location(3) f0: u32,
  @builtin(instance_index) f1: u32,
  @location(8) f2: vec4<u32>,
  @location(10) f3: vec2<u32>,
  @location(4) f4: vec4<f32>,
  @builtin(vertex_index) f5: u32,
  @location(0) f6: vec2<u32>,
  @location(5) f7: vec4<u32>,
  @location(15) f8: vec4<u32>,
  @location(2) f9: f32,
  @location(7) f10: vec4<i32>,
  @location(9) f11: f16,
  @location(13) f12: f16
}
struct VertexOutput0 {
  @location(6) f361: vec3<f16>,
  @location(14) f362: vec2<u32>,
  @location(3) f363: vec3<i32>,
  @location(13) f364: vec2<f16>,
  @location(4) f365: i32,
  @location(7) f366: f32,
  @location(1) f367: f16,
  @location(9) f368: vec2<i32>,
  @builtin(position) f369: vec4<f32>,
  @location(8) f370: vec2<u32>,
  @location(2) f371: vec3<f32>,
  @location(15) f372: vec2<f16>,
  @location(0) f373: vec2<u32>,
  @location(5) f374: vec4<f16>
}

@vertex
fn vertex0(@location(6) a0: vec3<u32>, @location(14) a1: vec4<i32>, @location(11) a2: vec4<i32>, @location(12) a3: vec4<u32>, a4: S54, @location(1) a5: vec3<i32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder346 = device4.createCommandEncoder({label: '\u3371\u4181\u{1f7ef}\u6eaa\ub4cc'});
let texture228 = device4.createTexture({
  label: '\ucb4c\uee51\u{1fc80}\u{1fd36}\ue02c\u{1fe2b}\u1077\ubae0\u0737\u4631\u{1f824}',
  size: {width: 328, height: 6, depthOrArrayLayers: 523},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView412 = texture127.createView({label: '\ubdb9\u5111\u37b8', dimension: '2d-array'});
let sampler158 = device4.createSampler({
  label: '\u09c7\ua774\u9455\u{1f744}\u03ac\u7b86\u96db\u6df9\u0069\u{1fa42}\u61d5',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 38.10,
  lodMaxClamp: 65.13,
  compare: 'not-equal',
});
try {
renderBundleEncoder122.setPipeline(pipeline166);
} catch {}
try {
gpuCanvasContext22.configure({
  device: device4,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
device4.queue.writeBuffer(buffer56, 23644, new Int16Array(19479), 10052, 2860);
} catch {}
try {
  await device4.queue.onSubmittedWorkDone();
} catch {}
let pipeline267 = await device4.createRenderPipelineAsync({
  label: '\u11d5\u{1ff1c}\u03cd',
  layout: pipelineLayout36,
  fragment: {
  module: shaderModule58,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba8sint', writeMask: 0}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'dst'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: 0,
}, {format: 'rg8sint'}, {format: 'rg8unorm', writeMask: 0}],
},
  vertex: {
    module: shaderModule58,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 240, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 152,
        attributes: [
          {format: 'float32x4', offset: 16, shaderLocation: 3},
          {format: 'uint16x4', offset: 60, shaderLocation: 5},
          {format: 'snorm16x4', offset: 20, shaderLocation: 11},
        ],
      },
      {arrayStride: 68, attributes: [{format: 'sint32', offset: 0, shaderLocation: 6}]},
      {arrayStride: 128, stepMode: 'instance', attributes: []},
      {arrayStride: 728, attributes: []},
      {
        arrayStride: 328,
        stepMode: 'instance',
        attributes: [{format: 'float16x4', offset: 20, shaderLocation: 0}],
      },
      {arrayStride: 328, attributes: [{format: 'uint32x2', offset: 72, shaderLocation: 1}]},
      {
        arrayStride: 16,
        stepMode: 'vertex',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4},
          {format: 'unorm8x4', offset: 0, shaderLocation: 10},
          {format: 'uint32x4', offset: 0, shaderLocation: 14},
          {format: 'unorm8x2', offset: 6, shaderLocation: 8},
          {format: 'uint16x2', offset: 4, shaderLocation: 9},
          {format: 'unorm16x2', offset: 0, shaderLocation: 15},
          {format: 'sint32x4', offset: 0, shaderLocation: 7},
          {format: 'sint16x2', offset: 0, shaderLocation: 12},
          {format: 'sint32x2', offset: 0, shaderLocation: 13},
          {format: 'float16x4', offset: 0, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'front', unclippedDepth: true},
});
let gpuCanvasContext42 = canvas50.getContext('webgpu');
try {
  await promise86;
} catch {}
let commandEncoder347 = device2.createCommandEncoder();
let commandBuffer80 = commandEncoder302.finish({label: '\u9cf6\u{1f6fc}\u{1f7da}'});
let computePassEncoder171 = commandEncoder317.beginComputePass();
let renderBundle200 = renderBundleEncoder109.finish({});
try {
renderBundleEncoder74.setPipeline(pipeline168);
} catch {}
try {
commandEncoder300.copyBufferToBuffer(buffer33, 85032, buffer43, 2784, 3252);
} catch {}
try {
commandEncoder216.clearBuffer(buffer55, 60516, 9664);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 180, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas50,
  origin: { x: 7, y: 7 },
  flipY: false,
}, {
  texture: texture109,
  mipLevel: 1,
  origin: {x: 34, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 12, height: 0, depthOrArrayLayers: 0});
} catch {}
let img35 = await imageWithData(114, 21, '#bb23141e', '#fe35e137');
try {
adapter0.label = '\u{1fa1e}\u{1f670}\ubdbe\u007b\u9295\u7e8a\ubc30\u22c2';
} catch {}
let commandBuffer81 = commandEncoder300.finish({label: '\uaab3\u{1ffb6}\u{1f849}\u{1ff23}\ufd36\ubb9f\u0484\u{1f6f6}'});
let texture229 = device2.createTexture({
  label: '\uee1e\u046f\u046c\ub357\u0d1a\u00f7\u{1f80b}\u6ee3\u154c\u2c63\u{1f786}',
  size: {width: 240},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg8unorm', 'rg8unorm'],
});
let textureView413 = texture190.createView({label: '\uc28a\ud71d', dimension: '2d-array', aspect: 'all', baseMipLevel: 1});
let renderBundle201 = renderBundleEncoder108.finish();
let sampler159 = device2.createSampler({
  label: '\u3d0b\u25a5\u3fb6\ub3fb\ud514\u90dd\u36b3',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 65.92,
});
try {
renderBundleEncoder106.setPipeline(pipeline192);
} catch {}
try {
commandEncoder310.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 16005 */
  offset: 16005,
  buffer: buffer23,
}, {
  texture: texture114,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder159.resolveQuerySet(querySet125, 29, 321, buffer65, 11520);
} catch {}
try {
device2.queue.writeBuffer(buffer65, 7756, new BigUint64Array(41312), 30517, 248);
} catch {}
let pipeline268 = device2.createComputePipeline({
  label: '\u{1fd4e}\u0d0d\u53c6\u024c\u90fc\u{1f95b}',
  layout: pipelineLayout13,
  compute: {module: shaderModule46, entryPoint: 'compute0', constants: {}},
});
document.body.prepend(video15);
let textureView414 = texture35.createView({dimension: '2d', baseArrayLayer: 94});
let externalTexture166 = device0.importExternalTexture({label: '\u{1f68e}\u381d\u{1fcfa}\u03f4\u1ff0', source: video15, colorSpace: 'srgb'});
try {
renderPassEncoder13.beginOcclusionQuery(223);
} catch {}
try {
renderPassEncoder15.setScissorRect(556, 210, 90, 257);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(2, buffer34, 0, 10_226);
} catch {}
try {
renderBundleEncoder50.draw(59, 723, 1_355_053_965, 240_092_225);
} catch {}
try {
renderBundleEncoder50.drawIndexed(1_240, 153, 633, -1_878_739_228, 809_500_973);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer5, 34_912);
} catch {}
try {
commandEncoder148.copyBufferToBuffer(buffer3, 53900, buffer14, 5180, 7400);
} catch {}
try {
commandEncoder240.copyBufferToTexture({
  /* bytesInLastRow: 420 widthInBlocks: 105 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 17620 */
  offset: 17620,
  bytesPerRow: 512,
  buffer: buffer5,
}, {
  texture: texture222,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 105, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder190.clearBuffer(buffer7);
} catch {}
try {
device0.queue.submit([commandBuffer73]);
} catch {}
let bindGroup113 = device3.createBindGroup({
  label: '\u{1fac0}\u{1f7e4}\u5d36\u{1fd35}\udba1\u{1f8f5}\u{1f613}\u{1f874}\uf0e6\u{1f931}\u2843',
  layout: bindGroupLayout48,
  entries: [],
});
let textureView415 = texture106.createView({label: '\u080f\u6068', dimension: '2d-array', baseArrayLayer: 0});
let renderBundle202 = renderBundleEncoder86.finish({label: '\ufb6b\uce3c\u04bf\u0cdb\ue4fa\ue1e3\u{1fab8}\u{1fe0a}\u034b'});
let sampler160 = device3.createSampler({
  label: '\u05c2\u{1f7af}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 90.73,
  lodMaxClamp: 96.68,
  maxAnisotropy: 19,
});
try {
commandEncoder342.resolveQuerySet(querySet81, 81, 632, buffer64, 9984);
} catch {}
let pipeline269 = device3.createRenderPipeline({
  label: '\u5cdf\u058b\u0775',
  layout: pipelineLayout35,
  fragment: {
  module: shaderModule53,
  entryPoint: 'fragment0',
  targets: [{format: 'rg8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba8unorm-srgb', writeMask: 0}, {format: 'rgba8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, undefined, {format: 'rgba8sint'}, {format: 'rg32uint'}, {format: 'rg8unorm', writeMask: 0}],
},
  vertex: {
    module: shaderModule53,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 104, attributes: [{format: 'snorm16x4', offset: 8, shaderLocation: 14}]},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'uint32x3', offset: 20, shaderLocation: 8}],
      },
      {arrayStride: 80, attributes: []},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'unorm16x2', offset: 52, shaderLocation: 15}],
      },
      {arrayStride: 116, stepMode: 'instance', attributes: []},
      {arrayStride: 1140, attributes: [{format: 'sint32x3', offset: 40, shaderLocation: 9}]},
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 32, shaderLocation: 7},
          {format: 'sint16x2', offset: 136, shaderLocation: 13},
          {format: 'sint32', offset: 1724, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 400, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 400,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 56, shaderLocation: 0},
          {format: 'uint32x2', offset: 92, shaderLocation: 3},
          {format: 'float16x2', offset: 72, shaderLocation: 1},
          {format: 'unorm16x2', offset: 24, shaderLocation: 10},
          {format: 'float32x4', offset: 180, shaderLocation: 12},
          {format: 'sint32x2', offset: 100, shaderLocation: 11},
          {format: 'snorm8x4', offset: 236, shaderLocation: 4},
          {format: 'snorm16x2', offset: 36, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'none'},
});
video49.height = 269;
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55) };
} catch {}
let bindGroupLayout95 = device2.createBindGroupLayout({
  label: '\ud78a\u{1f612}\u{1f7aa}\u0d91\ud65a\u{1f9d1}',
  entries: [
    {binding: 930, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 854,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '2d-array' },
    },
    {binding: 415, visibility: 0, externalTexture: {}},
  ],
});
let bindGroupLayout96 = pipeline114.getBindGroupLayout(0);
let buffer75 = device2.createBuffer({
  label: '\u019c\ud6ea\u144f\u39c0\ua1e8\u049b\u0f12\ue354\u308b\u1c99\ucaa9',
  size: 113549,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let commandEncoder348 = device2.createCommandEncoder({label: '\u0d5d\ufbd8\u{1f868}\u4a51\u4b65\u0ddb\u2fe7\u{1f849}\u17d2\u03e2'});
let textureView416 = texture113.createView({
  label: '\u4933\u6125\ue6c9\u7bd4\u7280\u{1f756}\u{1fb94}\u1ca6',
  dimension: '2d',
  format: 'bgra8unorm-srgb',
  baseArrayLayer: 16,
});
try {
computePassEncoder171.setBindGroup(3, bindGroup96, new Uint32Array(5900), 2665, 0);
} catch {}
try {
renderBundleEncoder114.setBindGroup(1, bindGroup98);
} catch {}
try {
renderBundleEncoder114.setBindGroup(2, bindGroup72, new Uint32Array(9660), 4708, 0);
} catch {}
try {
commandEncoder303.copyTextureToBuffer({
  texture: texture215,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 1},
  aspect: 'all',
}, {
  /* bytesInLastRow: 284 widthInBlocks: 71 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 172316 */
  offset: 5632,
  bytesPerRow: 512,
  rowsPerImage: 304,
  buffer: buffer33,
}, {width: 71, height: 22, depthOrArrayLayers: 2});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 6, height: 4, depthOrArrayLayers: 26}
*/
{
  source: offscreenCanvas38,
  origin: { x: 0, y: 35 },
  flipY: true,
}, {
  texture: texture118,
  mipLevel: 2,
  origin: {x: 2, y: 0, z: 8},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise91;
} catch {}
let offscreenCanvas41 = new OffscreenCanvas(937, 716);
let computePassEncoder172 = commandEncoder311.beginComputePass();
try {
renderBundleEncoder69.setBindGroup(3, bindGroup99, [1280]);
} catch {}
try {
renderBundleEncoder114.setPipeline(pipeline133);
} catch {}
try {
commandEncoder276.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 23168 */
  offset: 23168,
  buffer: buffer33,
}, {
  texture: texture138,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder336.copyTextureToTexture({
  texture: texture85,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture109,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
},
{width: 37, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.writeBuffer(buffer75, 10284, new DataView(new ArrayBuffer(27380)), 547, 2240);
} catch {}
let canvas51 = document.createElement('canvas');
try {
offscreenCanvas41.getContext('webgpu');
} catch {}
let shaderModule62 = device1.createShaderModule({
  label: '\u04e3\u7967\ucd3d\u0af1\u0ec1\u273c',
  code: `@group(3) @binding(959)
var<storage, read_write> n28: array<u32>;
@group(3) @binding(522)
var<storage, read_write> parameter25: array<u32>;

@compute @workgroup_size(3, 4, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(1) f0: vec3<i32>,
  @location(0) f1: vec4<i32>,
  @location(3) f2: i32,
  @location(2) f3: vec4<f32>
}

@fragment
fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(front_facing) a1: bool) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(8) a0: vec3<i32>, @location(7) a1: u32, @location(15) a2: vec2<f32>, @location(10) a3: vec3<u32>, @location(2) a4: vec3<f16>, @location(4) a5: vec2<f16>, @location(5) a6: f32, @location(9) a7: vec4<f16>, @location(0) a8: i32, @location(1) a9: vec3<i32>, @builtin(vertex_index) a10: u32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let buffer76 = device1.createBuffer({
  label: '\u{1f79c}\u{1fdc2}\u7bab',
  size: 1048576,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder349 = device1.createCommandEncoder();
let renderBundleEncoder176 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'r32sint', 'rgb10a2unorm'], depthStencilFormat: 'depth32float'});
try {
computePassEncoder42.setPipeline(pipeline217);
} catch {}
try {
renderBundleEncoder107.setBindGroup(2, bindGroup66, new Uint32Array(2618), 1482, 0);
} catch {}
try {
renderBundleEncoder34.drawIndexed(2_499, 72, 4_312, 318_692_172, 26_323_588);
} catch {}
try {
renderBundleEncoder164.setPipeline(pipeline131);
} catch {}
try {
renderBundleEncoder155.setVertexBuffer(1, buffer42, 0);
} catch {}
try {
commandEncoder284.clearBuffer(buffer59, 266652, 11536);
} catch {}
try {
device1.queue.writeBuffer(buffer12, 576, new Float32Array(22087), 15810, 16);
} catch {}
let pipeline270 = device1.createComputePipeline({
  label: '\u08af\u8cd6\u8947\u2ecf\u02f0\u{1f96c}\u8664\u3b53',
  layout: pipelineLayout24,
  compute: {module: shaderModule48, entryPoint: 'compute0', constants: {}},
});
let offscreenCanvas42 = new OffscreenCanvas(699, 130);
let img36 = await imageWithData(119, 197, '#73f5fb3c', '#2bfddaef');
let commandEncoder350 = device0.createCommandEncoder({label: '\u04e4\u{1f8c5}\uc210\u1bcc'});
let textureView417 = texture2.createView({baseMipLevel: 3, mipLevelCount: 1, arrayLayerCount: 1});
try {
renderPassEncoder19.setStencilReference(3688);
} catch {}
try {
renderBundleEncoder29.draw(111, 47, 122, 1_707_339_158);
} catch {}
try {
renderBundleEncoder56.drawIndirect(buffer11, 176_136);
} catch {}
try {
renderBundleEncoder133.setVertexBuffer(6, buffer53, 1_764, 174);
} catch {}
try {
commandEncoder230.copyTextureToTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 189, y: 449, z: 318},
  aspect: 'all',
},
{
  texture: texture27,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 3, depthOrArrayLayers: 32});
} catch {}
try {
commandEncoder312.clearBuffer(buffer40, 94308, 189880);
} catch {}
let pipeline271 = await device0.createRenderPipelineAsync({
  label: '\uabe0\u761b\ua392\uba9b\u{1fae8}',
  layout: pipelineLayout3,
  multisample: {count: 4},
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'greater-equal', failOp: 'increment-wrap', passOp: 'keep'},
    stencilBack: {
      compare: 'less-equal',
      failOp: 'increment-wrap',
      depthFailOp: 'increment-clamp',
      passOp: 'increment-wrap',
    },
    stencilReadMask: 2257969905,
    stencilWriteMask: 1545679062,
    depthBiasSlopeScale: 483.33469326828356,
    depthBiasClamp: 319.36979977731556,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 616,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32', offset: 112, shaderLocation: 0},
          {format: 'unorm8x4', offset: 352, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 108,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 4, shaderLocation: 14},
          {format: 'float32x2', offset: 8, shaderLocation: 9},
          {format: 'float16x4', offset: 16, shaderLocation: 3},
        ],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 156, stepMode: 'instance', attributes: []},
      {arrayStride: 352, stepMode: 'instance', attributes: []},
      {arrayStride: 136, stepMode: 'instance', attributes: []},
      {
        arrayStride: 776,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x4', offset: 220, shaderLocation: 11},
          {format: 'snorm8x2', offset: 46, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 120,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 0, shaderLocation: 13},
          {format: 'uint32', offset: 8, shaderLocation: 10},
          {format: 'unorm16x4', offset: 8, shaderLocation: 15},
          {format: 'sint32x3', offset: 4, shaderLocation: 1},
          {format: 'uint32x4', offset: 12, shaderLocation: 4},
          {format: 'unorm16x2', offset: 0, shaderLocation: 7},
          {format: 'uint32x3', offset: 0, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 2},
          {format: 'float32x3', offset: 12, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {frontFace: 'ccw', cullMode: 'front'},
});
let canvas52 = document.createElement('canvas');
let querySet162 = device1.createQuerySet({type: 'occlusion', count: 3345});
try {
computePassEncoder138.setBindGroup(0, bindGroup33);
} catch {}
let arrayBuffer27 = buffer37.getMappedRange(3568, 76);
try {
commandEncoder115.copyBufferToBuffer(buffer13, 65924, buffer12, 2424, 3924);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture204,
  mipLevel: 0,
  origin: {x: 51, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(arrayBuffer26), /* required buffer size: 394 */
{offset: 394, rowsPerImage: 129}, {width: 445, height: 0, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas43 = new OffscreenCanvas(467, 914);
let textureView418 = texture191.createView({label: '\u27b6\u3157\u{1f98f}\u0828\ua554\uc3e4\u0d08\u09c8\u00e3\uacae\u2f1a'});
let renderBundle203 = renderBundleEncoder149.finish({label: '\u03a9\u3af9\ud21b\u6699\u0b0f\u0886\u{1f773}\ub8ff'});
try {
renderBundleEncoder157.setVertexBuffer(3, buffer60, 22_060, 41_427);
} catch {}
try {
commandEncoder340.copyTextureToBuffer({
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 80904 */
  offset: 80904,
  buffer: buffer60,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipelineLayout41 = device4.createPipelineLayout({label: '\u68cf\u5f2a', bindGroupLayouts: []});
let commandEncoder351 = device4.createCommandEncoder({});
try {
renderBundleEncoder173.setIndexBuffer(buffer51, 'uint16', 3_226, 20_247);
} catch {}
try {
renderBundleEncoder127.setVertexBuffer(3, buffer56, 330_408, 27_681);
} catch {}
try {
buffer58.destroy();
} catch {}
try {
commandEncoder238.copyTextureToTexture({
  texture: texture192,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture124,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
},
{width: 51, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device4,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await promise88;
} catch {}
let buffer77 = device4.createBuffer({
  size: 226339,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
let commandEncoder352 = device4.createCommandEncoder();
let querySet163 = device4.createQuerySet({
  label: '\u{1fd6d}\u4dfb\u4c57\u{1fd5f}\u{1f8db}\ua2f9\u06bb\u0a87\u{1f731}',
  type: 'occlusion',
  count: 856,
});
let texture230 = device4.createTexture({
  label: '\ueb41\u057a',
  size: [1312, 24, 1],
  mipLevelCount: 6,
  dimension: '2d',
  format: 'rg8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView419 = texture136.createView({label: '\u1dbc\ufe39\u9487\ue5a2\u{1f989}\uf5ce\u0b2e\u3f72\ud90c', baseMipLevel: 7});
let renderBundleEncoder177 = device4.createRenderBundleEncoder({
  label: '\u{1f69c}\u46b3\ue297\u{1f91f}\uad9e',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
let externalTexture167 = device4.importExternalTexture({
  label: '\uf7ee\u{1fb31}\u{1fe1f}\u{1f92b}\u8cc2\u1c08\u0bc4',
  source: videoFrame39,
  colorSpace: 'display-p3',
});
try {
computePassEncoder129.setBindGroup(1, bindGroup85);
} catch {}
try {
computePassEncoder113.setBindGroup(3, bindGroup85, new Uint32Array(3696), 2320, 0);
} catch {}
try {
computePassEncoder151.setPipeline(pipeline258);
} catch {}
try {
renderBundleEncoder177.setPipeline(pipeline170);
} catch {}
try {
commandEncoder339.copyBufferToBuffer(buffer58, 96280, buffer51, 94764, 2696);
} catch {}
try {
commandEncoder346.copyTextureToTexture({
  texture: texture228,
  mipLevel: 1,
  origin: {x: 42, y: 0, z: 6},
  aspect: 'all',
},
{
  texture: texture129,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext31.configure({
  device: device4,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline272 = await device4.createComputePipelineAsync({
  label: '\u6cec\ue096',
  layout: pipelineLayout41,
  compute: {module: shaderModule58, entryPoint: 'compute0', constants: {}},
});
let gpuCanvasContext43 = canvas51.getContext('webgpu');
video22.height = 286;
let commandEncoder353 = device6.createCommandEncoder({label: '\u{1f623}\u0dd4\u5b8b\uf140\u5afb\u{1fc19}\u0020\u030f\u3205'});
let sampler161 = device6.createSampler({
  label: '\u{1fd93}\ude56\uebbb\u5300',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 53.08,
  lodMaxClamp: 76.71,
  maxAnisotropy: 10,
});
try {
commandEncoder340.copyTextureToBuffer({
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 25780 */
  offset: 25780,
  buffer: buffer60,
}, {width: 1, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device6.queue.submit([commandBuffer76, commandBuffer65, commandBuffer69]);
} catch {}
let pipeline273 = device6.createRenderPipeline({
  label: '\u047f\u4007\u3c6a\u3d7c\ufe0b\ub30e\u08a1\u0604\u{1fc77}\u{1fb26}\u69fe',
  layout: 'auto',
  fragment: {
  module: shaderModule60,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba16sint', writeMask: 0}, {format: 'rgb10a2uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {
  format: 'rgb10a2uint',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule60,
    buffers: [
      {
        arrayStride: 1080,
        attributes: [
          {format: 'unorm8x4', offset: 328, shaderLocation: 8},
          {format: 'float16x2', offset: 260, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 104,
        attributes: [
          {format: 'uint16x4', offset: 16, shaderLocation: 11},
          {format: 'float16x4', offset: 4, shaderLocation: 2},
          {format: 'uint8x4', offset: 24, shaderLocation: 0},
          {format: 'unorm16x2', offset: 0, shaderLocation: 3},
          {format: 'sint32', offset: 8, shaderLocation: 4},
          {format: 'uint32x2', offset: 16, shaderLocation: 12},
          {format: 'unorm16x2', offset: 0, shaderLocation: 10},
          {format: 'sint32', offset: 0, shaderLocation: 13},
        ],
      },
      {arrayStride: 492, attributes: [{format: 'float32x2', offset: 8, shaderLocation: 9}]},
      {arrayStride: 360, stepMode: 'instance', attributes: []},
      {arrayStride: 1188, stepMode: 'instance', attributes: []},
      {arrayStride: 324, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 80,
        stepMode: 'instance',
        attributes: [{format: 'sint16x2', offset: 12, shaderLocation: 6}],
      },
      {
        arrayStride: 568,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 80, shaderLocation: 5},
          {format: 'float32', offset: 148, shaderLocation: 15},
          {format: 'snorm8x2', offset: 76, shaderLocation: 7},
          {format: 'sint16x2', offset: 16, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list'},
});
let commandEncoder354 = device0.createCommandEncoder({label: '\u{1fd67}\u{1f631}\u3e53\uf636\u{1fcf4}'});
let querySet164 = device0.createQuerySet({label: '\u7677\u4123', type: 'occlusion', count: 2616});
let texture231 = device0.createTexture({
  label: '\u0f48\u35db\u032b\u0d38\u7e2a\uce0e\u06e2\u{1fc02}\u0099\u4298',
  size: {width: 660},
  sampleCount: 1,
  dimension: '1d',
  format: 'rgba16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView420 = texture26.createView({
  label: '\u7aae\ucb79\u0b37\ubfbf\u008d\u09e8\u{1fa34}\u1054\u{1f933}\u2339\u{1fdbc}',
  aspect: 'all',
  baseMipLevel: 1,
  mipLevelCount: 4,
});
try {
renderPassEncoder12.beginOcclusionQuery(1936);
} catch {}
try {
renderPassEncoder8.setViewport(54.28, 53.51, 66.17, 39.06, 0.3442, 0.5202);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
commandEncoder312.clearBuffer(buffer44, 9920, 3732);
} catch {}
try {
commandEncoder118.resolveQuerySet(querySet112, 2378, 453, buffer24, 61440);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let canvas53 = document.createElement('canvas');
let commandEncoder355 = device3.createCommandEncoder({label: '\u{1ff8e}\u{1f95f}\u0914'});
let textureView421 = texture131.createView({format: 'rg8sint', baseMipLevel: 1, mipLevelCount: 1});
try {
computePassEncoder169.setPipeline(pipeline230);
} catch {}
try {
renderBundleEncoder135.setVertexBuffer(1, buffer64);
} catch {}
try {
commandEncoder345.copyTextureToBuffer({
  texture: texture143,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 136 widthInBlocks: 68 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 23242 */
  offset: 23242,
  buffer: buffer64,
}, {width: 68, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder277.copyTextureToTexture({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture106,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device3.queue.writeBuffer(buffer70, 135836, new Float32Array(62337), 9577, 6352);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture186,
  mipLevel: 0,
  origin: {x: 37, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer15), /* required buffer size: 1_936 */
{offset: 603, bytesPerRow: 369}, {width: 113, height: 4, depthOrArrayLayers: 1});
} catch {}
let promise93 = device3.queue.onSubmittedWorkDone();
let pipeline274 = await device3.createComputePipelineAsync({layout: pipelineLayout39, compute: {module: shaderModule49, entryPoint: 'compute0', constants: {}}});
let gpuCanvasContext44 = offscreenCanvas43.getContext('webgpu');
let imageData53 = new ImageData(184, 24);
let shaderModule63 = device3.createShaderModule({
  label: '\uf365\u{1fe58}\u{1f91a}',
  code: `@group(0) @binding(75)
var<storage, read_write> type19: array<u32>;
@group(1) @binding(852)
var<storage, read_write> type20: array<u32>;

@compute @workgroup_size(2, 4, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct S56 {
  @builtin(sample_index) f0: u32
}
struct FragmentOutput0 {
  @location(1) f0: vec4<f32>,
  @location(3) f1: u32,
  @location(2) f2: vec2<f32>,
  @location(0) f3: vec2<f32>
}

@fragment
fn fragment0(@builtin(position) a0: vec4<f32>, a1: S56) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(11) a0: f16, @location(14) a1: vec4<f32>, @location(12) a2: u32, @location(5) a3: vec2<f32>, @location(15) a4: vec2<f32>, @location(8) a5: vec4<f16>, @location(10) a6: vec3<i32>, @location(3) a7: vec2<i32>, @location(6) a8: vec2<i32>, @location(4) a9: vec3<i32>, @location(9) a10: vec2<f16>, @location(7) a11: vec4<u32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let querySet165 = device3.createQuerySet({
  label: '\u5075\u9090\u10ff\u6ee2\u30c6\u3e26\u1938\u000e\ue265\u{1f9a9}\u042e',
  type: 'occlusion',
  count: 1995,
});
let textureView422 = texture183.createView({
  label: '\u4d14\u2c94\u86c0\u2296\u2066\u0459\u9224\u8b6e',
  dimension: '2d-array',
  baseMipLevel: 2,
  mipLevelCount: 2,
});
let renderBundleEncoder178 = device3.createRenderBundleEncoder({
  label: '\u0827\ufd1a',
  colorFormats: ['r8sint', 'rgba16uint', 'rgba32sint', 'r8sint'],
  depthReadOnly: true,
});
try {
renderBundleEncoder146.setBindGroup(1, bindGroup76);
} catch {}
try {
commandEncoder281.copyTextureToTexture({
  texture: texture122,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture224,
  mipLevel: 0,
  origin: {x: 86, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline275 = await device3.createComputePipelineAsync({
  label: '\uf551\ubcc5\u9bed\uae88',
  layout: pipelineLayout25,
  compute: {module: shaderModule53, entryPoint: 'compute0', constants: {}},
});
let commandEncoder356 = device1.createCommandEncoder({label: '\u{1f98d}\u0046\u1f80'});
let textureView423 = texture49.createView({
  label: '\u08ea\u0ffa\u2740\uf505\u0af9\u{1ff4d}\u0e57\u0802\u{1fd47}\u{1f8d5}',
  baseMipLevel: 0,
  mipLevelCount: 2,
});
let computePassEncoder173 = commandEncoder284.beginComputePass({label: '\u357d\ubbfc\uf050\uff23\u0917\u2993'});
try {
renderBundleEncoder34.draw(1, 1, 0, 1);
} catch {}
try {
renderBundleEncoder34.drawIndexed(2_021, 433, 1_641, -1_049_214_928, 1_221_252_989);
} catch {}
try {
renderBundleEncoder34.drawIndexedIndirect(buffer13, 6_620);
} catch {}
try {
renderBundleEncoder34.setPipeline(pipeline80);
} catch {}
try {
renderBundleEncoder105.setVertexBuffer(7, buffer12, 0);
} catch {}
try {
commandEncoder245.copyTextureToTexture({
  texture: texture137,
  mipLevel: 4,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture137,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{width: 27, height: 10, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeBuffer(buffer36, 6716, new Int16Array(43601), 12909, 884);
} catch {}
let pipeline276 = device1.createRenderPipeline({
  label: '\ucca5\u{1fa11}\ubc89\ua924',
  layout: pipelineLayout24,
  fragment: {
  module: shaderModule48,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'r8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'r16sint', writeMask: 0}, {format: 'rg32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'equal',
    stencilFront: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'never', failOp: 'increment-clamp', depthFailOp: 'increment-wrap', passOp: 'decrement-clamp'},
    stencilReadMask: 3047626311,
    stencilWriteMask: 685891071,
    depthBiasSlopeScale: 947.4282554246054,
  },
  vertex: {
    module: shaderModule48,
    buffers: [
      {arrayStride: 360, attributes: []},
      {arrayStride: 116, stepMode: 'instance', attributes: []},
      {arrayStride: 316, stepMode: 'instance', attributes: []},
      {arrayStride: 356, stepMode: 'instance', attributes: []},
      {arrayStride: 188, stepMode: 'instance', attributes: []},
      {arrayStride: 508, stepMode: 'instance', attributes: []},
      {arrayStride: 712, attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'float32x3', offset: 356, shaderLocation: 6},
          {format: 'float32x3', offset: 196, shaderLocation: 15},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'back', unclippedDepth: false},
});
video24.width = 25;
let bindGroup114 = device4.createBindGroup({layout: bindGroupLayout93, entries: [{binding: 702, resource: sampler108}]});
try {
renderBundleEncoder122.setBindGroup(2, bindGroup114, new Uint32Array(2362), 179, 0);
} catch {}
try {
commandEncoder339.copyBufferToBuffer(buffer58, 39788, buffer74, 23644, 10540);
} catch {}
try {
commandEncoder318.copyTextureToTexture({
  texture: texture188,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture188,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder238.resolveQuerySet(querySet163, 156, 188, buffer48, 7424);
} catch {}
try {
device4.queue.writeBuffer(buffer77, 25920, new Int16Array(38140), 23037, 2024);
} catch {}
let pipeline277 = await device4.createComputePipelineAsync({layout: pipelineLayout17, compute: {module: shaderModule36, entryPoint: 'compute0', constants: {}}});
let querySet166 = device6.createQuerySet({label: '\u{1ff51}\u4e0e\u{1fcb6}\ua9fe\u8c7e\u{1fdcb}\u52ed\u3f0f', type: 'occlusion', count: 1176});
let textureView424 = texture191.createView({label: '\u0b45\u806d', baseMipLevel: 2, mipLevelCount: 1});
try {
commandEncoder353.clearBuffer(buffer60, 129068, 21128);
} catch {}
try {
device6.queue.writeTexture({
  texture: texture196,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new BigInt64Array(arrayBuffer7), /* required buffer size: 36_704 */
{offset: 532, bytesPerRow: 102, rowsPerImage: 88}, {width: 16, height: 3, depthOrArrayLayers: 5});
} catch {}
let videoFrame41 = new VideoFrame(canvas17, {timestamp: 0});
let bindGroup115 = device3.createBindGroup({label: '\u05b0\u0fde', layout: bindGroupLayout56, entries: [{binding: 75, resource: sampler115}]});
let commandEncoder357 = device3.createCommandEncoder();
let textureView425 = texture186.createView({format: 'rg8unorm', baseMipLevel: 7});
let computePassEncoder174 = commandEncoder237.beginComputePass({label: '\u0d03\u{1fc91}\u{1f8a7}\u7c3a\uf8ea\ue38f\u25bd\ue742\u0993\ua990'});
let renderBundle204 = renderBundleEncoder123.finish({label: '\ud8ea\u{1f913}\u{1fadb}'});
let externalTexture168 = device3.importExternalTexture({label: '\ub074\u{1fd7b}\uf10e\ue8ad\u{1f652}', source: video24, colorSpace: 'srgb'});
try {
renderBundleEncoder178.setBindGroup(1, bindGroup71, new Uint32Array(4132), 1141, 0);
} catch {}
try {
commandEncoder297.resolveQuerySet(querySet93, 436, 248, buffer64, 50432);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture224,
  mipLevel: 0,
  origin: {x: 23, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer3, /* required buffer size: 857 */
{offset: 857}, {width: 256, height: 0, depthOrArrayLayers: 1});
} catch {}
let gpuCanvasContext45 = offscreenCanvas42.getContext('webgpu');
let img37 = await imageWithData(53, 94, '#3f140e07', '#c7f43eec');
let textureView426 = texture162.createView({label: '\u09e0\ubd8a\ue451\u3a32\ucf56\u00aa\uc681\ue103', mipLevelCount: 3});
let computePassEncoder175 = commandEncoder337.beginComputePass({label: '\u9bde\u0757'});
let renderBundle205 = renderBundleEncoder170.finish();
try {
renderBundleEncoder167.setVertexBuffer(4_294_967_295, undefined, 0);
} catch {}
try {
computePassEncoder135.popDebugGroup();
} catch {}
try {
device5.queue.writeTexture({
  texture: texture206,
  mipLevel: 0,
  origin: {x: 52, y: 0, z: 0},
  aspect: 'all',
}, new Int16Array(arrayBuffer25), /* required buffer size: 585 */
{offset: 585}, {width: 8, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline278 = device5.createComputePipeline({
  label: '\u77ad\u{1feaa}\u9463\u921b',
  layout: pipelineLayout28,
  compute: {module: shaderModule51, entryPoint: 'compute0', constants: {}},
});
let imageBitmap36 = await createImageBitmap(img21);
let commandEncoder358 = device4.createCommandEncoder({label: '\u0cab\u9909\u0af4\u{1ffd1}\u{1fe5d}\u3580\u6450\u04fa'});
let texture232 = device4.createTexture({
  label: '\u0441\u022d\u918f',
  size: {width: 656},
  dimension: '1d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView427 = texture124.createView({label: '\u22de\ucb77\uc60d\u001f\u0718\u0deb\u{1f64a}\ubd4d\u3f01\u{1ff38}', baseArrayLayer: 0});
let computePassEncoder176 = commandEncoder339.beginComputePass({label: '\ua93f\u608a\u{1fba2}\u{1fa92}'});
let renderBundle206 = renderBundleEncoder117.finish();
let externalTexture169 = device4.importExternalTexture({
  label: '\u1f50\u6544\u0c66\ubbb3\u0586\u42d0\ue6f0\u0309\u{1fd0b}',
  source: video42,
  colorSpace: 'srgb',
});
try {
computePassEncoder164.setPipeline(pipeline223);
} catch {}
try {
renderBundleEncoder171.setBindGroup(0, bindGroup114, []);
} catch {}
try {
commandEncoder351.copyTextureToTexture({
  texture: texture230,
  mipLevel: 0,
  origin: {x: 85, y: 1, z: 0},
  aspect: 'all',
},
{
  texture: texture127,
  mipLevel: 0,
  origin: {x: 76, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 5, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder314.resolveQuerySet(querySet102, 248, 99, buffer56, 3840);
} catch {}
let offscreenCanvas44 = new OffscreenCanvas(271, 245);
let commandEncoder359 = device1.createCommandEncoder({label: '\u68d3\u3fb8\u{1fe2f}\u40d6\uf282\ubfd9'});
let texture233 = device1.createTexture({
  label: '\u0cb2\u092d\u0d45',
  size: [550, 6, 1],
  mipLevelCount: 4,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let textureView428 = texture49.createView({label: '\u01df\u07db', baseMipLevel: 1, mipLevelCount: 1});
let computePassEncoder177 = commandEncoder359.beginComputePass({label: '\u{1ffa8}\u0ec6\uf1f8\u{1f725}\u0d36\u6019'});
let externalTexture170 = device1.importExternalTexture({
  label: '\u2294\u{1f7ad}\u0e37\u22b7\u{1f73f}\udeda\u{1f6a7}\u647f\u0821\u2d24\u0c3d',
  source: video30,
  colorSpace: 'display-p3',
});
try {
computePassEncoder59.setBindGroup(2, bindGroup60);
} catch {}
try {
renderBundleEncoder34.drawIndexedIndirect(buffer15, 5_708);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new Uint8ClampedArray(arrayBuffer19), /* required buffer size: 1_599 */
{offset: 871, bytesPerRow: 1005, rowsPerImage: 256}, {width: 182, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let pipeline279 = await device1.createComputePipelineAsync({
  label: '\u{1f622}\ub33d\u4738\u0f6f\ue42b\uf96d',
  layout: pipelineLayout5,
  compute: {module: shaderModule33, entryPoint: 'compute0', constants: {}},
});
let pipeline280 = device1.createRenderPipeline({
  layout: pipelineLayout5,
  fragment: {
  module: shaderModule52,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'r8uint', writeMask: GPUColorWrite.ALPHA}, {format: 'r16sint', writeMask: 0}, {format: 'rg32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'stencil8',
    depthCompare: 'always',
    stencilFront: {compare: 'greater-equal', failOp: 'decrement-clamp', depthFailOp: 'decrement-clamp', passOp: 'keep'},
    stencilBack: {compare: 'equal', depthFailOp: 'zero', passOp: 'invert'},
    stencilReadMask: 2600413765,
    depthBias: -1983079063,
  },
  vertex: {
    module: shaderModule52,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 36,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 0, shaderLocation: 8},
          {format: 'snorm16x4', offset: 0, shaderLocation: 13},
          {format: 'sint32', offset: 0, shaderLocation: 10},
          {format: 'uint32', offset: 0, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 1248,
        attributes: [
          {format: 'float32x4', offset: 248, shaderLocation: 9},
          {format: 'snorm8x2', offset: 780, shaderLocation: 1},
          {format: 'snorm8x2', offset: 510, shaderLocation: 12},
          {format: 'unorm16x4', offset: 8, shaderLocation: 4},
          {format: 'sint32', offset: 12, shaderLocation: 11},
          {format: 'unorm16x2', offset: 8, shaderLocation: 5},
        ],
      },
      {arrayStride: 184, stepMode: 'instance', attributes: []},
      {arrayStride: 464, stepMode: 'instance', attributes: []},
      {arrayStride: 304, stepMode: 'vertex', attributes: []},
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 988, attributes: [{format: 'uint32x3', offset: 172, shaderLocation: 7}]},
      {
        arrayStride: 104,
        attributes: [
          {format: 'sint32x3', offset: 4, shaderLocation: 0},
          {format: 'snorm16x4', offset: 16, shaderLocation: 2},
          {format: 'snorm16x4', offset: 36, shaderLocation: 14},
          {format: 'uint16x2', offset: 32, shaderLocation: 3},
          {format: 'uint32x3', offset: 12, shaderLocation: 6},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'ccw'},
});
let renderBundleEncoder179 = device2.createRenderBundleEncoder({
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle207 = renderBundleEncoder108.finish({});
try {
buffer23.unmap();
} catch {}
try {
commandEncoder303.copyBufferToBuffer(buffer33, 107588, buffer62, 273600, 23576);
} catch {}
try {
commandEncoder347.copyTextureToTexture({
  texture: texture108,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 20},
  aspect: 'all',
},
{
  texture: texture108,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 8},
  aspect: 'all',
},
{width: 11, height: 3, depthOrArrayLayers: 16});
} catch {}
let pipeline281 = device2.createRenderPipeline({
  layout: pipelineLayout9,
  fragment: {
  module: shaderModule46,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba8unorm', writeMask: 0}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {
  format: 'r8unorm',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r8sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rgba8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'never', failOp: 'increment-wrap', depthFailOp: 'zero', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'not-equal', failOp: 'invert', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'},
    stencilWriteMask: 3183637917,
    depthBiasSlopeScale: 358.4260874330137,
    depthBiasClamp: 730.4337579964072,
  },
  vertex: {
    module: shaderModule46,
    buffers: [
      {
        arrayStride: 92,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 4, shaderLocation: 0},
          {format: 'uint8x4', offset: 0, shaderLocation: 1},
          {format: 'float32x4', offset: 56, shaderLocation: 10},
          {format: 'sint8x2', offset: 18, shaderLocation: 3},
          {format: 'sint32x2', offset: 8, shaderLocation: 9},
          {format: 'snorm16x4', offset: 0, shaderLocation: 6},
        ],
      },
      {arrayStride: 16, attributes: []},
      {arrayStride: 556, attributes: []},
      {
        arrayStride: 32,
        attributes: [
          {format: 'float32x3', offset: 4, shaderLocation: 2},
          {format: 'unorm16x4', offset: 0, shaderLocation: 11},
          {format: 'sint16x4', offset: 0, shaderLocation: 4},
          {format: 'float32x2', offset: 0, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 184,
        stepMode: 'instance',
        attributes: [{format: 'sint8x2', offset: 40, shaderLocation: 14}],
      },
      {arrayStride: 160, attributes: []},
      {arrayStride: 100, attributes: [{format: 'float16x2', offset: 0, shaderLocation: 15}]},
      {
        arrayStride: 0,
        attributes: [
          {format: 'unorm8x2', offset: 30, shaderLocation: 7},
          {format: 'uint8x4', offset: 344, shaderLocation: 5},
          {format: 'sint32x2', offset: 268, shaderLocation: 13},
          {format: 'snorm8x4', offset: 60, shaderLocation: 12},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', frontFace: 'ccw', cullMode: 'front'},
});
let commandEncoder360 = device1.createCommandEncoder({label: '\u017d\u03d5\ubbd3\u00af\ua598\u{1fed3}\ueae2\u5ba8\u97f8\u0271\ucbb7'});
let computePassEncoder178 = commandEncoder313.beginComputePass({label: '\u4c81\u0d51\ufe0f\u09f3\u0c51\u0b77\u3934'});
let renderBundleEncoder180 = device1.createRenderBundleEncoder({
  label: '\u018e\u04a0\u7635\u3b3c\u0975\u0b40\u{1fa58}\u264a',
  colorFormats: ['rg8uint', 'r8uint', 'r16sint', 'rg32sint'],
  stencilReadOnly: true,
});
try {
computePassEncoder156.setPipeline(pipeline266);
} catch {}
try {
renderBundleEncoder34.draw(2, 0, 0, 1);
} catch {}
try {
renderBundleEncoder151.setVertexBuffer(3, buffer36, 22_852, 3_022);
} catch {}
try {
buffer71.destroy();
} catch {}
try {
  await buffer73.mapAsync(GPUMapMode.READ, 0, 98564);
} catch {}
try {
commandEncoder280.copyBufferToBuffer(buffer15, 29048, buffer36, 38440, 1996);
} catch {}
try {
commandEncoder323.copyTextureToBuffer({
  texture: texture99,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 25444 */
  offset: 25444,
  rowsPerImage: 163,
  buffer: buffer36,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture171,
  mipLevel: 0,
  origin: {x: 18, y: 15, z: 0},
  aspect: 'all',
}, new Uint16Array(arrayBuffer24), /* required buffer size: 894 */
{offset: 894, bytesPerRow: 397}, {width: 44, height: 27, depthOrArrayLayers: 0});
} catch {}
let promise94 = device1.queue.onSubmittedWorkDone();
let offscreenCanvas45 = new OffscreenCanvas(916, 622);
let video54 = await videoWithData();
let commandEncoder361 = device2.createCommandEncoder({label: '\ua62b\ub2bd\u{1f7c5}\u{1fd22}\u{1fca8}\u0f72\u023a'});
let querySet167 = device2.createQuerySet({type: 'occlusion', count: 525});
let textureView429 = texture132.createView({
  label: '\uc38e\u6172\u39b5\u{1fdcb}\u3593\u0116\u9c8a\ue367',
  dimension: '2d-array',
  format: 'rg8unorm',
  baseMipLevel: 1,
});
let renderBundle208 = renderBundleEncoder153.finish({label: '\u2313\u1b32\udd36\u{1f6aa}\u770e\u722e\ub078\u4a10\u61c8'});
try {
computePassEncoder76.dispatchWorkgroups(3);
} catch {}
try {
commandEncoder159.copyTextureToTexture({
  texture: texture140,
  mipLevel: 2,
  origin: {x: 21, y: 0, z: 6},
  aspect: 'all',
},
{
  texture: texture118,
  mipLevel: 1,
  origin: {x: 0, y: 3, z: 6},
  aspect: 'all',
},
{width: 6, height: 0, depthOrArrayLayers: 31});
} catch {}
let pipeline282 = device2.createRenderPipeline({
  label: '\u071d\u{1fe84}\u06e0\ue072',
  layout: pipelineLayout13,
  fragment: {
  module: shaderModule27,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha-saturated'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'src-alpha'},
  },
}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {
  format: 'r8unorm',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r8sint', writeMask: GPUColorWrite.ALL}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule27,
    buffers: [
      {arrayStride: 404, attributes: []},
      {arrayStride: 532, attributes: []},
      {
        arrayStride: 544,
        stepMode: 'instance',
        attributes: [{format: 'uint16x2', offset: 0, shaderLocation: 14}],
      },
      {
        arrayStride: 924,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x4', offset: 472, shaderLocation: 10},
          {format: 'float16x2', offset: 368, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 156,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 28, shaderLocation: 11},
          {format: 'uint32', offset: 32, shaderLocation: 0},
        ],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 1028, stepMode: 'instance', attributes: []},
      {
        arrayStride: 80,
        attributes: [
          {format: 'uint32x3', offset: 4, shaderLocation: 15},
          {format: 'uint8x4', offset: 16, shaderLocation: 2},
          {format: 'uint32x4', offset: 8, shaderLocation: 7},
          {format: 'float16x4', offset: 0, shaderLocation: 1},
          {format: 'float32x2', offset: 4, shaderLocation: 9},
        ],
      },
    ],
  },
});
let offscreenCanvas46 = new OffscreenCanvas(305, 380);
let shaderModule64 = device3.createShaderModule({
  label: '\u{1f690}\ubcab\u9c3f\u07d8\u07d2',
  code: `@group(0) @binding(852)
var<storage, read_write> local26: array<u32>;

@compute @workgroup_size(1, 2, 4)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(3) f0: vec2<i32>,
  @location(2) f1: vec4<i32>,
  @location(0) f2: vec4<i32>,
  @location(1) f3: vec4<u32>
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}


@vertex
fn vertex0(@location(3) a0: vec2<u32>, @location(10) a1: vec2<u32>, @location(9) a2: vec4<f32>, @location(5) a3: vec2<u32>, @location(7) a4: i32, @location(8) a5: vec4<f16>, @location(15) a6: u32, @location(6) a7: vec3<u32>, @builtin(vertex_index) a8: u32, @location(0) a9: vec2<f16>, @builtin(instance_index) a10: u32, @location(13) a11: f32, @location(4) a12: vec3<i32>, @location(12) a13: vec2<i32>, @location(1) a14: vec4<i32>, @location(14) a15: u32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let pipelineLayout42 = device3.createPipelineLayout({label: '\u0606\u{1fc94}\uc4c2\ueceb', bindGroupLayouts: [bindGroupLayout48]});
let texture234 = device3.createTexture({
  label: '\u{1f9ed}\u74f3\u027b\u{1fe16}',
  size: [351, 1, 116],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg16sint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg16sint', 'rg16sint'],
});
let textureView430 = texture152.createView({
  label: '\u0c5a\u0da2\u8882\u961a\u0a99\u{1fd69}\u{1f7fa}\u44e0\u{1f775}',
  format: 'rgba8sint',
  baseMipLevel: 5,
  mipLevelCount: 1,
});
try {
computePassEncoder141.setBindGroup(0, bindGroup113);
} catch {}
try {
commandEncoder301.copyBufferToBuffer(buffer47, 131072, buffer64, 140484, 36148);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device3,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let gpuCanvasContext46 = offscreenCanvas44.getContext('webgpu');
let sampler162 = device2.createSampler({
  label: '\ue08e\uc741',
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  lodMinClamp: 79.74,
  lodMaxClamp: 89.29,
});
try {
buffer57.unmap();
} catch {}
try {
commandEncoder285.copyTextureToTexture({
  texture: texture197,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture216,
  mipLevel: 4,
  origin: {x: 0, y: 5, z: 0},
  aspect: 'all',
},
{width: 2, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture216,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer5, /* required buffer size: 756 */
{offset: 756}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise93;
} catch {}
let video55 = await videoWithData();
try {
canvas53.getContext('webgpu');
} catch {}
let gpuCanvasContext47 = offscreenCanvas45.getContext('webgpu');
canvas18.height = 2809;
try {
offscreenCanvas46.getContext('webgl');
} catch {}
let shaderModule65 = device2.createShaderModule({
  label: '\ub407\ue380\u9b9a\u0cfb\u0a25\uf2e5',
  code: `@group(0) @binding(385)
var<storage, read_write> local27: array<u32>;
@group(3) @binding(786)
var<storage, read_write> global15: array<u32>;
@group(2) @binding(953)
var<storage, read_write> local28: array<u32>;
@group(2) @binding(84)
var<storage, read_write> n29: array<u32>;
@group(0) @binding(473)
var<storage, read_write> local29: array<u32>;
@group(0) @binding(552)
var<storage, read_write> parameter26: array<u32>;

@compute @workgroup_size(7, 2, 1)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(3) f0: f32,
  @location(0) f1: vec4<f32>,
  @location(5) f2: vec4<f32>,
  @location(4) f3: i32,
  @location(6) f4: vec4<i32>,
  @location(2) f5: vec4<f32>,
  @location(1) f6: vec4<f32>
}

@fragment
fn fragment0(@location(13) a0: vec3<i32>, @location(7) a1: vec4<f32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(2) f375: u32,
  @location(1) f376: i32,
  @location(3) f377: vec3<i32>,
  @location(0) f378: vec2<i32>,
  @location(15) f379: vec4<f32>,
  @location(11) f380: vec3<f32>,
  @location(10) f381: vec2<f32>,
  @location(12) f382: vec3<i32>,
  @location(8) f383: vec3<f32>,
  @location(14) f384: f32,
  @location(7) f385: vec4<f32>,
  @location(5) f386: i32,
  @builtin(position) f387: vec4<f32>,
  @location(9) f388: vec4<f16>,
  @location(6) f389: f32,
  @location(13) f390: vec3<i32>,
  @location(4) f391: vec3<f32>
}

@vertex
fn vertex0(@location(0) a0: vec4<i32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let computePassEncoder179 = commandEncoder283.beginComputePass({label: '\ucbc3\u4b18\u5cd8\u11ae'});
try {
commandEncoder310.clearBuffer(buffer57);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 48, height: 32, depthOrArrayLayers: 46}
*/
{
  source: videoFrame27,
  origin: { x: 69, y: 0 },
  flipY: false,
}, {
  texture: texture113,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 42},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 31, height: 4, depthOrArrayLayers: 0});
} catch {}
let pipeline283 = device2.createRenderPipeline({
  label: '\u0806\u9032\u70e5\u0d66\u0899\u0f9e\u{1fbad}\u220f\u6e97',
  layout: pipelineLayout11,
  fragment: {
  module: shaderModule59,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'bgra8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'constant', dstFactor: 'one-minus-constant'},
    alpha: {operation: 'subtract', srcFactor: 'src', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.GREEN,
}, {
  format: 'rgba8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'one', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}, {
  format: 'rgba8unorm-srgb',
  blend: {
    color: {operation: 'subtract', srcFactor: 'src', dstFactor: 'src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'r8unorm', writeMask: GPUColorWrite.BLUE}, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rgba8sint'}],
},
  vertex: {
    module: shaderModule59,
    buffers: [
      {
        arrayStride: 32,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm8x2', offset: 2, shaderLocation: 11},
          {format: 'snorm8x2', offset: 26, shaderLocation: 8},
          {format: 'uint32x2', offset: 0, shaderLocation: 14},
        ],
      },
      {arrayStride: 768, stepMode: 'instance', attributes: []},
      {arrayStride: 60, attributes: []},
      {
        arrayStride: 800,
        attributes: [
          {format: 'uint16x4', offset: 84, shaderLocation: 12},
          {format: 'unorm8x2', offset: 166, shaderLocation: 6},
        ],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 40,
        attributes: [
          {format: 'uint32x2', offset: 4, shaderLocation: 3},
          {format: 'sint16x2', offset: 0, shaderLocation: 1},
          {format: 'uint32x3', offset: 0, shaderLocation: 2},
          {format: 'uint8x2', offset: 0, shaderLocation: 15},
          {format: 'sint32x4', offset: 4, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x2', offset: 294, shaderLocation: 4}],
      },
      {
        arrayStride: 160,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x2', offset: 0, shaderLocation: 7},
          {format: 'sint8x4', offset: 4, shaderLocation: 13},
          {format: 'unorm8x2', offset: 14, shaderLocation: 10},
          {format: 'unorm8x4', offset: 4, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'ccw', cullMode: 'front'},
});
let commandEncoder362 = device4.createCommandEncoder();
let textureView431 = texture124.createView({label: '\u75e1\u8b8e\u6b85\uca31\u7917\u5174\u{1f667}'});
let externalTexture171 = device4.importExternalTexture({label: '\uac3e\u2c22\ud97e\u0be4\u9944\u04ca\u{1f669}\u{1f7b6}', source: videoFrame16});
try {
renderBundleEncoder168.setVertexBuffer(0, buffer77, 11_252, 17_634);
} catch {}
try {
commandEncoder335.copyBufferToBuffer(buffer77, 221000, buffer54, 73984, 1724);
} catch {}
try {
commandEncoder352.clearBuffer(buffer56, 35036, 392904);
} catch {}
try {
device4.queue.writeTexture({
  texture: texture232,
  mipLevel: 0,
  origin: {x: 35, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer12, /* required buffer size: 718 */
{offset: 718}, {width: 500, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
  await device4.queue.onSubmittedWorkDone();
} catch {}
let pipeline284 = device4.createRenderPipeline({
  label: '\u2763\u75ac',
  layout: pipelineLayout36,
  multisample: {mask: 0xffffffff},
  fragment: {
  module: shaderModule39,
  entryPoint: 'fragment0',
  targets: [{format: 'rgb10a2uint'}, {format: 'rgba8sint', writeMask: 0}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'src-alpha-saturated'},
    alpha: {operation: 'add', srcFactor: 'constant', dstFactor: 'dst'},
  },
}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'add', srcFactor: 'src', dstFactor: 'dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.BLUE,
}, {format: 'rg8sint', writeMask: GPUColorWrite.ALL}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'equal', failOp: 'invert', depthFailOp: 'replace', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'equal', failOp: 'decrement-wrap', depthFailOp: 'invert', passOp: 'increment-clamp'},
    stencilReadMask: 2338244794,
    stencilWriteMask: 2989423014,
    depthBias: -1362322060,
    depthBiasSlopeScale: 250.64172926347197,
  },
  vertex: {
    module: shaderModule39,
    buffers: [
      {arrayStride: 120, attributes: []},
      {arrayStride: 104, stepMode: 'instance', attributes: []},
      {
        arrayStride: 824,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint16x4', offset: 12, shaderLocation: 0},
          {format: 'uint8x4', offset: 72, shaderLocation: 8},
        ],
      },
      {arrayStride: 248, attributes: [{format: 'sint32x2', offset: 92, shaderLocation: 15}]},
      {arrayStride: 704, stepMode: 'instance', attributes: []},
      {arrayStride: 328, attributes: []},
      {
        arrayStride: 300,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 172, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 100, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 736,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x4', offset: 108, shaderLocation: 11},
          {format: 'snorm8x4', offset: 528, shaderLocation: 10},
          {format: 'sint16x4', offset: 120, shaderLocation: 14},
          {format: 'sint8x2', offset: 390, shaderLocation: 3},
          {format: 'sint8x4', offset: 12, shaderLocation: 4},
          {format: 'snorm8x2', offset: 4, shaderLocation: 6},
          {format: 'float32', offset: 4, shaderLocation: 13},
          {format: 'uint16x2', offset: 84, shaderLocation: 9},
          {format: 'unorm8x2', offset: 122, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7},
          {format: 'uint16x4', offset: 216, shaderLocation: 12},
        ],
      },
    ],
  },
});
gc();
document.body.prepend(img4);
let video56 = await videoWithData();
try {
canvas52.getContext('bitmaprenderer');
} catch {}
let commandBuffer82 = commandEncoder355.finish({label: '\u2712\u0572\ub292\uf884\ub988\u{1fd8b}\u08e7\u051d\u0197'});
let renderBundleEncoder181 = device3.createRenderBundleEncoder({
  label: '\u0ed4\ud6d9\u0744\u2e27\u6ead\u3c12\u{1ffcf}\u{1fb8a}\u{1f92b}\u175f\u0791',
  colorFormats: ['rgba32sint', 'rg32uint', 'rg16sint', 'r32uint'],
  sampleCount: 4,
  depthReadOnly: true,
});
let renderBundle209 = renderBundleEncoder181.finish({});
let sampler163 = device3.createSampler({
  label: '\u89dd\u{1f794}\u{1ff1f}\u0afc\u10b6\u013c\u{1f917}\u6613',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  maxAnisotropy: 18,
});
try {
commandEncoder287.copyBufferToBuffer(buffer47, 97368, buffer64, 295124, 1252);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture224,
  mipLevel: 0,
  origin: {x: 79, y: 0, z: 0},
  aspect: 'all',
}, new DataView(arrayBuffer9), /* required buffer size: 1_363 */
{offset: 999, rowsPerImage: 121}, {width: 91, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline285 = device3.createComputePipeline({layout: pipelineLayout25, compute: {module: shaderModule45, entryPoint: 'compute0', constants: {}}});
let pipeline286 = device3.createRenderPipeline({
  label: '\u04f9\u8172\uaba9\u4685\u1423\u40e6\u76d0\u7d0d\u{1fbfe}\u075b\u4df9',
  layout: pipelineLayout15,
  multisample: {mask: 0x6c060068},
  fragment: {
  module: shaderModule64,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'rgba32sint', writeMask: 0}, {format: 'r8sint'}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {compare: 'less-equal', failOp: 'replace', depthFailOp: 'keep', passOp: 'invert'},
    stencilBack: {failOp: 'replace', depthFailOp: 'decrement-wrap', passOp: 'invert'},
    stencilReadMask: 2738469028,
    stencilWriteMask: 2853197928,
    depthBiasSlopeScale: 394.1877333955046,
    depthBiasClamp: 32.03659177346344,
  },
  vertex: {
    module: shaderModule64,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 552, stepMode: 'instance', attributes: []},
      {arrayStride: 28, stepMode: 'instance', attributes: []},
      {arrayStride: 800, stepMode: 'instance', attributes: []},
      {arrayStride: 492, attributes: []},
      {arrayStride: 32, attributes: [{format: 'uint16x2', offset: 8, shaderLocation: 15}]},
      {
        arrayStride: 488,
        attributes: [
          {format: 'float16x2', offset: 68, shaderLocation: 9},
          {format: 'sint8x2', offset: 4, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 424,
        attributes: [
          {format: 'uint16x2', offset: 32, shaderLocation: 14},
          {format: 'unorm10-10-10-2', offset: 16, shaderLocation: 0},
          {format: 'uint16x4', offset: 48, shaderLocation: 6},
          {format: 'sint8x4', offset: 300, shaderLocation: 1},
          {format: 'float16x4', offset: 80, shaderLocation: 13},
          {format: 'sint32x3', offset: 32, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 100,
        attributes: [
          {format: 'uint8x4', offset: 0, shaderLocation: 5},
          {format: 'uint8x4', offset: 0, shaderLocation: 10},
          {format: 'sint32x3', offset: 0, shaderLocation: 4},
          {format: 'uint8x2', offset: 0, shaderLocation: 3},
          {format: 'float32x4', offset: 12, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
let commandEncoder363 = device0.createCommandEncoder({label: '\u8de1\u{1fa16}\u7cdc\u06cc\uc7f9'});
let texture235 = device0.createTexture({
  label: '\u5c22\u4331\u0441',
  size: [1320],
  mipLevelCount: 1,
  dimension: '1d',
  format: 'rg8uint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView432 = texture10.createView({
  aspect: 'all',
  format: 'rg16uint',
  baseMipLevel: 6,
  mipLevelCount: 1,
  baseArrayLayer: 31,
  arrayLayerCount: 60,
});
let computePassEncoder180 = commandEncoder118.beginComputePass({label: '\u0e0d\u03b1\u7ddb\u627f\u6b0f\u{1f8a2}\u{1f66c}\u0c3f\uf48e'});
let sampler164 = device0.createSampler({
  label: '\u452d\u0ca8\udd39\u0a12\u{1fab3}\u0254\u{1fb4d}\u7c08\u9901\ucfea\u5b94',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 74.01,
  lodMaxClamp: 83.15,
});
try {
computePassEncoder27.dispatchWorkgroups(1, 2, 4);
} catch {}
try {
renderPassEncoder19.executeBundles([]);
} catch {}
try {
renderBundleEncoder50.draw(460, 35, 352_060_948, 259_565_804);
} catch {}
try {
renderBundleEncoder169.setVertexBuffer(0, buffer7);
} catch {}
try {
commandEncoder138.copyTextureToTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture60,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
},
{width: 288, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder178.resolveQuerySet(querySet157, 320, 983, buffer1, 51200);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline287 = await device0.createRenderPipelineAsync({
  label: '\u04af\u0e7a\u87de\u{1fce7}\u{1f89b}',
  layout: pipelineLayout30,
  fragment: {
  module: shaderModule44,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-dst-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rgba8sint', writeMask: GPUColorWrite.RED}, {format: 'bgra8unorm-srgb', writeMask: 0}, {format: 'rg8uint', writeMask: 0}, {format: 'rg16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'rgb10a2unorm'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilFront: {compare: 'not-equal', failOp: 'decrement-wrap', depthFailOp: 'zero', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'equal', failOp: 'zero', depthFailOp: 'zero', passOp: 'decrement-clamp'},
    stencilReadMask: 2624061952,
    stencilWriteMask: 4100416157,
  },
  vertex: {
    module: shaderModule44,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 304, stepMode: 'instance', attributes: []},
      {arrayStride: 76, attributes: []},
      {arrayStride: 120, stepMode: 'instance', attributes: []},
      {arrayStride: 232, stepMode: 'instance', attributes: []},
      {arrayStride: 416, attributes: []},
      {arrayStride: 752, attributes: []},
      {arrayStride: 560, attributes: []},
      {
        arrayStride: 32,
        stepMode: 'instance',
        attributes: [{format: 'sint32', offset: 8, shaderLocation: 12}, {format: 'sint16x2', offset: 8, shaderLocation: 0}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'},
});
try {
  await promise94;
} catch {}
let imageData54 = new ImageData(80, 212);
let commandEncoder364 = device4.createCommandEncoder({label: '\u0ec0\u4d94\u0c4d\u01d0\u{1f672}'});
let renderBundle210 = renderBundleEncoder171.finish({label: '\u0347\u{1fce5}\ubf45\u5d32\u{1fb0a}'});
let externalTexture172 = device4.importExternalTexture({label: '\u18e3\u1e35\u0e80', source: videoFrame13, colorSpace: 'srgb'});
try {
commandEncoder235.copyBufferToBuffer(buffer77, 217048, buffer30, 38320, 2256);
} catch {}
try {
commandEncoder238.copyTextureToTexture({
  texture: texture225,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 14},
  aspect: 'all',
},
{
  texture: texture127,
  mipLevel: 0,
  origin: {x: 32, y: 0, z: 0},
  aspect: 'all',
},
{width: 78, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
adapter6.label = '\u013f\u1055';
} catch {}
let textureView433 = texture154.createView({label: '\u9262\u0363\u01c2\u0880\u{1fe98}\u{1f6f3}', baseMipLevel: 3, mipLevelCount: 1});
let renderBundleEncoder182 = device4.createRenderBundleEncoder({
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  sampleCount: 1,
  stencilReadOnly: false,
});
try {
computePassEncoder129.end();
} catch {}
try {
renderBundleEncoder101.setBindGroup(0, bindGroup114, new Uint32Array(3738), 2689, 0);
} catch {}
let arrayBuffer28 = buffer51.getMappedRange();
try {
commandEncoder267.copyBufferToBuffer(buffer77, 88956, buffer51, 27064, 25300);
} catch {}
try {
commandEncoder193.resolveQuerySet(querySet145, 366, 204, buffer48, 41984);
} catch {}
try {
device4.queue.submit([commandBuffer70, commandBuffer78]);
} catch {}
let promise95 = device4.queue.onSubmittedWorkDone();
let offscreenCanvas47 = new OffscreenCanvas(655, 986);
let renderBundle211 = renderBundleEncoder134.finish();
try {
commandEncoder340.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 8404 */
  offset: 8404,
  bytesPerRow: 512,
  rowsPerImage: 84,
  buffer: buffer60,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device6.queue.writeTexture({
  texture: texture196,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer20, /* required buffer size: 544 */
{offset: 544, rowsPerImage: 84}, {width: 2, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline288 = device6.createRenderPipeline({
  label: '\u086d\uba70\u52c5',
  layout: pipelineLayout40,
  fragment: {
  module: shaderModule60,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rgba16sint', writeMask: 0}, {format: 'rgb10a2uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgb10a2uint', writeMask: GPUColorWrite.ALL}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'equal', failOp: 'zero', depthFailOp: 'replace', passOp: 'zero'},
    stencilBack: {compare: 'not-equal', failOp: 'decrement-wrap', depthFailOp: 'decrement-clamp', passOp: 'replace'},
    stencilReadMask: 3064463648,
    stencilWriteMask: 416590251,
    depthBias: -528643641,
  },
  vertex: {
    module: shaderModule60,
    buffers: [
      {arrayStride: 188, attributes: [{format: 'unorm8x2', offset: 16, shaderLocation: 14}]},
      {arrayStride: 536, stepMode: 'instance', attributes: []},
      {
        arrayStride: 288,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 16, shaderLocation: 9},
          {format: 'sint32', offset: 76, shaderLocation: 13},
          {format: 'snorm8x2', offset: 12, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 15},
          {format: 'uint32x3', offset: 104, shaderLocation: 12},
        ],
      },
      {arrayStride: 120, attributes: []},
      {arrayStride: 224, attributes: []},
      {
        arrayStride: 20,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 0, shaderLocation: 10}],
      },
      {arrayStride: 612, stepMode: 'instance', attributes: []},
      {
        arrayStride: 1684,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x3', offset: 596, shaderLocation: 0},
          {format: 'uint16x4', offset: 76, shaderLocation: 11},
          {format: 'float16x4', offset: 80, shaderLocation: 7},
          {format: 'sint16x4', offset: 48, shaderLocation: 1},
          {format: 'float32', offset: 144, shaderLocation: 5},
          {format: 'snorm8x2', offset: 270, shaderLocation: 2},
          {format: 'sint32x3', offset: 252, shaderLocation: 4},
          {format: 'sint32x3', offset: 320, shaderLocation: 6},
          {format: 'float16x4', offset: 288, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'none'},
});
gc();
let offscreenCanvas48 = new OffscreenCanvas(540, 790);
let commandEncoder365 = device2.createCommandEncoder({label: '\u33cb\u0c22\u63fd\u0785\u7b39\u0c09\u72c0\u2cfe\ufbd7\u6a00'});
let querySet168 = device2.createQuerySet({label: '\u373e\u0e2d\uf9db', type: 'occlusion', count: 167});
let texture236 = device2.createTexture({
  label: '\uc0b3\u8345\uf3b9\u{1f6c9}\uc62d\u2be6',
  size: [45, 192, 1],
  mipLevelCount: 6,
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8sint', 'rgba8sint', 'rgba8sint'],
});
let textureView434 = texture95.createView({format: 'rgba8unorm', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 17, arrayLayerCount: 36});
let renderBundle212 = renderBundleEncoder154.finish({label: '\ucf84\u05b6\u4683\u{1ff5b}\u2030\u{1fc3c}\u58a9'});
try {
computePassEncoder133.setBindGroup(0, bindGroup98);
} catch {}
try {
computePassEncoder87.setBindGroup(0, bindGroup96, new Uint32Array(755), 486, 0);
} catch {}
try {
computePassEncoder76.dispatchWorkgroups(2);
} catch {}
try {
computePassEncoder179.setPipeline(pipeline254);
} catch {}
try {
commandEncoder361.copyBufferToBuffer(buffer41, 188, buffer65, 25748, 9264);
} catch {}
try {
commandEncoder293.copyBufferToTexture({
  /* bytesInLastRow: 32 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 14624 */
  offset: 14624,
  rowsPerImage: 161,
  buffer: buffer23,
}, {
  texture: texture87,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder292.copyTextureToBuffer({
  texture: texture197,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 85 widthInBlocks: 85 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 20371 */
  offset: 20371,
  buffer: buffer75,
}, {width: 85, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext42.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
gpuCanvasContext44.unconfigure();
} catch {}
canvas32.height = 9;
let textureView435 = texture83.createView({dimension: '2d', baseMipLevel: 1, baseArrayLayer: 76});
let renderBundleEncoder183 = device0.createRenderBundleEncoder({
  colorFormats: ['r16float', 'rgba8sint', 'bgra8unorm-srgb', 'rg8uint', 'rg16uint', 'rgb10a2unorm'],
  stencilReadOnly: true,
});
let renderBundle213 = renderBundleEncoder84.finish();
let sampler165 = device0.createSampler({
  label: '\u4d58\ub122\uf976\u0b87\u03f6\u21ee',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 62.77,
  lodMaxClamp: 77.41,
});
try {
renderPassEncoder8.setIndexBuffer(buffer34, 'uint16', 171_354, 86_732);
} catch {}
try {
renderBundleEncoder29.drawIndexed(145, 81, 58, 412_368_573, 166_629_234);
} catch {}
try {
renderBundleEncoder67.setVertexBuffer(1, buffer9);
} catch {}
try {
commandEncoder170.copyBufferToBuffer(buffer21, 33252, buffer69, 26848, 2352);
} catch {}
try {
commandEncoder257.clearBuffer(buffer3, 56976, 25544);
} catch {}
try {
commandEncoder257.resolveQuerySet(querySet105, 510, 19, buffer44, 1024);
} catch {}
try {
gpuCanvasContext24.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let offscreenCanvas49 = new OffscreenCanvas(416, 856);
let buffer78 = device0.createBuffer({size: 40132, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: true});
let commandEncoder366 = device0.createCommandEncoder({label: '\u464b\u3639\u46d4\ue403\u0736\u{1f6cf}'});
let renderBundleEncoder184 = device0.createRenderBundleEncoder({
  label: '\u{1f84f}\u{1fc2e}\ud484\u05b7\u3d65\u08c5\u6a93\u19cf\u{1fc16}',
  colorFormats: ['r32float'],
  stencilReadOnly: true,
});
try {
renderPassEncoder17.setBlendConstant({ r: -73.66, g: 531.9, b: 550.7, a: -5.244, });
} catch {}
try {
renderPassEncoder17.setViewport(55.32, 1.310, 83.82, 91.72, 0.4086, 0.9100);
} catch {}
try {
renderPassEncoder13.setVertexBuffer(1, buffer7, 0);
} catch {}
try {
renderBundleEncoder27.setBindGroup(0, bindGroup70, new Uint32Array(2035), 1469, 0);
} catch {}
try {
renderBundleEncoder50.draw(14, 313, 1_381_059_861, 318_180_614);
} catch {}
try {
renderBundleEncoder29.drawIndexed(57, 45, 1, -1_946_282_658, 57_132_386);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer5, 108_188);
} catch {}
try {
renderBundleEncoder56.setPipeline(pipeline257);
} catch {}
try {
renderBundleEncoder169.setVertexBuffer(7, buffer24, 0);
} catch {}
try {
buffer21.destroy();
} catch {}
try {
commandEncoder84.copyBufferToBuffer(buffer10, 14520, buffer20, 103364, 564);
} catch {}
try {
commandEncoder185.copyTextureToTexture({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 95, y: 67, z: 24},
  aspect: 'all',
},
{
  texture: texture72,
  mipLevel: 0,
  origin: {x: 100, y: 0, z: 0},
  aspect: 'all',
},
{width: 431, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder134.clearBuffer(buffer20, 40892, 41732);
} catch {}
try {
device0.queue.submit([commandBuffer68, commandBuffer62]);
} catch {}
try {
device0.queue.writeBuffer(buffer34, 46052, new Int16Array(15515), 9916, 948);
} catch {}
try {
device0.queue.copyExternalImageToTexture(/*
{width: 330, height: 240, depthOrArrayLayers: 124}
*/
{
  source: video31,
  origin: { x: 2, y: 2 },
  flipY: false,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 277, y: 16, z: 71},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 2, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext48 = offscreenCanvas49.getContext('webgpu');
let bindGroupLayout97 = device0.createBindGroupLayout({label: '\u{1fbde}\u0a78', entries: []});
let texture237 = device0.createTexture({
  label: '\u{1fdc2}\u24a7\u{1fb0e}',
  size: [660, 480, 6],
  mipLevelCount: 6,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let computePassEncoder181 = commandEncoder210.beginComputePass({});
let renderPassEncoder20 = commandEncoder296.beginRenderPass({
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: -267.8, g: -949.0, b: 279.8, a: 733.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet112,
  maxDrawCount: 160109186,
});
let renderBundleEncoder185 = device0.createRenderBundleEncoder({colorFormats: ['rg16float', undefined, 'rg8unorm', 'rg16float', 'rgba16uint']});
let renderBundle214 = renderBundleEncoder169.finish();
let externalTexture173 = device0.importExternalTexture({
  label: '\u0995\u09e9\ube6c\u{1f7f2}\ubbd8\ue959\u{1f7a5}\uf7d5\u2f3a\u03b2',
  source: videoFrame32,
  colorSpace: 'srgb',
});
try {
renderPassEncoder6.setBindGroup(0, bindGroup21);
} catch {}
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
renderPassEncoder17.setViewport(22.49, 96.87, 30.68, 11.90, 0.2242, 0.8676);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer53, 5_148);
} catch {}
let arrayBuffer29 = buffer40.getMappedRange(244640, 155824);
try {
commandEncoder268.clearBuffer(buffer7);
} catch {}
try {
gpuCanvasContext35.unconfigure();
} catch {}
let renderBundleEncoder186 = device0.createRenderBundleEncoder({
  label: '\uc279\u0c5e\u79fe\u0c19\ud818\u1fa2\u00ce\u2503',
  colorFormats: ['rg16float', 'rgba16float'],
  stencilReadOnly: true,
});
let renderBundle215 = renderBundleEncoder16.finish({});
try {
computePassEncoder93.setPipeline(pipeline201);
} catch {}
try {
renderPassEncoder12.setBindGroup(1, bindGroup77);
} catch {}
try {
renderPassEncoder19.setBindGroup(0, bindGroup57, new Uint32Array(8356), 587, 0);
} catch {}
try {
renderPassEncoder15.setBlendConstant({ r: -175.9, g: 92.96, b: -618.8, a: -169.2, });
} catch {}
try {
renderPassEncoder17.setScissorRect(165, 51, 0, 68);
} catch {}
try {
renderBundleEncoder40.setBindGroup(2, bindGroup2, new Uint32Array(9472), 7934, 0);
} catch {}
let commandEncoder367 = device6.createCommandEncoder({label: '\u{1f8ca}\u{1f8a9}\u7d67\u63bd\u99d1\u0dfa'});
let texture238 = gpuCanvasContext11.getCurrentTexture();
let computePassEncoder182 = commandEncoder340.beginComputePass();
let renderBundle216 = renderBundleEncoder132.finish({label: '\u0ea7\ufe87'});
try {
renderBundleEncoder157.setPipeline(pipeline273);
} catch {}
try {
renderBundleEncoder157.setVertexBuffer(0, buffer60);
} catch {}
try {
commandEncoder324.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 70044 */
  offset: 70044,
  bytesPerRow: 0,
  buffer: buffer60,
}, {
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder325.copyTextureToBuffer({
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 10284 */
  offset: 10284,
  buffer: buffer60,
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder353.copyTextureToTexture({
  texture: texture179,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture196,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 1},
  aspect: 'all',
},
{width: 9, height: 1, depthOrArrayLayers: 1});
} catch {}
let promise96 = device6.createRenderPipelineAsync({
  label: '\uf6f9\u0898\u{1f8d7}\u0243\ud001\u4b93',
  layout: pipelineLayout40,
  multisample: {mask: 0x76238a81},
  fragment: {
  module: shaderModule60,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgb10a2uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgb10a2uint', writeMask: 0}],
},
  vertex: {
    module: shaderModule60,
    constants: {},
    buffers: [
      {arrayStride: 72, stepMode: 'instance', attributes: []},
      {arrayStride: 196, attributes: [{format: 'unorm8x2', offset: 14, shaderLocation: 3}]},
      {arrayStride: 0, attributes: []},
      {
        arrayStride: 156,
        attributes: [
          {format: 'sint32x3', offset: 44, shaderLocation: 13},
          {format: 'float32x2', offset: 0, shaderLocation: 2},
          {format: 'unorm16x4', offset: 28, shaderLocation: 14},
        ],
      },
      {arrayStride: 344, attributes: []},
      {
        arrayStride: 204,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 24, shaderLocation: 7},
          {format: 'snorm16x4', offset: 48, shaderLocation: 5},
          {format: 'snorm8x4', offset: 36, shaderLocation: 15},
          {format: 'sint32', offset: 8, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 272,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x2', offset: 166, shaderLocation: 10}],
      },
      {
        arrayStride: 76,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 24, shaderLocation: 9},
          {format: 'uint16x4', offset: 0, shaderLocation: 12},
          {format: 'uint32x4', offset: 4, shaderLocation: 0},
          {format: 'sint16x4', offset: 20, shaderLocation: 1},
          {format: 'float32', offset: 0, shaderLocation: 8},
          {format: 'uint8x2', offset: 2, shaderLocation: 11},
          {format: 'sint8x2', offset: 16, shaderLocation: 6},
        ],
      },
    ],
  },
});
let bindGroup116 = device1.createBindGroup({
  label: '\u{1f602}\u{1fecd}\uc549\u3367\u8a83\u0765\u6719\u0840\u48bd\u0ecf',
  layout: bindGroupLayout77,
  entries: [
    {binding: 959, resource: {buffer: buffer13, offset: 154624, size: 28608}},
    {binding: 522, resource: textureView314},
  ],
});
let textureView436 = texture48.createView({label: '\u31fb\u1b77\u2bb0\u08c0', baseMipLevel: 5, mipLevelCount: 1, arrayLayerCount: 1});
try {
computePassEncoder86.setPipeline(pipeline270);
} catch {}
try {
renderBundleEncoder105.setBindGroup(3, bindGroup60);
} catch {}
try {
renderBundleEncoder34.draw(0, 0, 0, 1);
} catch {}
let arrayBuffer30 = buffer73.getMappedRange(0, 58120);
try {
commandEncoder356.copyTextureToBuffer({
  texture: texture37,
  mipLevel: 0,
  origin: {x: 37, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 348 widthInBlocks: 87 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 23852 */
  offset: 23852,
  buffer: buffer71,
}, {width: 87, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm', 'bgra8unorm'],
  colorSpace: 'display-p3',
});
} catch {}
let pipeline289 = device1.createComputePipeline({layout: pipelineLayout5, compute: {module: shaderModule62, entryPoint: 'compute0'}});
let pipelineLayout43 = device1.createPipelineLayout({
  label: '\ue55a\u0e5a\u{1fb11}\u2784\u092d\u{1fc66}\u09ef\u{1f68d}\u772d\u040e\u0324',
  bindGroupLayouts: [bindGroupLayout43, bindGroupLayout13, bindGroupLayout20],
});
let commandBuffer83 = commandEncoder320.finish({label: '\u1016\u07b6\u00a1'});
let computePassEncoder183 = commandEncoder165.beginComputePass({label: '\u{1f7d6}\u383d\ue8c1\ud4ae\u5225\u{1f982}\u{1fcbd}\u08cc\u050b'});
try {
computePassEncoder94.end();
} catch {}
try {
renderBundleEncoder34.draw(0, 0, 0, 1);
} catch {}
try {
renderBundleEncoder34.drawIndexed(2_062, 346, 2_896, 330_247_376, 512_432_920);
} catch {}
try {
renderBundleEncoder139.setVertexBuffer(6, buffer42, 7_916, 212);
} catch {}
try {
commandEncoder323.copyTextureToTexture({
  texture: texture42,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'depth-only',
},
{
  texture: texture39,
  mipLevel: 3,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
},
{width: 5, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder156.clearBuffer(buffer12, 6124, 12);
} catch {}
video17.height = 139;
let buffer79 = device0.createBuffer({
  label: '\u41f6\u0b43\ua383\u039e\u2311\u0318\u0394\u{1fa1d}',
  size: 63224,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: true,
});
let commandEncoder368 = device0.createCommandEncoder({label: '\u57e7\u61c0\u2d08\u{1f821}\u2c54\u{1ffbc}\u{1f89f}\u{1fbf2}\u0860'});
let textureView437 = texture19.createView({
  label: '\u0e28\u{1ff55}\u5d61\u{1f9cb}\u{1f774}\u0984\uc89a\u0997\u0bec\u6253\u3ad8',
  aspect: 'depth-only',
  baseMipLevel: 2,
  baseArrayLayer: 112,
  arrayLayerCount: 10,
});
let computePassEncoder184 = commandEncoder202.beginComputePass({label: '\u4be2\ub705\u4304\u154f\u0347\uaa4d'});
let renderPassEncoder21 = commandEncoder305.beginRenderPass({
  label: '\u26a2\u29eb\uf5e9\u0f74\u689e\u237c',
  colorAttachments: [{
  view: textureView73,
  clearValue: { r: 365.9, g: -863.0, b: 299.8, a: -726.6, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet18,
});
try {
renderPassEncoder14.setBlendConstant({ r: -616.6, g: 453.0, b: -646.8, a: 551.7, });
} catch {}
try {
renderPassEncoder12.setIndexBuffer(buffer35, 'uint16', 2_306, 10_256);
} catch {}
try {
renderPassEncoder6.setPipeline(pipeline135);
} catch {}
try {
renderPassEncoder17.setVertexBuffer(0, buffer7, 2_884);
} catch {}
try {
renderBundleEncoder29.draw(128, 165, 111, 345_141_903);
} catch {}
try {
renderBundleEncoder29.drawIndexedIndirect(buffer11, 86_980);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(1, buffer9, 0);
} catch {}
try {
commandEncoder251.copyTextureToTexture({
  texture: texture89,
  mipLevel: 0,
  origin: {x: 185, y: 1, z: 91},
  aspect: 'all',
},
{
  texture: texture10,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 4, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder84.clearBuffer(buffer34, 56964, 7456);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture70,
  mipLevel: 0,
  origin: {x: 90, y: 0, z: 0},
  aspect: 'all',
}, new BigUint64Array(new ArrayBuffer(0)), /* required buffer size: 53 */
{offset: 53}, {width: 83, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup117 = device2.createBindGroup({layout: bindGroupLayout96, entries: [{binding: 786, resource: externalTexture70}]});
let externalTexture174 = device2.importExternalTexture({source: video49, colorSpace: 'display-p3'});
try {
computePassEncoder74.end();
} catch {}
try {
buffer55.unmap();
} catch {}
try {
commandEncoder292.resolveQuerySet(querySet133, 2400, 18, buffer68, 15872);
} catch {}
try {
device2.queue.submit([commandBuffer72, commandBuffer80, commandBuffer75, commandBuffer81, commandBuffer61]);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 360, height: 1, depthOrArrayLayers: 222}
*/
{
  source: img6,
  origin: { x: 19, y: 6 },
  flipY: true,
}, {
  texture: texture150,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 42},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 116, height: 0, depthOrArrayLayers: 0});
} catch {}
let shaderModule66 = device2.createShaderModule({
  label: '\u{1fd42}\u0f70\u0b94\ue521\u{1fbcd}\u{1fdde}',
  code: `@group(0) @binding(786)
var<storage, read_write> local30: array<u32>;

@compute @workgroup_size(3, 3, 3)
fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {}

struct FragmentOutput0 {
  @location(0) f0: vec4<f32>,
  @location(5) f1: vec2<f32>,
  @location(1) f2: vec4<f32>,
  @location(3) f3: vec4<f32>,
  @location(4) f4: i32,
  @location(2) f5: vec4<f32>,
  @location(6) f6: vec4<i32>
}

@fragment
fn fragment0() -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S57 {
  @builtin(instance_index) f0: u32,
  @location(3) f1: vec2<u32>,
  @location(8) f2: vec3<u32>,
  @location(7) f3: vec3<f16>,
  @location(4) f4: i32,
  @location(5) f5: i32,
  @builtin(vertex_index) f6: u32,
  @location(11) f7: vec3<u32>,
  @location(13) f8: vec2<f32>,
  @location(2) f9: vec3<u32>,
  @location(14) f10: vec4<u32>,
  @location(9) f11: vec2<f16>,
  @location(15) f12: vec4<u32>
}

@vertex
fn vertex0(@location(6) a0: vec3<u32>, a1: S57, @location(10) a2: vec2<i32>, @location(1) a3: i32, @location(0) a4: vec4<f32>, @location(12) a5: vec2<f32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
});
let commandEncoder369 = device2.createCommandEncoder({});
let texture239 = device2.createTexture({
  label: '\udf4a\u0d9a\u0418\u0062\u0895\u{1f8cd}\u4810',
  size: {width: 180, height: 768, depthOrArrayLayers: 230},
  sampleCount: 1,
  dimension: '3d',
  format: 'r8sint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r8sint', 'r8sint'],
});
let textureView438 = texture223.createView({
  label: '\u652d\u1d22\u0aca\u0817\u{1f6ae}\u0f43\u00ee\u0667',
  dimension: '2d-array',
  baseMipLevel: 1,
  mipLevelCount: 2,
  baseArrayLayer: 79,
  arrayLayerCount: 98,
});
let renderBundleEncoder187 = device2.createRenderBundleEncoder({
  label: '\u0286\u{1f81c}',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  sampleCount: 1,
  depthReadOnly: true,
});
let externalTexture175 = device2.importExternalTexture({label: '\u{1f8c7}\u{1f853}\ub636\u0091\uff15\ub058\u0b3f', source: videoFrame35, colorSpace: 'srgb'});
try {
computePassEncoder76.dispatchWorkgroupsIndirect(buffer23, 366572);
} catch {}
try {
computePassEncoder144.setPipeline(pipeline114);
} catch {}
try {
renderBundleEncoder69.setPipeline(pipeline168);
} catch {}
try {
renderBundleEncoder114.setVertexBuffer(4, buffer43, 648);
} catch {}
try {
renderBundleEncoder187.insertDebugMarker('\u4a29');
} catch {}
try {
device2.queue.writeBuffer(buffer65, 11236, new Int16Array(64084), 17624, 7476);
} catch {}
let canvas54 = document.createElement('canvas');
let video57 = await videoWithData();
let querySet169 = device2.createQuerySet({label: '\u0906\u0686\u2e9c\u0f0f\u6efb\ubebf', type: 'occlusion', count: 2392});
let renderBundleEncoder188 = device2.createRenderBundleEncoder({
  label: '\u0310\u{1faad}\u0593\u{1fe68}\u0dcd\ufde6\u{1ff57}\u{1fb77}',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  stencilReadOnly: true,
});
try {
renderBundleEncoder69.setVertexBuffer(1, buffer68, 0, 11_088);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture223,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 3},
  aspect: 'all',
}, arrayBuffer21, /* required buffer size: 59_371_639 */
{offset: 591, bytesPerRow: 2193, rowsPerImage: 192}, {width: 538, height: 1, depthOrArrayLayers: 142});
} catch {}
let video58 = await videoWithData();
try {
adapter8.label = '\u{1f8db}\u5687\u{1ff08}\u0e1a';
} catch {}
let buffer80 = device0.createBuffer({size: 233782, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
let querySet170 = device0.createQuerySet({label: '\u2adf\u{1f972}\u{1fcd6}\u5d9a', type: 'occlusion', count: 1206});
let texture240 = device0.createTexture({
  label: '\ueeb5\u01f2\u0aec\u074e\ua8c5\u7b70\ud062\u6fc1\u{1f6a3}\u6b47\u01a9',
  size: {width: 330},
  dimension: '1d',
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb'],
});
let renderPassEncoder22 = commandEncoder84.beginRenderPass({
  label: '\u0375\u0001\u{1fa8e}\u0542\ue553\uf43e\u6d7c',
  colorAttachments: [{view: textureView227, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet9,
  maxDrawCount: 1095103042,
});
try {
computePassEncoder155.setBindGroup(0, bindGroup24);
} catch {}
try {
renderPassEncoder12.setBindGroup(3, bindGroup43, new Uint32Array(2259), 1346, 0);
} catch {}
try {
renderPassEncoder13.executeBundles([renderBundle107, renderBundle107, renderBundle213, renderBundle69, renderBundle213, renderBundle42, renderBundle213]);
} catch {}
try {
renderPassEncoder18.setBlendConstant({ r: 582.0, g: 433.8, b: 107.1, a: -821.6, });
} catch {}
try {
renderPassEncoder21.setScissorRect(64, 84, 97, 22);
} catch {}
try {
renderPassEncoder14.setVertexBuffer(5, buffer35, 0, 2_017);
} catch {}
try {
renderBundleEncoder29.draw(21, 401, 129, 295_877_069);
} catch {}
try {
renderBundleEncoder50.drawIndexed(659, 22, 14, 152_367_023, 1_450_352_984);
} catch {}
try {
renderBundleEncoder96.setIndexBuffer(buffer6, 'uint32', 1_740, 201);
} catch {}
try {
  await buffer66.mapAsync(GPUMapMode.WRITE, 5320);
} catch {}
try {
commandEncoder134.copyTextureToBuffer({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 3636 */
  offset: 3636,
  buffer: buffer16,
}, {width: 0, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline290 = device0.createComputePipeline({
  label: '\u{1f8df}\u5b62\u8440\u0e8c\u66f1\u785d\u8bd3\u5559',
  layout: pipelineLayout6,
  compute: {module: shaderModule7, entryPoint: 'compute0', constants: {}},
});
try {
gpuCanvasContext43.unconfigure();
} catch {}
let canvas55 = document.createElement('canvas');
let texture241 = device4.createTexture({
  label: '\u{1fb1a}\ufc63\u0b6b',
  size: {width: 328, height: 6, depthOrArrayLayers: 1},
  mipLevelCount: 7,
  sampleCount: 1,
  format: 'rgb10a2uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
try {
renderBundleEncoder131.setBindGroup(2, bindGroup114);
} catch {}
try {
renderBundleEncoder177.setVertexBuffer(5, buffer77, 0);
} catch {}
try {
commandEncoder238.resolveQuerySet(querySet119, 1468, 164, buffer74, 1280);
} catch {}
try {
commandEncoder308.insertDebugMarker('\u{1fa11}');
} catch {}
let pipeline291 = device4.createRenderPipeline({
  label: '\u0292\ua65d\u101b\u334b\uf988',
  layout: pipelineLayout37,
  fragment: {
  module: shaderModule41,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba8sint', writeMask: 0}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'zero'},
  },
  writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'zero'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'add', srcFactor: 'zero', dstFactor: 'one'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilFront: {compare: 'greater', failOp: 'increment-clamp', depthFailOp: 'replace', passOp: 'zero'},
    stencilBack: {compare: 'greater', depthFailOp: 'invert', passOp: 'invert'},
    stencilReadMask: 1296956980,
    stencilWriteMask: 3607393062,
    depthBiasSlopeScale: 767.7138762475307,
    depthBiasClamp: 615.6951107034158,
  },
  vertex: {
    module: shaderModule41,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 116, stepMode: 'instance', attributes: []},
      {arrayStride: 332, stepMode: 'vertex', attributes: []},
      {arrayStride: 44, stepMode: 'instance', attributes: []},
      {arrayStride: 392, stepMode: 'instance', attributes: []},
      {arrayStride: 860, stepMode: 'instance', attributes: []},
      {arrayStride: 140, attributes: []},
      {arrayStride: 72, stepMode: 'instance', attributes: []},
      {
        arrayStride: 308,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x4', offset: 16, shaderLocation: 2}],
      },
    ],
  },
  primitive: {topology: 'triangle-list', frontFace: 'ccw', cullMode: 'back'},
});
canvas15.height = 1136;
let querySet171 = device4.createQuerySet({label: '\udcd1\u9118\u{1feac}\uba8a\u836f\u258c\u01b8', type: 'occlusion', count: 2697});
let textureView439 = texture129.createView({baseMipLevel: 4});
let renderBundleEncoder189 = device4.createRenderBundleEncoder({
  label: '\u17eb\ub0ee',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder151.setBindGroup(0, bindGroup114, new Uint32Array(7922), 5894, 0);
} catch {}
try {
computePassEncoder151.setPipeline(pipeline151);
} catch {}
try {
renderBundleEncoder122.setVertexBuffer(7, buffer56, 67_008, 56_684);
} catch {}
try {
commandEncoder238.pushDebugGroup('\u0d29');
} catch {}
let promise97 = device4.createRenderPipelineAsync({
  label: '\u36b1\uc47a\ue507\u023f\ub71f',
  layout: 'auto',
  fragment: {
  module: shaderModule61,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rgba8sint', writeMask: 0}, {format: 'rg8unorm', writeMask: GPUColorWrite.BLUE}, {
  format: 'rg11b10ufloat',
  blend: {
    color: {operation: 'add', srcFactor: 'dst-alpha', dstFactor: 'src'},
    alpha: {operation: 'subtract', srcFactor: 'src-alpha', dstFactor: 'src-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg8sint', writeMask: GPUColorWrite.GREEN}, {format: 'rg8unorm', writeMask: GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'greater-equal', failOp: 'decrement-clamp', depthFailOp: 'zero', passOp: 'keep'},
    stencilBack: {failOp: 'decrement-wrap', depthFailOp: 'zero', passOp: 'increment-clamp'},
    stencilReadMask: 2148648265,
    stencilWriteMask: 2781664855,
    depthBias: 1632017182,
    depthBiasSlopeScale: 393.56051434328407,
  },
  vertex: {
    module: shaderModule61,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 40,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 4, shaderLocation: 13},
          {format: 'uint8x2', offset: 4, shaderLocation: 6},
          {format: 'uint32x2', offset: 0, shaderLocation: 12},
          {format: 'snorm16x2', offset: 4, shaderLocation: 9},
          {format: 'unorm16x4', offset: 0, shaderLocation: 2},
          {format: 'uint32x3', offset: 0, shaderLocation: 3},
          {format: 'uint32x4', offset: 16, shaderLocation: 5},
        ],
      },
      {arrayStride: 172, stepMode: 'instance', attributes: []},
      {
        arrayStride: 712,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x2', offset: 88, shaderLocation: 15},
          {format: 'uint32x4', offset: 0, shaderLocation: 10},
          {format: 'float16x4', offset: 24, shaderLocation: 4},
          {format: 'sint8x4', offset: 124, shaderLocation: 14},
        ],
      },
      {arrayStride: 80, stepMode: 'instance', attributes: []},
      {arrayStride: 96, stepMode: 'instance', attributes: []},
      {arrayStride: 212, attributes: [{format: 'sint32x4', offset: 32, shaderLocation: 11}]},
      {arrayStride: 240, stepMode: 'instance', attributes: []},
      {
        arrayStride: 336,
        attributes: [
          {format: 'uint32x2', offset: 152, shaderLocation: 0},
          {format: 'sint8x2', offset: 74, shaderLocation: 1},
          {format: 'sint16x2', offset: 0, shaderLocation: 7},
          {format: 'uint32', offset: 40, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let gpuCanvasContext49 = canvas55.getContext('webgpu');
let bindGroupLayout98 = device3.createBindGroupLayout({
  label: '\u4b0f\u0c22',
  entries: [{binding: 464, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}],
});
try {
commandEncoder345.copyBufferToBuffer(buffer47, 146244, buffer49, 23556, 632);
} catch {}
try {
device3.queue.writeTexture({
  texture: texture131,
  mipLevel: 1,
  origin: {x: 118, y: 0, z: 1},
  aspect: 'all',
}, new Uint16Array(new ArrayBuffer(72)), /* required buffer size: 84_407 */
{offset: 911, bytesPerRow: 142, rowsPerImage: 196}, {width: 48, height: 0, depthOrArrayLayers: 4});
} catch {}
try {
  await promise95;
} catch {}
let commandEncoder370 = device2.createCommandEncoder({});
let querySet172 = device2.createQuerySet({type: 'occlusion', count: 2105});
let externalTexture176 = device2.importExternalTexture({label: '\u74d2\u00a5\u{1fd5e}\u0a48\u0fe6\u5930\u70e8\u9061', source: video17, colorSpace: 'srgb'});
try {
renderBundleEncoder179.setVertexBuffer(4, buffer68, 0, 497);
} catch {}
try {
commandEncoder216.resolveQuerySet(querySet65, 90, 62, buffer23, 18944);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture79,
  mipLevel: 0,
  origin: {x: 60, y: 0, z: 7},
  aspect: 'all',
}, arrayBuffer10, /* required buffer size: 624 */
{offset: 592}, {width: 24, height: 12, depthOrArrayLayers: 1});
} catch {}
let buffer81 = device2.createBuffer({size: 276765, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder371 = device2.createCommandEncoder({label: '\u{1fde0}\u0d89\u{1f8e7}\u{1fc66}'});
let commandBuffer84 = commandEncoder292.finish({});
let textureView440 = texture181.createView({aspect: 'all', format: 'rgba8unorm-srgb', baseMipLevel: 2});
let renderBundleEncoder190 = device2.createRenderBundleEncoder({
  label: '\u0dc6\ua85d',
  colorFormats: ['bgra8unorm', 'rgba8unorm', 'rgba8unorm-srgb', 'r8unorm', 'r8sint', 'rg8unorm', 'rgba8sint'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder123.setBindGroup(1, bindGroup105, new Uint32Array(1574), 93, 1);
} catch {}
try {
renderBundleEncoder87.setIndexBuffer(buffer43, 'uint32', 1_996, 827);
} catch {}
let textureView441 = texture238.createView({
  label: '\u274c\ubed0\ua3d8\u0e32\u5220\u2b23\u7a5a\u15a1\ub3f0\u{1f936}\u633f',
  format: 'bgra8unorm-srgb',
  baseArrayLayer: 0,
  arrayLayerCount: 1,
});
let externalTexture177 = device6.importExternalTexture({label: '\ufef6\u9909\u0143\u0432\u850a\u01da\u02a4', source: videoFrame4, colorSpace: 'display-p3'});
try {
renderBundleEncoder166.setPipeline(pipeline273);
} catch {}
try {
commandEncoder324.copyTextureToBuffer({
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 420 */
  offset: 420,
  buffer: buffer60,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder325.copyTextureToTexture({
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture189,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let bindGroup118 = device3.createBindGroup({
  label: '\u{1f833}\u5e63\u{1f75d}\u69ae\u{1fac3}\u0454\ud141\ud9e9',
  layout: bindGroupLayout98,
  entries: [{binding: 464, resource: externalTexture113}],
});
let commandEncoder372 = device3.createCommandEncoder({label: '\u0692\u6b7c\u90d4\udcea\u0f9b\ufaf6\u{1ff66}\u01b0\u{1ff01}\u7290\u{1fb3e}'});
let texture242 = gpuCanvasContext42.getCurrentTexture();
let textureView442 = texture151.createView({label: '\u{1fd0c}\u{1fdcf}\u34c4', format: 'bgra8unorm'});
let sampler166 = device3.createSampler({
  label: '\u{1f7e7}\ud5a7\u19ce\u{1f86a}\ubc58\u0c0a\ue236',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 45.24,
  lodMaxClamp: 50.87,
});
try {
commandEncoder315.clearBuffer(buffer47, 174148, 43976);
} catch {}
let canvas56 = document.createElement('canvas');
try {
window.someLabel = commandEncoder184.label;
} catch {}
let commandBuffer85 = commandEncoder264.finish({label: '\u0325\u0d4e\uccaa\u{1fa8f}\u{1f845}\u0078\ud384\uf378'});
let texture243 = device2.createTexture({
  label: '\u156e\u99ea\u0687\u5691\u325e\u{1fde2}\u{1f8dc}\uc799\u05fe\u{1fba3}\u5787',
  size: [360, 1, 246],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_SRC,
  viewFormats: ['rgba8sint', 'rgba8sint', 'rgba8sint'],
});
try {
renderBundleEncoder100.setBindGroup(2, bindGroup98);
} catch {}
try {
commandEncoder329.copyBufferToBuffer(buffer23, 209560, buffer43, 2896, 2732);
} catch {}
try {
commandEncoder136.resolveQuerySet(querySet153, 90, 495, buffer65, 7680);
} catch {}
try {
device2.queue.writeBuffer(buffer75, 5724, new DataView(new ArrayBuffer(18531)), 9848, 1264);
} catch {}
let bindGroupLayout99 = device0.createBindGroupLayout({label: '\ue626\u861a\ueb75\ubca9\u0fce\u0da8\u0a1a\u4b8c', entries: []});
let querySet173 = device0.createQuerySet({label: '\u00a5\u0a1a\u6998\u{1f7fc}\u383d\u0aad\u9de2', type: 'occlusion', count: 1191});
let sampler167 = device0.createSampler({
  label: '\u0686\ufbea\u{1fa65}\u0a04\u009d\u{1ff4a}\u308a\u{1f694}\u59ea\u7a79',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 99.83,
});
try {
renderPassEncoder6.executeBundles([renderBundle147, renderBundle73, renderBundle73, renderBundle69, renderBundle69, renderBundle149, renderBundle69, renderBundle117, renderBundle73, renderBundle107]);
} catch {}
try {
renderBundleEncoder50.drawIndexedIndirect(buffer0, 6_216);
} catch {}
let promise98 = device0.popErrorScope();
try {
commandEncoder278.copyTextureToTexture({
  texture: texture51,
  mipLevel: 0,
  origin: {x: 132, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture198,
  mipLevel: 6,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
},
{width: 10, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder350.clearBuffer(buffer34, 166064, 80980);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
try {
  await promise98;
} catch {}
let canvas57 = document.createElement('canvas');
let commandEncoder373 = device6.createCommandEncoder({label: '\u41da\u{1fdba}\u813a\ud1be\uc068\uf19b\u0482\u5781\u{1fb47}'});
let texture244 = gpuCanvasContext6.getCurrentTexture();
let renderBundleEncoder191 = device6.createRenderBundleEncoder({
  label: '\u04f4\u5fa4\u1540\uab9f\ufcb8',
  colorFormats: ['r16sint', 'rgba16sint', 'rgb10a2uint', 'rgb10a2uint'],
  sampleCount: 1,
});
try {
renderBundleEncoder157.setPipeline(pipeline273);
} catch {}
try {
commandEncoder373.copyBufferToTexture({
  /* bytesInLastRow: 464 widthInBlocks: 116 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 7344 */
  offset: 7344,
  buffer: buffer60,
}, {
  texture: texture179,
  mipLevel: 0,
  origin: {x: 20, y: 0, z: 0},
  aspect: 'all',
}, {width: 116, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline292 = await device6.createComputePipelineAsync({
  label: '\u0734\udeec\u1e90\uca44\u9727\u021d\u026b\u6775',
  layout: pipelineLayout40,
  compute: {module: shaderModule60, entryPoint: 'compute0', constants: {}},
});
let video59 = await videoWithData();
let commandEncoder374 = device6.createCommandEncoder({label: '\u1b17\u{1fd07}\u{1ff94}\u0c9a'});
try {
device6.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: img9,
  origin: { x: 25, y: 8 },
  flipY: true,
}, {
  texture: texture244,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline293 = await device6.createComputePipelineAsync({layout: pipelineLayout40, compute: {module: shaderModule60, entryPoint: 'compute0', constants: {}}});
video8.height = 237;
try {
canvas54.getContext('2d');
} catch {}
let bindGroup119 = device4.createBindGroup({label: '\u3c46\u7429', layout: bindGroupLayout67, entries: []});
let textureView443 = texture127.createView({label: '\u71c0\u0b16\u50ec\u9f36\u{1f62e}', baseMipLevel: 1});
let computePassEncoder185 = commandEncoder227.beginComputePass({label: '\u0874\u1df2\ubf7a\ufc88\u{1fce1}\u1885\u0e85\u83a3\ua7de\ud144'});
let renderBundleEncoder192 = device4.createRenderBundleEncoder({
  label: '\u08a7\ucaca\uee5d\u6325\uabf9',
  colorFormats: ['rgb10a2uint', 'rgba8sint', 'rg8unorm', 'rg11b10ufloat', 'rg8sint', 'rg8unorm'],
  stencilReadOnly: true,
});
try {
renderBundleEncoder131.setBindGroup(0, bindGroup114, new Uint32Array(776), 426, 0);
} catch {}
try {
device4.queue.writeBuffer(buffer56, 12440, new DataView(new ArrayBuffer(6575)), 1195);
} catch {}
try {
device4.queue.writeTexture({
  texture: texture166,
  mipLevel: 0,
  origin: {x: 14, y: 0, z: 0},
  aspect: 'all',
}, new Float32Array(arrayBuffer6), /* required buffer size: 338 */
{offset: 338, rowsPerImage: 32}, {width: 55, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline294 = device4.createRenderPipeline({
  label: '\u58d2\u{1f6e4}\ua0e0\u{1fc78}',
  layout: pipelineLayout26,
  multisample: {mask: 0xab98572f},
  fragment: {
  module: shaderModule50,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba8sint', writeMask: 0}, {
  format: 'rg8unorm',
  blend: {
    color: {operation: 'subtract', srcFactor: 'constant', dstFactor: 'constant'},
    alpha: {operation: 'add', srcFactor: 'constant', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}, {format: 'rg11b10ufloat', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rg8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule50,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 208,
        attributes: [
          {format: 'snorm8x4', offset: 12, shaderLocation: 5},
          {format: 'sint32x4', offset: 20, shaderLocation: 13},
          {format: 'unorm8x2', offset: 48, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 148,
        attributes: [
          {format: 'unorm16x2', offset: 40, shaderLocation: 11},
          {format: 'float16x4', offset: 52, shaderLocation: 6},
          {format: 'uint32x3', offset: 88, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 7},
          {format: 'unorm8x2', offset: 0, shaderLocation: 12},
        ],
      },
      {arrayStride: 52, stepMode: 'vertex', attributes: [{format: 'sint8x4', offset: 8, shaderLocation: 3}]},
      {arrayStride: 112, stepMode: 'instance', attributes: []},
      {arrayStride: 112, stepMode: 'instance', attributes: []},
      {arrayStride: 756, attributes: []},
      {arrayStride: 1324, attributes: []},
      {
        arrayStride: 92,
        stepMode: 'vertex',
        attributes: [
          {format: 'snorm16x4', offset: 60, shaderLocation: 0},
          {format: 'float16x4', offset: 8, shaderLocation: 14},
          {format: 'snorm16x4', offset: 8, shaderLocation: 2},
          {format: 'float32x3', offset: 8, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {cullMode: 'front'},
});
let canvas58 = document.createElement('canvas');
let textureView444 = texture76.createView({label: '\u0042\u01fe\u3f51\u{1f742}', baseMipLevel: 9, mipLevelCount: 1});
let renderBundleEncoder193 = device0.createRenderBundleEncoder({
  label: '\ud78d\uc1ab\u06f8\u{1ff8c}\u772e\ue96c\ua026\u0cce\u0555\u2a48\u07d5',
  colorFormats: ['rg16float', 'rgba16float'],
  depthReadOnly: true,
  stencilReadOnly: false,
});
try {
computePassEncoder96.setPipeline(pipeline142);
} catch {}
try {
renderPassEncoder20.end();
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline208);
} catch {}
try {
renderBundleEncoder29.drawIndirect(buffer5, 85_520);
} catch {}
let promise99 = device0.createComputePipelineAsync({
  label: '\u3775\u{1f760}\u47a9\u{1f86e}\u4668\u0547',
  layout: pipelineLayout23,
  compute: {module: shaderModule8, entryPoint: 'compute0'},
});
videoFrame0.close();
videoFrame1.close();
videoFrame2.close();
videoFrame3.close();
videoFrame4.close();
videoFrame5.close();
videoFrame6.close();
videoFrame7.close();
videoFrame8.close();
videoFrame9.close();
videoFrame10.close();
videoFrame11.close();
videoFrame12.close();
videoFrame13.close();
videoFrame14.close();
videoFrame15.close();
videoFrame16.close();
videoFrame17.close();
videoFrame18.close();
videoFrame19.close();
videoFrame20.close();
videoFrame21.close();
videoFrame22.close();
videoFrame23.close();
videoFrame24.close();
videoFrame25.close();
videoFrame26.close();
videoFrame27.close();
videoFrame28.close();
videoFrame29.close();
videoFrame30.close();
videoFrame31.close();
videoFrame32.close();
videoFrame33.close();
videoFrame34.close();
videoFrame35.close();
videoFrame36.close();
videoFrame37.close();
videoFrame38.close();
videoFrame39.close();
videoFrame40.close();
videoFrame41.close();
  log('the end')
  log(location);
  } catch (e) {
    log('error');
    log(e);
    log(e[Symbol.toStringTag]);
    log(e.stack);
    if (e instanceof GPUPipelineError) {
      log(`${e} - ${e.reason}`);
      
    } else if (e instanceof DOMException) {
      if (e.name === 'OperationError') {
      log(e.message);
      
      } else if (e.name === 'InvalidStateError') {
      } else {
        log(e);
        
      }
    } else if (e instanceof GPUValidationError) {
      
    } else if (e instanceof GPUOutOfMemoryError) {
      
    } else if (e instanceof TypeError) {
      log(e);
      
    } else {
      log('unexpected error type');
      log(e);
      
    }
  }
  debug('Pass')
    globalThis.testRunner?.notifyDone();
};
</script>